过滤器

时间 2020-08-05

标签过滤器繁體版

原文原文链接

---恢复内容开始---css

JavaWeb三大组件html

1. 都须要在web.xml中进行配置
Servlet
Listener(2个感知监听器不须要配置)
Filterjava

2. 过滤器
它会在一组资源（jsp、servlet、.css、.html等等）的前面执行！
它可让请求获得目标资源，也能够不让请求达到！
* 过滤器有拦截请求的能力！web

登陆：
容许它访问AServlet、BServlet、CServlet数据库

-------------------------------浏览器

过滤器如何编写缓存

1. 写一个类实现Filter接口（javax.servlet.Filter;）
2. 在web.xml中进行配置服务器

Filter接口session

void init(FilterConfig)
* 建立以后，立刻执行；Filter会在服务器启动时就建立！
void destory()
* 销毁以前执行！在服务器关闭时销毁
void doFilter(ServletRequest request,ServletResponse response,FilterChain filterchan)
* 每次过滤时都会执行app

Filter是单例的！

web.xml
<filter>
<filter-name>xxx</filter-name>
<filter-class>cn.itcast.web.filter.AFitler</fitler-class>
</filter>
<fitler-mapping>
<filter-name>xxx</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

-------------------------------

FilterConfig-->与ServletConfig类似
* 获取初始化参数：getInitParameter()
* 获取过滤器名称：getFilterName()
* 获取appliction：getServletContext()

FilterChain
* doFilter(ServletRequest, ServletResponse)：放行！
放行，就至关于调用了目标Servlet的service()方法！

-------------------------------

多过滤器

FilterChain#doFilter()方法：
执行目标资源，或是执行下一个过滤器！若是没有下一个过滤器那么执
行的是目标资源，若是有，那么就执行下一个过滤器！

-------------------------------

过滤器的四种拦截方式

<dispatcher>REQUEST</dispatcher>默认的！
<dispatcher>FORWARD</dispatcher>
<dispatcher>INCLUDE</dispatcher>
<dispatcher>ERROR</dispatcher>

在<filter-mapping>中进行配置!

-------------------------------

多个过滤器的执行顺序

<filter-mapping>的配置顺序决定了过滤器的执行顺序！

过滤器的应用场景：

（1）执行目标资源以前作预处理工做，例如设置编码，这种试一般都会放行，只是在目标资源执行以前作一些准备工做；

（2）经过条件判断是否放行，例如校验当前用户是否已经登陆，或者用户IP是否已经被禁用；

(3) 在目标资源执行后，作一些后续的特殊处理工做，例如把目标资源输出的数据进行处理；

过滤器应用案例

分ip统计网站的访问次数

ip	count
192.168.1.111	2
192.168.1.112	59

统计工做须要在全部资源以前都执行，那么就能够放到Filter中了。

咱们这个过滤器不打算作拦截操做！由于咱们只是用来作统计的。

用什么东西来装载统计的数据。Map<String,Integer>

整个网站只须要一个Map便可！

Map何时建立（使用ServletContextListener，在服务器启动时完成建立，并只在到ServletContext中），Map保存到哪里！（Map保存到ServletContext中！！！）

Map须要在Filter中用来保存数据
Map须要在页面使用，打印Map中的数据

1　说明

　　网站统计每一个IP地址访问本网站的次数。

2　分析

由于一个网站可能有多个页面，不管哪一个页面被访问，都要统计访问次数，因此使用过滤器最为方便。

由于须要分IP统计，因此能够在过滤器中建立一个Map，使用IP为key，访问次数为value。当有用户访问时，获取请求的IP，若是IP在Map中存在，说明之前访问过，那么在访问次数上加1，便可；IP在Map中不存在，那么设置次数为1。

把这个Map存放到ServletContext中！

3　代码

index.jsp

<body>

<h1>分IP统计访问次数</h1>

<tr>

</tr>

<c:forEach items="${applicationScope.ipCountMap }" var="entry">

<tr>

<td>${entry.key }</td>

<td>${entry.value }</td>

</tr>

</c:forEach>

</table>

</body>

IPFilter

public class IPFilter implements Filter {

private ServletContext context;

public void init(FilterConfig fConfig) throws ServletException {

context = fConfig.getServletContext();

Map<String, Integer> ipCountMap = Collections

.synchronizedMap(new LinkedHashMap<String, Integer>());

context.setAttribute("ipCountMap", ipCountMap);

}

@SuppressWarnings("unchecked")

public void doFilter(ServletRequest request, ServletResponse response,

FilterChain chain) throws IOException, ServletException {

HttpServletRequest req = (HttpServletRequest) request;

String ip = req.getRemoteAddr();

Map<String, Integer> ipCountMap = (Map<String, Integer>) context

.getAttribute("ipCountMap");

Integer count = ipCountMap.get(ip);

if (count == null) {

count = 1;

} else {

count += 1;

}

ipCountMap.put(ip, count);

context.setAttribute("ipCountMap", ipCountMap);

chain.doFilter(request, response);

}

public void destroy() {}

}

<display-name>IPFilter</display-name>

<filter-name>IPFilter</filter-name>

<filter-class>cn.itcast.filter.ip.IPFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>IPFilter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

粗粒度权限控制（拦截是否登陆、拦截用户名admin权限）

RBAC à 基于角色的权限控制

l tb_user

l tb_role

l tb_userrole

l tb_menu(增、删、改、查)

l tb_rolemenu

1　说明

咱们给出三个页面：index.jsp、user.jsp、admin.jsp。

l index.jsp：谁均可以访问，没有限制；

l user.jsp：只有登陆用户才能访问；

l admin.jsp：只有管理员才能访问。

2　分析

设计User类：username、password、grade，其中grade表示用户等级，1表示普通用户，2表示管理员用户。

当用户登陆成功后，把user保存到session中。

建立LoginFilter，它有两种过滤方式：

l 若是访问的是user.jsp，查看session中是否存在user；

l 若是访问的是admin.jsp，查看session中是否存在user，而且user的grade等于2。

3　代码

User.java

public class User {

private String username;

private String password;

private int grade;

…

}

为了方便，这里就不使用数据库了，因此咱们须要在UserService中建立一个Map，用来保存全部用户。Map中的key中用户名，value为User对象。

UserService.java

public class UserService {

private static Map<String,User> users = new HashMap<String,User>();

static {

users.put("zhangSan", new User("zhangSan", "123", 1));

users.put("liSi", new User("liSi", "123", 2));

}

public User login(String username, String password) {

User user = users.get(username);

if(user == null) return null;

return user.getPassword().equals(password) ? user : null;

}

<body>

<form action="<c:url value='/LoginServlet'/>" method="post">

用户名：<input type="text" name="username"/><br/>

密　码：<input type="password" name="password"/><br/>

</form>

</body>

index.jsp

<body>

<h3>${user.username }</h3>

<hr/>

<a href="<c:url value='/admin/admin.jsp'/>">管理员页面</a>

</body>

/user/user.jsp

<body>

<h3>${user.username }</h3>

<hr/>

</body>

/admin/admin.jsp

<body>

<h1>管理员页面</h1>

<h3>${user.username }</h3>

<hr/>

</body>

LoginServlet

public class LoginServlet extends HttpServlet {

public void doPost(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

request.setCharacterEncoding("utf-8");

response.setContentType("text/html;charset=utf-8");

String username = request.getParameter("username");

String password = request.getParameter("password");

UserService userService = new UserService();

User user = userService.login(username, password);

if(user == null) {

request.setAttribute("msg", "用户名或密码错误");

request.getRequestDispatcher("/login.jsp").forward(request, response);

} else {

request.getSession().setAttribute("user", user);

request.getRequestDispatcher("/index.jsp").forward(request, response);

}

LoginUserFilter.java

<display-name>LoginUserFilter</display-name>

<filter-name>LoginUserFilter</filter-name>

<filter-class>cn.itcast.filter.LoginUserFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>LoginUserFilter</filter-name>

<url-pattern>/user/*</url-pattern>

</filter-mapping>

public class LoginUserFilter implements Filter {

public void destroy() {}

public void init(FilterConfig fConfig) throws ServletException {}

public void doFilter(ServletRequest request, ServletResponse response,

FilterChain chain) throws IOException, ServletException {

response.setContentType("text/html;charset=utf-8");

HttpServletRequest req = (HttpServletRequest) request;

User user = (User) req.getSession().getAttribute("user");

if(user == null) {

response.getWriter().print("您尚未登陆");

return;

}

chain.doFilter(request, response);

}

LoginAdminFilter.java

<display-name>LoginAdminFilter</display-name>

<filter-name>LoginAdminFilter</filter-name>

<filter-class>cn.itcast.filter.LoginAdminFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>LoginAdminFilter</filter-name>

<url-pattern>/admin/*</url-pattern>

</filter-mapping>

public class LoginAdminFilter implements Filter {

public void destroy() {}

public void init(FilterConfig fConfig) throws ServletException {}

public void doFilter(ServletRequest request, ServletResponse response,

FilterChain chain) throws IOException, ServletException {

response.setContentType("text/html;charset=utf-8");

HttpServletRequest req = (HttpServletRequest) request;

User user = (User) req.getSession().getAttribute("user");

if(user == null) {

response.getWriter().print("您尚未登陆!");

return;

}

if(user.getGrade() < 2) {

response.getWriter().print("您的等级不够！");

return;

}

chain.doFilter(request, response);

}

禁用资源缓存

浏览器只是要缓存页面，这对咱们在开发时测试很不方便，因此咱们能够过滤全部资源，而后添加去除全部缓存！

public class NoCacheFilter extends HttpFilter {

public void doFilter(HttpServletRequest request,

HttpServletResponse response, FilterChain chain)

throws IOException, ServletException {

response.setHeader("cache-control", "no-cache");

response.setHeader("pragma", "no-cache");

response.setHeader("expires", "0");

chain.doFilter(request, response);

}

可是要注意，有的浏览器可能不会理会你的设置，仍是会缓存的！这时就要在页面中使用时间戳来处理了。

解决全站字符乱码（POST和GET中文编码问题）

servlet：

l POST：request.setCharacterEncoding(“utf-8”);

l GET：

String username = request.getParameter(“username”);
username = new String(username.getBytes(“ISO-8859-1”), “utf-8”);

1　说明

乱码问题：

l 获取请求参数中的乱码问题；

POST请求：request.setCharacterEncoding(“utf-8”)；
GET请求：new String(request.getParameter(“xxx”).getBytes(“iso-8859-1”), “utf-8”)；

l 响应的乱码问题：response.setContextType(“text/html;charset=utf-8”)。

基本上在每一个Servlet中都要处理乱码问题，因此应该把这个工做放到过滤器中来完成。

2　分析

其实全站乱码问题的难点就是处理GET请求参数的问题。

若是只是处理POST请求的编码问题，以及响应编码问题，那么这个过滤器就太！太！太简单的。

public class EncodingFilter extends HttpFilter {

public void doFilter(HttpServletRequest request,

HttpServletResponse response, FilterChain chain)

throws IOException, ServletException {

String charset = this.getInitParameter("charset");

if(charset == null || charset.isEmpty()) {

charset = "UTF-8";

}

request.setCharacterEncoding(charset);

response.setContentType("text/html;charset=" + charset);

chain.doFilter(request, response);

}

若是是POST请求，当执行目标Servlet时，Servlet中调用request.getParameter()方法时，就会根据request.setCharacterEncoding()设置的编码来转码！这说明在过滤器中调用request.setCharacterEncoding()方法会影响在目标Servlet中的request.getParameter()方法的行为！

可是若是是GET请求，咱们又如何能影响request.getParameter()方法的行为呢？这是很差作到的！咱们不可能先调用request.getParameter()方法获取参数，而后手动转码后，再施加在到request中！由于request只有getParameter()，而没有setParameter()方法。

处理GET请求参数编码问题，须要在Filter中放行时，把request对象给“调包”了，也就是让目标Servlet使用咱们“调包”以后的request对象。这说明咱们须要保证“调包”以后的request对象中全部方法都要与“调包”以前同样可使用，而且getParameter()方法还要有能力返回转码以后的参数

这可能让你想起了“继承”，可是这里不能用继承，而是“装饰者模式（Decorator Pattern）”！

下面是三种对a对象进行加强的手段：

l 继承：AA类继承a对象的类型：A类，而后重写fun1()方法，其中重写的fun1()方法就是被加强的方法。可是，继承必需要知道a对象的真实类型，而后才能去继承。若是咱们不知道a对象的确切类型，而只知道a对象是IA接口的实现类对象，那么就没法使用继承来加强a对象了；

l 装饰者模式：AA类去实现a对象相同的接口：IA接口，还须要给AA类传递a对象，而后在AA类中全部的方法实现都是经过代理a对象的相同方法完成的，只有fun1()方法在代理a对象相同方法的先后添加了一些内容，这就是对fun1()方法进行了加强；

l 动态代理：动态代理与装饰者模式比较类似，并且是经过反射来完成的。动态代理会在最后一天的基础增强中讲解，这里就再也不废话了。

对request对象进行加强的条件，恰好符合装饰者模式的特色！由于咱们不知道request对象的具体类型，但咱们知道request是HttpServletRequest接口的实现类。这说明咱们写一个类EncodingRequest，去实现HttpServletRequest接口，而后再把原来的request传递给EncodingRequest类！在EncodingRequest中对HttpServletRequest接口中的全部方法的实现都是经过代理原来的request对象来完成的，只有对getParameter()方法添加了加强代码！

JavaEE已经给咱们提供了一个HttpServletRequestWrapper类，它就是HttpServletRequest的包装类，但它作任何的加强！你可能会说，写一个装饰类，但不作加强，其目的是什么呢？使用这个装饰类的对象，和使用原有的request有什么分别呢？

HttpServletRequestWrapper类虽然是HttpServletRequest的装饰类，但它不是用来直接使用的，而是用来让咱们去继承的！当咱们想写一个装饰类时，还要对全部不须要加强的方法作一次实现是很心烦的事情，但若是你去继承HttpServletRequestWrapper类，那么就只须要重写须要加强的方法便可了。

3　代码

EncodingRequest

public class EncodingRequest extends HttpServletRequestWrapper {

private String charset;

public EncodingRequest(HttpServletRequest request, String charset) {

super(request);

this.charset = charset;

}

public String getParameter(String name) {

HttpServletRequest request = (HttpServletRequest) getRequest();

String method = request.getMethod();

if(method.equalsIgnoreCase("post")) {

try {

request.setCharacterEncoding(charset);

} catch (UnsupportedEncodingException e) {}

} else if(method.equalsIgnoreCase("get")) {

String value = request.getParameter(name);

try {

value = new String(name.getBytes("ISO-8859-1"), charset);

} catch (UnsupportedEncodingException e) {

}

return value;

}

return request.getParameter(name);

}

EncodingFilter

public class EncodingFilter extends HttpFilter {

public void doFilter(HttpServletRequest request,

HttpServletResponse response, FilterChain chain)

throws IOException, ServletException {

String charset = this.getInitParameter("charset");

if(charset == null || charset.isEmpty()) {

charset = "UTF-8";

}

response.setCharacterEncoding(charset);

response.setContentType("text/html;charset=" + charset);

EncodingRequest res = new EncodingRequest(request, charset);

chain.doFilter(res, response);

}

web.xml

<filter-name>EncodingFilter</filter-name>

<filter-class>cn.itcast.filter.EncodingFilter</filter-class>

<init-param>

<param-name>charset</param-name>

<param-value>UTF-8</param-value>

</init-param>

</filter>

<filter-mapping>

<filter-name>EncodingFilter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

页面静态化

1　说明

你到“当当”搜索最多的是什么分类，没错，就是Java分类！你猜猜，你去搜索Java分类时，“当当”会不会去查询数据库呢？固然会了，不查询数据库怎么获取Java分类下的图书呢！其实天天都有不少人去搜索“Java分类”的图书，每次都去访问数据库，这会有性能上的缺失！若是是在访问静态页面（html）那么就会快的多了！静态页面自己就比动态页面快不少倍，并且动态页面老是要去数据库查询，这会更加下降速度！

页面静态化是把动态页面生成的html保存到服务器的文件上，而后再有相同请求时，再也不去执行动态页面，而是直接给用户响应上次已经生成的静态页面。并且静态页面还有助与搜索引擎找到你！

2　查看图书分类

咱们先来写一个小例子，用来查看不一样分类的图书。而后咱们再去思考如何让动态页面静态化的问题。

index.jsp

<body>

<a href="<c:url value='/BookServlet?category=1'/>">JavaSE分类</a><br/>

<a href="<c:url value='/BookServlet?category=2'/>">JavaEE分类</a><br/>

<a href="<c:url value='/BookServlet?category=3'/>">Java框架分类</a><br/>

</body>

BookServlet.java

public class BookServlet extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

BookService bookService = new BookService();

List<Book> bookList = null;

String param = request.getParameter("category");

if(param == null || param.isEmpty()) {

bookList = bookService.findAll();

} else {

int category = Integer.parseInt(param);

bookList = bookService.findByCategory(category);

}

request.setAttribute("bookList", bookList);

request.getRequestDispatcher("/show.jsp").forward(request, response);

}

show.jsp

<tr>

</tr>

<c:forEach items="${bookList }" var="book">

<tr>

<td>${book.bname }</td>

<td>${book.price }</td>

<td>

<c:choose>

<c:when test="${book.category eq 1}"><p style="color:red;">JavaSE分类</p></c:when>

<c:when test="${book.category eq 2}"><p style="color:blue;">JavaEE分类</p></c:when>

<c:when test="${book.category eq 3}"><p style="color:green;">Java框架分类</p></c:when>

</c:choose>

</td>

</tr>

</c:forEach>

</table>

3分析

　　咱们的目标是在用户第一次访问页面时生成静态页面，而后让请求重定向到静态页面上去。当用户再次访问时，直接重定向到静态页面上去。

咱们须要为不一样的请求生成静态页面，例如用户访问BookServlet?category=1时，咱们要生成静态页面，当用户访问BookServlet?category=2时，也要生成静态页面。即不一样的参数生成不一样的静态页面！

咱们可使用category为key，静态页面的路径为value，保存到一个Map中，而后再把Map保存到ServletContext中。没有对应的静态页面时，咱们生成静态页面，再重定向到静态页面，若是存在静态页面，那么直接重定向便可。

StaticResponse.java

public class StaticResponse extends HttpServletResponseWrapper {

private PrintWriter pw;

public StaticResponse(HttpServletResponse response, String filepath)

throws FileNotFoundException, UnsupportedEncodingException {

super(response);

pw = new PrintWriter(filepath, "UTF-8");

}

public PrintWriter getWriter() throws IOException {

return pw;

}

public void close() throws IOException {

pw.close();

}

StaticFilter.java

public class StaticFilter implements Filter {

private ServletContext sc;

public void destroy() {

}

public void doFilter(ServletRequest request, ServletResponse response,

FilterChain chain) throws IOException, ServletException {

HttpServletRequest req = (HttpServletRequest) request;

HttpServletResponse res = (HttpServletResponse) response;

String key = "key_" + request.getParameter("category");

Map<String,String> map = (Map<String, String>) sc.getAttribute("pages");

if(map == null) {

map = new HashMap<String,String>();

sc.setAttribute("pages", map);

}

if(map.containsKey(key)) {

res.sendRedirect(req.getContextPath() + "/staticPages/" + map.get(key));

return;

}

String html = key + ".html";

String realPath = sc.getRealPath("/staticPages/" + html);

StaticResponse sr = new StaticResponse(res, realPath);

chain.doFilter(request, sr);

sr.close();

res.sendRedirect(req.getContextPath() + "/staticPages/" + html);

map.put(key, html);

}

public void init(FilterConfig fConfig) throws ServletException {

this.sc = fConfig.getServletContext();

}

过滤器

过滤器应用案例

分ip统计网站的访问次数

粗粒度权限控制（拦截是否登陆、拦截用户名admin权限）

1 说明

2 分析

禁用资源缓存

解决全站字符乱码（POST和GET中文编码问题）

页面静态化

1　说明

2　分析