过滤器

问题：Servlet 的作用是针对浏览器发起的请求，进行请求的 处理。通过 Servlet 技术我们可以灵活的进行请求的处理，但是我们不但要对请求记性处理，我们还需对服务器的资源进行统一的管理 ，比如请求编码格式的统一设置，资源的统一分配等等，这个时候该怎么办呢？

解决：使用过滤器。

作用：对服务器资源进行管理 保护 servlet

过滤器的使用

  • 创建一个实现了Filter接口的普通java类

  • 覆写接口的方法

    • init方法:服务器启动即执行。资源初始化
    • doFilter方法:拦截请求的方法，在此方法中可以对资源实现管理。
    • destory方法：服务器关闭执行。
    • 注意：需要手动对请求进行放行。chain.doFilter(request, response);

  • 在web.xml中配置过滤器

    1
    2
    3
    4
    5
    6
    7
    8
    <filter>
    	<filter-name>myFilter</filter-name>
    	<filter-class>com.bjsxt.filter.MyFilter</filter-class>
    </filter>
    <filter-mapping>
    	<filter-name>myFilter</filter-name>
    	<url-pattern>/*</url-pattern>
    </filter-mapping>

  • 注意:

    • url-pattern:/* 表示拦截所有的请求。
    • url-pattern:*.do表示所有以.do结尾的请求。一般是用来进行模块拦截处理。
    • url-pattern:/ts 表示拦截指定url的请求。针对某个servlet的请求进行拦截，保护servlet。

  • 过滤器的生命周期：服务器启动到服务器关闭。

  • 执行:

    • 浏览器发起请求到服务器，服务器接收到请求后，根据URI信息在web.xml中找到对应的过滤器执行doFilter方法，该方法对此次请求进行处理后如果符合要求则放行，放行后如果还有符合要求的过滤则继续进行过滤，找到执行对应的servlet进行请求处理。servlet对请求处理完毕后，也就service方法结束了。还需继续返回相应的doFilter方法继续执行。

  • 案例：

    • 统一编码格式设置。
    • session管理
    • 权限管理
    • 资源管理（统一水印，和谐词汇等等）

  • 总结:过滤器程序员声明和配置，服务器根据请求中的uri信息调用。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    package com.kylin.filter;

    import java.io.IOException;

    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    public class MyFilter implements Filter{
    		
    	@Override
    	public void destroy() {
    		System.out.println("我被destroy");
    		
    	}@Override
    	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    			throws IOException, ServletException {
    		System.out.println("MyFilter.doFilter(我被执行了)");
    		//设置编码格式
    		request.setCharacterEncoding("utf-8");
    		response.setContentType("text/html;charset=utf-8");
    		//判断session
    			HttpSession hs=((HttpServletRequest) request).getSession();
    			if(hs.getAttribute("user")==null){
    				((HttpServletResponse)response).sendRedirect("/a/login.jsp");
    			}else{
    				//放行
    				chain.doFilter(request, response);
    			}
    		System.out.println("MyFilter.doFilter(我被执行了2)");
    	}@Override
    	public void init(FilterConfig filterConfig) throws ServletException {
    		System.out.println("我被init");
    		
    	}
    }

    监听器

问题：在 Servlet技术中我们学习了request、session，application作用域对象，其主要作用是实现数据的在不同场景中的灵活流转。但是数据的具体流转过程我们是看不到的，比如作用域对象是什么时候创建和销毁的，数据是什么时候存取，改变和删除的。因为具体的流转过程看不到，所以也就无法再指定的时机对数据和对象进行操作，比如 session 销毁的时候，在线人数-1。

解决：使用监听器

概念：Servlet 监听器是 Servlet 规范中定义的一种特殊类，用 于监听 ServletContext、HttpSession 和 ServletRequest 等域对象的创建与销毁事件，以及监听这些域对象中属性发生修改的事件。

监听器的使用

  • 使用:创建一个实现了指定接口的java类
  • 监听request—>ServletRequestListener 监听request对象的创建和销毁
    • requestInitialized(ServletRequestEvent sre)//创建
    • requestDestroyed(ServletRequestEvent sre)//销毁
    • 注意:形参可以获取监听的request对象 sre.getServletRequest();
  • 监听request—>ServletRequestAttributeListener 监听request作用域数据的变更。
    • attributeAdded(ServletRequestAttributeEvent srae)
    • attributeRemoved(ServletRequestAttributeEvent srae)
    • attributeReplaced(ServletRequestAttributeEvent srae)
    • 注意：形参可以获取被监听的数据
      • srae.getName() 获取监听数据的键
      • srae.getValue() 获取监听数据的值
  • 监听session—>HttpSessionListener 监听session的创建和销毁
    • sessionCreated(HttpSessionEvent se) 创建
    • sessionDestroyed(HttpSessionEvent se) 销毁
    • 注意：形参可以获取被监听的session对象 se.getSession();
  • 监听session—>HttpSessionAttributeListener 监听session数据的变更
    • attributeAdded(HttpSessionBindingEvent event)
    • attributeRemoved(HttpSessionBindingEvent event)
    • attributeReplaced(HttpSessionBindingEvent event)
    • 注意:形参可以获取被监听的数据
      • event.getName() 获取数据的键名
      • event.getValue() 获取数据的值
  • 监听application—>ServletContextListener 监听application对象的初始化和销毁
    • contextInitialized(ServletContextEvent sce) 初始化 服务器启动
    • contextDestroyed(ServletContextEvent sce) 销毁 服务器关闭
    • 注意：形参可以获取当前application对象。sce.getServletContext();
  • 监听application—>ServletContextAttributeListener 监听数据的变更
    • attributeAdded(ServletContextAttributeEvent event)
    • attributeRemoved(ServletContextAttributeEvent event)
    • attributeReplaced(ServletContextAttributeEvent event)
    • 注意：形参可以获取当前监听的数据
      • event.getName() 获取数据的键名
      • event.getValue() 获取数据的值
  • 总结
    • 实现接口名为（Servlet+作用域对象+Listener）的方法都是对此作用域对象的创建和销毁的监听。形参可以获取到当前的作用域对象
    • 实现接口名为（Servlet+作用域对象+AttributeListener）的方法都是此作用域数据的增加，移除，替换的监听。形参可以通过getName()和getValue()分别获取到数据的键名和值
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
      92
      93
      94
      95
      96
      97
      98
      99
      100
      101
      102
      103
      package com.bjsxt.listener;

      import javax.servlet.ServletContextAttributeEvent;
      import javax.servlet.ServletContextAttributeListener;
      import javax.servlet.ServletContextEvent;
      import javax.servlet.ServletContextListener;
      import javax.servlet.ServletRequestAttributeEvent;
      import javax.servlet.ServletRequestAttributeListener;
      import javax.servlet.ServletRequestEvent;
      import javax.servlet.ServletRequestListener;
      import javax.servlet.http.HttpSessionAttributeListener;
      import javax.servlet.http.HttpSessionBindingEvent;
      import javax.servlet.http.HttpSessionEvent;
      import javax.servlet.http.HttpSessionListener;

      public class MyListener implements ServletRequestListener,ServletRequestAttributeListener,HttpSessionListener,HttpSessionAttributeListener,ServletContextListener,ServletContextAttributeListener{
      	//request对象销毁
      	@Override
      	public void requestDestroyed(ServletRequestEvent sre) {
      		System.out.println("我被销毁了");
      		
      	}
      	//request对象创建
      	@Override
      	public void requestInitialized(ServletRequestEvent sre) {
      		System.out.println("我被创建了");
      		
      	}
      	//监听request作用域数据的添加
      	@Override
      	public void attributeAdded(ServletRequestAttributeEvent srae) {
      		
      		System.out.println("request中增加了一条数据-"+srae.getName()+":"+srae.getValue());
      		
      	}
      	@Override
      	public void attributeRemoved(ServletRequestAttributeEvent srae) {
      		// TODO Auto-generated method stub
      		
      	}
      	@Override
      	public void attributeReplaced(ServletRequestAttributeEvent srae) {
      		// TODO Auto-generated method stub
      		
      	}
      /*------------------------------------------------------------------------------*/
      	//监听session的创建
      	@Override
      	public void sessionCreated(HttpSessionEvent se) {
      		System.out.println("session被创建了");
      		
      	}
      	//监听session的销毁
      	@Override
      	public void sessionDestroyed(HttpSessionEvent se) {
      		System.out.println("session被销毁了");
      		
      	}
      	//监听session数据的表更
      	@Override
      	public void attributeAdded(HttpSessionBindingEvent event) {
      		System.out.println("session中增加了一条数据"+event.getName()+":"+event.getValue());
      	}
      	@Override
      	public void attributeRemoved(HttpSessionBindingEvent event) {
      		// TODO Auto-generated method stub
      		
      	}
      	@Override
      	public void attributeReplaced(HttpSessionBindingEvent event) {
      		// TODO Auto-generated method stub
      		
      	}
      /*------------------------------------------------------------------------------*/
      	@Override
      	public void contextInitialized(ServletContextEvent sce) {
      		System.out.println("application对象被初始化了");
      		
      	}
      	@Override
      	public void contextDestroyed(ServletContextEvent sce) {
      		System.out.println("application对象被销毁了");
      		
      	}
      	//监听application的数据变更
      	@Override
      	public void attributeAdded(ServletContextAttributeEvent event) {
      		System.out.println("application中存储了数据:"+event.getName()+":"+event.getValue());
      		
      	}
      	@Override
      	public void attributeRemoved(ServletContextAttributeEvent event) {
      		// TODO Auto-generated method stub
      		
      	}
      	@Override
      	public void attributeReplaced(ServletContextAttributeEvent event) {
      		// TODO Auto-generated method stub
      		
      	}
      		
      	
      }