Filter过滤器和Listener监听器并且制定初始化参数
filter过滤器是什么？
1、Filter 过滤器它是 JavaWeb 的三大组件之一。三大组件分别是：Servlet 程序、Listener 监听器、Filter 过滤器 2、Filter 过滤器它是 JavaEE 的规范。也就是接口 3、Filter 过滤器它的作用是：拦截请求，过滤响应。
拦截的场景是什么？
拦截请求常见的应用场景有： 1、权限检查 2、日记操作 3、事务管理 ……等等
filter的工作流程
Filter的初体验：
首先在你的web工程下，有一个限制的目录，这个目录下的所有资源（html页面，jpg图片，jsp文件等等）都必须是用户登陆后才能允许访问
思考：根据我们之前学过的内容，我们知道用户登陆之后都会把用户的登陆信息保存到session域中，所以要检查用户是否登陆，可以判断Session中是否含有用户登陆信息即可
我们使用Filter后端要实现Filter接口 Filter是Javax.servlet中的Filter接口
Filter的代码:
AdminServlet类
public class AdminFil implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException { } /** * doFilter 方法，专门用于拦截请求。可以做权限检查 * @param servletRequest * @param servletResponse * @param filterChain * @throws IOException * @throws ServletException */ @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest; HttpSession session = httpServletRequest.getSession(); //获取session中的user用户 Object user = session.getAttribute("user"); // 如果等于 null，说明还没有登录 if(user == null){ // 没有登陆就继续登陆 servletRequest.getRequestDispatcher("/login.jsp").forward(servletRequest,servletResponse); }else { // 让程序继续往下访问用户的目标资源 filterChain.doFilter(servletRequest,servletResponse); } } @Override public void destroy() { } }
web.xml 中的配置：
<!--filter 标签用于配置一个 Filter 过滤器--> <filter> <!--给 filter 起一个别名--> <filter-name>AdminFilter</filter-name> <!--配置 filter 的全类名--> <filter-class>web.AdminFile</filter-class> </filter> <!--filter-mapping 配置 Filter 过滤器的拦截路径--> <filter-mapping> <!--filter-name 表示当前的拦截路径给哪个 filter 使用--> <filter-name>AdminFilter</filter-name> <!-- url-pattern 配置拦截路径 / 表示请求地址为：http://ip:port/工程路径/ 映射到 IDEA 的 web 目录 /admin/* 表示请求地址为：http://ip:port/工程路径/admin/* --> <url-pattern>/admin/*</url-pattern> </filter-mapping>
上面就是如果你访问资源界面在/admin下那么久不能那直接访问,因为url-pattern指定了/admin/*下面的所有资源都被拦截器拦截
登陆界面:
login.jsp
<form action="/loginServlet" method="get"> 用户名:<input type="text" name="username"><br/> 密码: <input type="password" name="pwd"> <input type="submit" value="提交"> </form>
登陆的后端代码
AdminServlet
@Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { resp.setContentType("text/html; charset=UTF-8"); String username = req.getParameter("username"); String pwd = req.getParameter("pwd"); if("wzg168".equals(username) && "123456".equals(pwd)){ System.out.println(1111); //登陆成功 //登场成功会生产一个session,我们队session中填充一个user值用来后续过滤判断 req.getSession().setAttribute("user",username); resp.getWriter().write("登场成功"); }else { req.getRequestDispatcher("/login.jsp").forward(req,resp); } }
登陆的servlet
<servlet>
<servlet-name>LoginServer</servlet-name>
<servlet-class>web.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>LoginServer</servlet-name>
<url-pattern>/loginServlet</url-pattern>
</servlet-mapping>
上面就是一个完整的登陆经过拦截器的
Filter的注解方式
@WebFilter
上面是经过xml的配置来使用Filter的过滤在所有的请求前都生效,我们可以使用注解@WebFilter来让所有的请求前都经过这个类而不需要xml的配置
@WebFilter("/*") //访问所有资源之前，都会执行该过滤器
public class Filter implements javax.servlet.Filter {
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("This is init");
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
System.out.println("This is doＦile");
String name1 = request.getParameter("name");
System.out.println(name1);
if(name1.length() != 4){
System.out.println("This is Error");
}
request.getRequestDispatcher("index.jsp").forward(request,response);
}
public void destroy() {
System.out.println("This is 销毁");
}
}
Filter 的生命周期
Filter 的生命周期包含几个方法 1、构造器方法 2、init 初始化方法 第 1，2 步，在 web 工程启动的时候执行（Filter 已经创建） 3、doFilter 过滤方法 第 3 步，每次拦截到请求，就会执行 4、destroy 销毁 第 4 步，停止 web 工程的时候，就会执行（停止 web 工程，也会销毁 Filter 过滤器）
FilterConfig 类
FilterConfig 类见名知义，它是 Filter 过滤器的配置文件类。
Tomcat 每次创建 Filter 的时候，也会同时创建一个 FilterConfig 类，这里包含了 Filter 配置文件的配置信息。
FilterConfig的作用
FilterConfig 类的作用是获取 filter 过滤器的配置内容 1、获取 Filter 的名称 filter-name 的内容 2、获取在 Filter 中配置的 init-param 初始化参数 3、获取 ServletContext 对象
java代码:
我们在后端实现了Filter类中实现init方法中
@Override public void init(FilterConfig filterConfig) throws ServletException { System.out.println("Filter的init(FilterConfig)的初始化"); //获取Filter的名称filter-name的内容是:filter-name的值是 System.out.println("file-name的值是:"+filterConfig.getFilterName()); //获取在 web.xml 中配置的 init-param 初始化参数 System.out.println("初始化参数url的值是:"+filterConfig.getInitParameter("url")); //3:获取ServletContent对象 System.out.println(filterConfig.getServletContext()); }
web.xml配置
在原先的Filter配置中添加init-param
<!--filter 标签用于配置一个 Filter 过滤器-->
<filter>
<!--给 filter 起一个别名-->
<filter-name>AdminFilter</filter-name>
<!--配置 filter 的全类名-->
<filter-class>web.AdminFil</filter-class>
<init-param>
<param-name>username</param-name>
<param-value>root</param-value>
</init-param>
<init-param>
<param-name>url</param-name>
<param-value>jdbc:mysql://localhost3306/test</param-value>
</init-param>
</filter>
FilterConfig我们主要是在实现类中的init方法中实现来对filter的配置的提前获取
FilterChain 过滤器链
Filter 过滤器
Chain 链， 链条
FilterChain 就是过滤器链（多个过滤器如何一起工作）
FilterChina 过滤器就相当于python的装饰器,一层一层包裹的来执行
比如有两层过滤器,A和B,每个过滤器分为开始层和结束层, A在先执行完开始层再去执行B的开始层,然后执行B的结束层,在执行A的结束层
比如我们在后端定义两个Filter实现类
Filter1
public class Filter1 implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException { } @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { System.out.println("Filter1前置代码"); filterChain.doFilter(servletRequest,servletResponse); System.out.println("Filter1 后置代码"); } @Override public void destroy() { } }
Filter2
public class Filter2 implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException { } @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { System.out.println("Filter2的前置代码"); filterChain.doFilter(servletRequest,servletResponse); System.out.println("Filter2 的后置代码"); } @Override public void destroy() { } }
然后在web.xml中配置
<filter>
<filter-name>Filter1</filter-name>
<filter-class>Filter.Filter1</filter-class>
</filter>
<filter-mapping>
<filter-name>Filter1</filter-name>
<url-pattern>/target.jsp</url-pattern>
</filter-mapping>
<filter>
<filter-name>Filter2</filter-name>
<filter-class>Filter.Filter2</filter-class>
</filter>
<filter-mapping>
<filter-name>Filter2</filter-name>
<url-pattern>/target.jsp</url-pattern>
</filter-mapping>
定义拦截的是target.jsp 那么我们就随意定义一个target.jsp
输出结果是
这个时候就可以看到是一层一层的执行的,
Filter过滤器连的执行先后顺序
并且控制Filter拦截器的执行的先后顺序是在web.xml的Filter配置位置,哪个Filter的实现类在上面就先执行哪个
Filter 的拦截路径
精确匹配
<url-pattern>/target.jsp</url-pattern> 以上配置的路径，表示请求地址必须为：http://ip:port/工程路径/target.jsp
-目录匹配
<url-pattern>/admin/*</url-pattern> 以上配置的路径，表示请求地址必须为：http://ip:port/工程路径/admin/*
后缀名匹配
<url-pattern>*.html</url-pattern> 以上配置的路径，表示请求地址必须以.html 结尾才会拦截到 <url-pattern>*.do</url-pattern> 以上配置的路径，表示请求地址必须以.do 结尾才会拦截到 <url-pattern>*.action</url-pattern> 以上配置的路径，表示请求地址必须以.action 结尾才会拦截到 Filter 过滤器它只关心请求的地址是否匹配，不关心请求的资源是否存在！！！
给我们写的Book项目进行Filter对后台管理进行访问过滤
ManagerFilter
public class ManagerFilter implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException { } @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest; HttpSession session = httpServletRequest.getSession(); Object user = session.getAttribute("user"); if(user == null){ servletRequest.getRequestDispatcher("/pages/user/login.jsp").forward(servletRequest,servletResponse); }else{ filterChain.doFilter(servletRequest,servletResponse); } } @Override public void destroy() { } }
web.xml配置
<filter>
<filter-name>ManagerFilter</filter-name>
<filter-class>Filter.ManagerFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>ManagerFilter</filter-name>
<url-pattern>/pages/manager/*</url-pattern>
<url-pattern>/man/BookServlet</url-pattern><!--对url请求的servlet地址也过滤-->
</filter-mapping>
过滤器细节：
1. web.xml配置
<filter> <filter-name>demo1</filter-name> <filter-class>cn.itcast.web.filter.FilterDemo1</filter-class> </filter> <filter-mapping> <filter-name>demo1</filter-name> <!-- 拦截路径 --> <url-pattern>/*</url-pattern> </filter-mapping>
2. 过滤器执行流程 1. 执行过滤器 2. 执行放行后的资源 3. 回来执行过滤器放行代码下边的代码 3. 过滤器生命周期方法 1. init:在服务器启动后，会创建Filter对象，然后调用init方法。只执行一次。用于加载资源 2. doFilter:每一次请求被拦截资源时，会执行。执行多次 3. destroy:在服务器关闭后，Filter对象被销毁。如果服务器是正常关闭，则会执行destroy方法。只执行一次。用于释放资源 4. 过滤器配置详解 * 拦截路径配置： 1. 具体资源路径： /index.jsp 只有访问index.jsp资源时，过滤器才会被执行 2. 拦截目录： /user/* 访问/user下的所有资源时，过滤器都会被执行 3. 后缀名拦截： *.jsp 访问所有后缀名为jsp资源时，过滤器都会被执行 4. 拦截所有资源：/* 访问所有资源时，过滤器都会被执行 * 拦截方式配置：资源被访问的方式 * 注解配置： * 设置dispatcherTypes属性 1. REQUEST：默认值。浏览器直接请求资源 2. FORWARD：转发访问资源 3. INCLUDE：包含访问资源 4. ERROR：错误跳转资源 5. ASYNC：异步访问资源 * web.xml配置 * 设置<dispatcher></dispatcher>标签即可 5. 过滤器链(配置多个过滤器) * 执行顺序：如果有两个过滤器：过滤器1和过滤器2 1. 过滤器1 2. 过滤器2 3. 资源执行 4. 过滤器2 5. 过滤器1 * 过滤器先后顺序问题： 1. 注解配置：按照类名的字符串比较规则比较，值小的先执行 * 如： AFilter 和 BFilter，AFilter就先执行了。 2. web.xml配置： <filter-mapping>谁定义在上边，谁先执行
* 事件监听机制
* 事件 ：一件事情
* 事件源 ：事件发生的地方
* 监听器 ：一个对象
* 注册监听：将事件、事件源、监听器绑定在一起。 当事件源上发生某个事件后，执行监听器代码
监听事物处理机制,比如我们有一个点击按钮可以用到这个监听按钮
ServletContextListener:监听ServletContext对象的创建和销毁
* 方法：
* void contextDestroyed(ServletContextEvent sce) ：ServletContext对象被销毁之前会调用该方法
* void contextInitialized(ServletContextEvent sce) ：ServletContext对象创建后会调用该方法
* 步骤：
1. 定义一个类，实现ServletContextListener接口 2. 复写方法 3. 配置 1. web.xml <listener> <listener-class>cn.itcast.web.listener.ContextLoaderListener</listener-class> </listener> * 指定初始化参数<context-param> 2. 注解： * @WebListener
web.xml中的context-param参数是设置全局参数的
xml中配置监听类
<!-- 配置监听器-->
<listener>
<listener-class>com.spring.Listener.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>namespace</param-name>
<param-value>/WEB-INF/classes/applicationContext.xml</param-value>
</context-param>
public class ContextLoaderListener implements ServletContextListener { /** * 监听ServletContext类创建,ServletContext对象服务器启动后自动创建 * @param sce */ public void contextInitialized(ServletContextEvent sce) { ServletContext servletContext = sce.getServletContext(); String namespace = servletContext.getInitParameter("namespace"); // 获取配置文件中的初始化参数 System.out.println(namespace); System.out.println("这个对象被创建,服务器启动后自动创建"); } /** * 在服务关闭后,ServletContext对象被销毁,当服务关闭后该方法被调用 * @param sce */ public void contextDestroyed(ServletContextEvent sce) { System.out.println("这个对象被关闭,服务器关闭后自动创建"); } }
我们可以使用监听器来加载配置文件
现在src下创建一个applicationContext.xml配置文件
然后在web.xml中配置
<!-- 配置监听器--> <listener> <listener-class>com.spring.Listener.ContextLoaderListener</listener-class> </listener> <context-param> <param-name>namespace</param-name> <param-value>/WEB-INF/classes/applicationContext.xml</param-value> </context-param>
监听类
public class ContextLoaderListener implements ServletContextListener { /** * 监听ServletContext类创建,ServletContext对象服务器启动后自动创建 * @param sce */ public void contextInitialized(ServletContextEvent sce) { //加载资源文件 //获取ServletContext对象 ServletContext servletContext = sce.getServletContext(); //加载资源 String namespace = servletContext.getInitParameter("namespace"); // 获取配置文件中的初始化参数 //3:获取真实路径 String realPath = servletContext.getRealPath(namespace); try { FileInputStream fis = new FileInputStream(realPath); System.out.println(fis); } catch (FileNotFoundException e) { e.printStackTrace(); } System.out.println("这个对象被创建,服务器启动后自动创建"); } /** * 在服务关闭后,ServletContext对象被销毁,当服务关闭后该方法被调用 * @param sce */ public void contextDestroyed(ServletContextEvent sce) { System.out.println("这个对象被关闭,服务器关闭后自动创建"); } }
xml中配置Listener可以使用注解@WebListener来完成
注解：
* @WebListener
直接在类中使用注解
@WebListener //配置注解监听
public class ContextLoaderListener implements ServletContextListener {
/**
* 监听ServletContext类创建,ServletContext对象服务器启动后自动创建
* @param sce
*/
public void contextInitialized(ServletContextEvent sce) {
//加载资源文件
//获取ServletContext对象
ServletContext servletContext = sce.getServletContext();
//加载资源
String namespace = servletContext.getInitParameter("namespace"); // 获取配置文件中的初始化参数
//3:获取真实路径
String realPath = servletContext.getRealPath(namespace);
try {
FileInputStream fis = new FileInputStream(realPath);
System.out.println(fis);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
System.out.println("这个对象被创建,服务器启动后自动创建");
}
/**
* 在服务关闭后,ServletContext对象被销毁,当服务关闭后该方法被调用
* @param sce
*/
public void contextDestroyed(ServletContextEvent sce) {
System.out.println("这个对象被关闭,服务器关闭后自动创建");
}
}
<!-- 配置监听器--> <!-- <listener>--> <!-- <listener-class>com.spring.Listener.ContextLoaderListener</listener-class>--> <!-- </listener>--> <!-- 配置全局参数--> <context-param> <param-name>namespace</param-name> <param-value>/WEB-INF/classes/applicationContext.xml</param-value> </context-param>
Servlet的初始化参数
在web.xml中配置参数<context-param>
.
<!-- 配置全局参数--> <context-param> <param-name>namespace</param-name> <param-value>/WEB-INF/classes/applicationContext.xml</param-value> </context-param>
可以在类中通过ServletContext类来获取参数信息
//获取ServletContext对象
ServletContext servletContext = sce.getServletContext();
String namespace = servletContext.getInitParameter("namespace"); // 获取配置文件中的初始化参数
