十一、过滤器（统一编码、无效数据过滤、登录权限验证）

一、过滤器的概念

1.1 为什么需要过滤器？

为什么需用到过滤器？
		项目开发中，经常会涉及到重复代码的实现！
				注册 ---- Servlet 【1. 设置编码】 ----  JSP
				修改 ----Servlet 【1. 设置编码】 ---  JSP
				其他，
					如判断用户是否登陆，只有登陆才能有操作权限！
					涉及到重复判断： 获取session，取出session数据，判断是否为空,为空说明没有登陆，不能操作； 只有登陆后，才能操作！

				如何解决：
				1.抽取重复代码，封装
				2.每个用到重复代码的地方，手动的调用！
				
				上述解决方案，还是不太优美。所以引入了过滤器技术。

1.2 什么是过滤器？

		Filter也称之为过滤器，它是Servlet技术中最激动人心的技术。
	WEB开发人员通过Filter技术，对web服务器管理的所有web资源：例
	如Jsp, Servlet, 静态图片文件或静态 html 文件等进行拦截，从而
	实现一些特殊的功能。例如实现URL级别的权限访问控制、过滤敏感词
	汇、压缩响应信息等一些高级功能。
	
	过滤器是Servlet技术，可对请求进行拦截。
	使用过滤器可以实现权限访问、过滤敏感词汇、统一编码等功能。
	

二、过滤器的开发步骤

		1.写一个类实现Fileter接口
		2.在web.xml中配置过滤器

HelloFilter.java

/**
 * 过滤器，测试
 * @author Jie.Yuan
 *
 */
public class HelloFilter implements Filter{
	
	// 创建实例
	public HelloFilter(){
		System.out.println("1. 创建过滤器实例");
	}

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		System.out.println("2. 执行过滤器初始化方法");
		
		// 获取过滤器在web.xml中配置的初始化参数
		String encoding = filterConfig.getInitParameter("encoding");
		System.out.println(encoding);
		
		// 获取过滤器在web.xml中配置的初始化参数 的名称
		Enumeration<String> enums =  filterConfig.getInitParameterNames();
		while (enums.hasMoreElements()){
			// 获取所有参数名称：encoding、path
			String name = enums.nextElement();
			// 获取名称对应的值
			String value = filterConfig.getInitParameter(name);
			System.out.println(name + "\t" + value);
		}
	}

	// 过滤器业务处理方法： 在请求到达servlet之前先进入此方法处理公用的业务逻辑操作
	@Override
	public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {
		System.out.println("3. 执行过滤器业务处理方法");
		// 放行 (去到Servlet)
		// 如果有下一个过滤器，进入下一个过滤器，否则就执行访问servlet
		chain.doFilter(request, response);
		
		System.out.println("5. Servlet处理完成，又回到过滤器");
	}

	@Override
	public void destroy() {
		System.out.println("6. 销毁过滤器实例");
	}

}

web.xml 配置filter

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
	

	<!-- 过滤器配置 -->
	<filter>
			<init-param>
				<param-name>encoding</param-name>
				<param-value>UTF-8</param-value>
			</init-param>
			<init-param>
				<param-name>path</param-name>
				<param-value>c:/...</param-value>
			</init-param>
		
			<filter-name>hello_filter</filter-name>
			<filter-class>cn.itcast.a_filter_hello.HelloFilter</filter-class>
	</filter>
	
	<filter-mapping>
			<filter-name>hello_filter</filter-name>
			<url-pattern>/*</url-pattern>
	</filter-mapping>


</web-app>

三、过滤器的生命周期

3.1 代码演示

实例代码
web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
	xmlns="http://java.sun.com/xml/ns/javaee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">


 <!-- 过滤器1配置 -->
 <filter>
 	<filter-name>fiter1</filter-name>
 	<filter-class>org.jsfo.demo.IndexFilter</filter-class>
 </filter>
  
  <filter-mapping>
  	<filter-name>fiter1</filter-name>
  	<url-pattern>/*</url-pattern>
  </filter-mapping>
  
   <!-- 过滤器2配置 -->
   <filter>
 	<filter-name>fiter2</filter-name>
 	<filter-class>org.jsfo.demo.IndexFilter2</filter-class>
 </filter>
  
  <filter-mapping>
  	<filter-name>fiter2</filter-name>
  	<url-pattern>/*</url-pattern>
  </filter-mapping>
  
  
  <!-- servlet配置 -->
  <servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>org.jsfo.demo.HelloServlet</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>
  
    
</web-app>

HelloServlet.java

public class HelloServlet extends HttpServlet {
	
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		System.out.println("say hello...");
	}
}

IndexFilter.java 过滤器1

public class IndexFilter implements Filter {

	public IndexFilter() {
		System.out.println("过滤器1创建完毕");
	}
	

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		System.out.println("过滤器1初始化完毕");
		
	}
	

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		System.out.println("过滤器1执行业务逻辑");
		chain.doFilter(request, response);
		System.out.println("servlet执行完毕,返回过滤器1");
		
	}

	@Override
	public void destroy() {
		System.out.println("过滤器1销毁");
		
	}
	
}

IndexFilter2.java 过滤器2

public class IndexFilter2 implements Filter {

	public IndexFilter2() {
		System.out.println("过滤器2创建完毕");
	}
	
	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		System.out.println("过滤器2初始化完毕");
		
	}

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		System.out.println("过滤器2执行业务逻辑");
		chain.doFilter(request, response);
		System.out.println("servlet执行完毕,返回过滤器2");
		
	}


	
	@Override
	public void destroy() {
		System.out.println("过滤器2销毁");
		
	}
	
}

启动tomcat服务器，访问localhost:8080/test/hello
tomcat服务器启动过程中，创建过滤器实例，并调用init方法。

访问hello，则先执行过滤器1前置逻辑–》执行过滤器2前置逻辑–》执行servlet代码–》执行过滤器2后置逻辑–》执行过滤器1后置逻辑。

3.2 过滤器的生命周期

	1.tomcat服务器启动时，
		 首先会把过滤器的实例出来。
		 然后调用init（FilterConfig  config）方法，初始化过滤器实例。
		 同时封装web.xml中配置的FilterConfig配置信息传入过滤器实例。
	
	2.访问请求资源时，
		 ->访问过滤器1的前置逻辑->访问过滤器2的前置逻辑
		 ->访问请求资源->
		 ->过滤器2的后置逻辑->过滤器1的后置逻辑
		
	 过滤器就相当于一扇门。	

3.3 Filter 链

Filter链
			在一个web应用中，可以开发编写多个Filter，这些Filter组合起来称
		之为一个Filter链。web服务器根据Filter在web.xml文件中的注册顺序，决
		定先调用哪个Filte。
			当第一个Filter的doFilter方法被调用时，web服务器会创建一个代表
		Filter链的FilterChain对象传递给该方法。在doFilter方法中，开发人员
		如果调用了FilterChain对象的doFilter方法，则web服务器会检查FilterChain
		对象中是否还有filter，如果有，则调用第2个filter，如果没有，则调用目标资源。

		总结：
			1.在web项目中，如果有多个过滤器，则它们组成一个filter链。

			2.在filter中，用户调用chain.doFilter（）方法，则首先会查看filter
			  链中是否有其他filter，如果有则执行，如果没有则执行servlet方法。
			
			3.filter过滤器的核心代码可分为:
				 
				   {
							前置代码
							chain.doFilter()
							后置代码
					}
			4.过滤器在web项目中的执行顺序：
						1）filter的执行顺序，取决于它们在web.xml中的配置顺序（先配置的先执行）。	
						2）	一次http请求--》
											filter链的前置代码
											servlet代码
											filter链的后置代码
							
				
						

三、过滤器的API

		|-- interface  Filter				过滤器核心接口
			
			Void  init(filterConfig);    初始化方法，在服务器启动时候执行
			Void  doFilter(request,response,filterChain);   过滤器拦截的业务处理方法
			Void  destroy();   			销毁过滤器实例时候调用
		
		|-- interface  FilterConfig   获取初始化参数信息
			
			String	getInitParameter(java.lang.String name)  根据名称获取参数的值
			Enumeration	getInitParameterNames()   获取所有的参数名称
		
		|-- interface  FilterChain     过滤器链参数；一个个过滤器形成一个执行链；
			
			void doFilter(ServletRequest request, ServletResponse response)  ;  执行下一个过滤器或放行

3.1 配置过滤器初始化参数

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
	xmlns="http://java.sun.com/xml/ns/javaee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">


 <!-- 过滤器1配置 -->
 <filter>
 		
 		<!--	配置过滤器初始化参数 -->
	 	<init-param>
		 		<param-name>filename</param-name>
		 		<param-value>hlp</param-value>
	 	</init-param>
 	
	 	 <init-param>
		 		<param-name>dir</param-name>
		 		<param-value>c://</param-value>
	 	</init-param>
 	
 	<filter-name>fiter1</filter-name>
 	<filter-class>org.jsfo.demo.IndexFilter</filter-class>
 </filter>
  
  <filter-mapping>
  	<filter-name>fiter1</filter-name>
  	<url-pattern>/*</url-pattern>
  </filter-mapping>
  
 
  
  <!-- servlet配置 -->
  <servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>org.jsfo.demo.HelloServlet</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>
  
    
</web-app>

IndexFilter.java

public class IndexFilter implements Filter {

	public IndexFilter() {
		System.out.println("过滤器1创建完毕");
	}
	

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		
		//获取这个过滤器的所有初始化参数名
		Enumeration<String> ens = filterConfig.getInitParameterNames();
		while(ens.hasMoreElements()) {
			String key = ens.nextElement();	
			String value = filterConfig.getInitParameter(key);
			
			System.out.println("filter过滤器初始化参数:"+key+"-"+value);
		}
		
		System.out.println("过滤器1初始化完毕");	
	}
	

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {		
		//方形
		chain.doFilter(request, response);		
	}

}

tomcat服务器启动，则自动创建filter实例，并调用init（）方法初始化实例对象。init（）方法打印以下内容：

3.2 如果存在多个过滤器

3.2 过滤器的web.xml 配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
	xmlns="http://java.sun.com/xml/ns/javaee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">


 <!-- 过滤器1配置 -->
 <filter>
 		
 		<!--	配置过滤器初始化参数 -->
	 	<init-param>
		 		<param-name>filename</param-name>
		 		<param-value>hlp</param-value>
	 	</init-param>
 	 	<!--	配置过滤器 -->
	 	<filter-name>fiter1</filter-name>
	 	<filter-class>org.jsfo.demo.IndexFilter</filter-class>
 </filter>
  
  <filter-mapping>
  	<filter-name>fiter1</filter-name>
  	<url-pattern>/*</url-pattern>
  </filter-mapping>
  
 
  
  <!-- servlet配置 -->
  <servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>org.jsfo.demo.HelloServlet</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>
  
    
</web-app>

3.3 过滤器的web.xml 拦截资源配置

	<!-- 演示： 拦截指定的请求 -->
	<filter>
		<filter-name>hello_filter2</filter-name>
		<filter-class>cn.itcast.a_filter_hello.HelloFilter2</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>hello_filter2</filter-name>
		<!-- 1. 拦截所有
		<url-pattern>/*</url-pattern>
		 -->
		 
		 <!-- 2. 拦截指定的jsp 
		 <url-pattern>/index.jsp</url-pattern>
		 <url-pattern>/list.jsp</url-pattern>
		 -->
		 
		 <!-- 拦截所有的jsp
		 <url-pattern>*.jsp</url-pattern>
		  -->
		  
		  <!-- 3. 根据servlet的内部名称拦截
		  <servlet-name>IndexServlet</servlet-name>
		   -->
		  <!-- 拦截指定的servlet 
		  <url-pattern>/index</url-pattern>
		  -->
		  
		  <!-- 4. 指定拦截指定的类型 -->
		  <url-pattern>/*</url-pattern>
		  <dispatcher>REQUEST</dispatcher>
		  <dispatcher>FORWARD</dispatcher>
	</filter-mapping>

3.3.1 指定拦截的资源

	<!--过滤器配置-->
	<filter>
		<filter-name>hello_filter2</filter-name>
		<filter-class>cn.itcast.a_filter_hello.HelloFilter2</filter-class>
	</filter>
	<filter-mapping>
		  <filter-name>hello_filter2</filter-name>
		  <url-pattern>/*</url-pattern>	
	</filter-mapping>

指定拦截的资源

	 1. 拦截所有的资源
			<url-pattern>/*</url-pattern>
	 
	 2. 拦截指定的jsp	 
		 <url-pattern>/index.jsp</url-pattern>
		 <url-pattern>/list.jsp</url-pattern>
	 
	 3. 拦截所有的jsp -- 拦截所有以jsp结尾的资源
		 <url-pattern>*.jsp</url-pattern>
		  
	 4. 根据servlet的内部名称拦截	-- 拦截WebRoot/index 文件夹下所有的资源
		  <url-pattern>/index</url-pattern>
		  

3.3.2 指定拦截的类型

	<!--过滤器配置-->
	<filter>
		<filter-name>hello_filter2</filter-name>
		<filter-class>cn.itcast.a_filter_hello.HelloFilter2</filter-class>
	</filter>
	<filter-mapping>
		  <filter-name>hello_filter2</filter-name>
		  <url-pattern>/*</url-pattern>	
		  <dispatcher>REQUEST</dispatcher> //默认拦截的类型为REQUEST，可省略不写
	</filter-mapping>

指定拦截的类型

		1.默认拦截的类型：(直接访问或者重定向)
				<dispatcher>REQUEST</dispatcher>
		
		2.拦截转发：
		  		<dispatcher>FORWARD</dispatcher>
		  		
		3.拦截包含的页面(RequestDispatcher.include(/page.jsp);    对page.jsp也执行拦截)
	
		 	 	<dispatcher>INCLUDE</dispatcher>
		
		4.拦截声明式异常信息：
		  		<dispatcher>ERROR</dispatcher>
		  		

四、设置统一编码过滤器 – 过滤器的应用

EncodingFilter.java

/**
 * 编码处理统一写到这里(servlet中不需要再处理编码)
 *
 */
public class EncodingFilter implements Filter {

	// 过滤器业务处理方法：处理的公用的业务逻辑操作
	@Override
	public void doFilter(ServletRequest req, ServletResponse res,
			FilterChain chain) throws IOException, ServletException {
		
		// 转型
		final HttpServletRequest request = (HttpServletRequest) req;    
		HttpServletResponse response = (HttpServletResponse) res;
		
		// 一、处理公用业务
		request.setCharacterEncoding("UTF-8");					// POST提交有效
		response.setContentType("text/html;charset=UTF-8");
		
		/*
		 * 出现GET中文乱码，是因为在request.getParameter方法内部没有进行提交方式判断并处理。
		 * String name = request.getParameter("userName");
		 * 
		 * 解决：对指定接口的某一个方法进行功能扩展，可以使用代理!
		 *      对request对象(目标对象)，创建代理对象！
		 */
		HttpServletRequest proxy =  (HttpServletRequest) Proxy.newProxyInstance(
				request.getClass().getClassLoader(), 		// 指定当前使用的累加载器
				new Class[]{HttpServletRequest.class}, 		// 对目标对象实现的接口类型
				new InvocationHandler() {					// 事件处理器
					@Override
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						// 定义方法返回值
						Object returnValue = null;
						// 获取方法名
						String methodName = method.getName();
						// 判断：对getParameter方法进行GET提交中文处理
						if ("getParameter".equals(methodName)) {
							
							// 获取请求数据值【 <input type="text" name="userName">】
							String value = request.getParameter(args[0].toString());	// 调用目标对象的方法
							
							// 获取提交方式
							String methodSubmit = request.getMethod(); // 直接调用目标对象的方法
							
							// 判断如果是GET提交，需要对数据进行处理  (POST提交已经处理过了)
							if ("GET".equals(methodSubmit)) {
								if (value != null && !"".equals(value.trim())){
									// 处理GET中文
									value = new String(value.getBytes("ISO8859-1"),"UTF-8");
								}
							} 
							return value;
						}
						else {
							// 执行request对象的其他方法
							returnValue = method.invoke(request, args);
						}
						
						return returnValue;
					}
				});
		
		// 二、放行 (执行下一个过滤器或者servlet)
		chain.doFilter(proxy, response);		// 传入代理对象
	}

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		
	}

	@Override
	public void destroy() {
		
	}
}

web.xml 配置

过滤器配置：
<!-- 编码处理过滤器配置 -->
	<filter>
		<filter-name>encoding</filter-name>
		<filter-class>cn.itcast.a_loginFilter.EncodingFilter</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>encoding</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

LoginServlet.java

public class LoginServlet extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		// 获取请求数据 
		String name = request.getParameter("userName");
		System.out.println("用户：" + name);
	}

测试：

	提交表单数据到loginServlet。无论是post提交，还是get提交，都会被过滤器
	进行拦截处理。没有出现乱码问题。

五、设置过滤无效数据过滤器–过滤器的应用

DisFilter.java – 无效数据过滤器

/**
 * 讨论栏过滤器
 * 
 * @author BGS
 *
 */
public class DisFilter implements Filter {
	
	
	private List<String>  dirtyList=new ArrayList<String>();

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		dirtyList.add("CNM");
		dirtyList.add("操你妈");
		
	}

	@Override
	public void destroy() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		
		  System.out.println("2");
		  
		  HttpServletResponse resp=(HttpServletResponse) response;
		  HttpServletRequest req=(HttpServletRequest) request;
		
		  HttpServletRequest req2=(HttpServletRequest) Proxy.newProxyInstance(req.getClass().getClassLoader(), req.getClass().getInterfaces(), new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				
				String name = method.getName();
				if("getParameter".equals(name)) {
					String str=(String) method.invoke(req, args);
					System.out.println(dirtyList);

					//过滤无效字
					for(String dirty:dirtyList) {
						System.out.println(str);
						
						str=str.replaceAll(dirty,"***");
					}
					return str;
				}

				return method.invoke(req, args);
			}
		});
		
		//放行
		chain.doFilter(req2, resp);
		
	}
	
	public static void main(String[] args) {
		String str="<p>操你妈 CNM WE</p>".replaceAll("CNM","***");
		System.out.println(str);

	}


}

EncodingFilter.java – 编码统一处理过滤器

/**
 * 编码过滤器
 * 
 * @author BGS
 *
 */
public class EncodingFilter implements Filter {

	@Override
	public void destroy() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		
		System.out.println("encoding...");
		
		HttpServletResponse resp=(HttpServletResponse) response;
		final HttpServletRequest req=(HttpServletRequest) request;
		
		
		//1.处理post请求
		req.setCharacterEncoding("UTF-8");

		//2.处理get请求
		HttpServletRequest req2=(HttpServletRequest) Proxy.newProxyInstance(req.getClass().getClassLoader(), req.getClass().getInterfaces(), new InvocationHandler() {
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				
				String methodName = method.getName();
				if("getParameter".equals(methodName)) {
					
					String submit = req.getMethod();
					if("get".equalsIgnoreCase(submit)) {
						String str=(String) method.invoke(req, args);
						String string = new String(str.getBytes("ISO-8859-1"),"UTF-8");
				
						return string;
					}
				}
				
				return method.invoke(req, args);
			}
		});
		
		//设置响应编码集
		resp.setContentType("text/html;charset=UTF-8");
		
		//放行
		chain.doFilter(req2, resp);
		
	}

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		// TODO Auto-generated method stub
		
	}

}

DisServlet.java – 讨论栏处理器

/**
 * 讨论栏目处理器
 * 
 * @author BGS
 *
 */
public class DisServlet extends HttpServlet{

		
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		
		String content = req.getParameter("content");	
		req.setAttribute("content", content);
		
		System.out.println(content);
		req.getRequestDispatcher("/dis.jsp").forward(req, resp);
		
	}

}

web.xml 配置

	切记，过滤器的配置顺序:
			编码过滤器先配置，无效数据过滤器后设置。

	原因:首先会执行编码过滤器前置代码，然后才会执行无效数据过滤器前置代码。
	

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
	xmlns="http://java.sun.com/xml/ns/javaee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  
  <!-- 统一编码过滤器 -->
  <filter>
  		<filter-name>encoding</filter-name>
  		<filter-class>org.jsoft.filter.EncodingFilter</filter-class>
  </filter>	
  <filter-mapping>
  		<filter-name>encoding</filter-name>
  		<url-pattern>/*</url-pattern>
  </filter-mapping>
   
   <!-- 无效字过滤器 -->
  <filter>
  		<filter-name>dirty</filter-name>
  		<filter-class>org.jsoft.filter.EncodingFilter</filter-class>
  </filter>	
  <filter-mapping>
  		<filter-name>dirty</filter-name>
  		<url-pattern>/*</url-pattern>
  </filter-mapping>
  
  <servlet>
    <servlet-name>dis</servlet-name>
    <servlet-class>org.jsoft.controller.DisServlet</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>dis</servlet-name>
    <url-pattern>/dis</url-pattern>
  </servlet-mapping>

 

</web-app>

index.jsp 讨论栏

该页面引入了ckeditor 富文本编辑器

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>

<script src="./ckeditor/ckeditor.js"></script>
<link rel="stylesheet" href="./ckeditor/samples/sample.css">

</head>
<body>
<%if(request.getAttribute("content")!=null){
	out.write("content:");
} %>
${requestScope.content}

<form action="./dis" method="get">
		<textarea rows="10"  cols="10" class="ckeditor" name="content"></textarea>
		<input  type="submit" value="提交">
</form>
</body>
</html>

测试

六、登陆权限验证

/**
 * 登陆验证过滤器
 * 
 *  http://localhost:8080/emp_sys/login.jsp   可以直接访问
	http://localhost:8080/emp_sys/login      可以直接访问
	http://localhost:8080/emp_sys/index   不能直接访问
	http://localhost:8080/emp_sys/list.jsp   不能直接访问
 *
 */
public class LoginFilter implements Filter {
	
	private String uri;

	/**
	 * 分析：
	 * 
		1. 先指定放行的资源，哪些资源不需要拦截：
		      login.jsp   +    /login  (request对象可以获取)
		2. 获取session，从session中获取登陆用户
		3. 判断是否为空：
		      为空， 说明没有登陆， 跳转到登陆
		       不为空， 已经登陆，放行！
	 */
	@Override
	public void doFilter(ServletRequest req, ServletResponse res,
			FilterChain chain) throws IOException, ServletException {
		
		//0. 转换
		HttpServletRequest request = (HttpServletRequest) req;
		HttpServletResponse response = (HttpServletResponse) res;
		
		//1. 获取请求资源，截取  
		String uri = request.getRequestURI();   // /emp_sys/login.jsp
		// 截取 【login.jsp或login】
		String requestPath = uri.substring(uri.lastIndexOf("/") + 1, uri.length());  
		
		//2. 判断： 先放行一些资源：/login.jsp、/login
		if ("login".equals(requestPath) || "login.jsp".equals(requestPath)) {
			// 放行
			chain.doFilter(request, response);
		}
		else {
			//3. 对其他资源进行拦截
			//3.1 先获取Session、获取session中的登陆用户(loginInfo)
			HttpSession session = request.getSession(false);
			// 判断
			if (session != null) {
				
				Object obj = session.getAttribute("loginInfo");
				
				//3.2如果获取的内容不为空，说明已经登陆，放行
				if (obj != null) {
					// 放行
					chain.doFilter(request, response);
				} else {
					//3.3如果获取的内容为空，说明没有登陆； 跳转到登陆
					uri = "/login.jsp";
				}
				
			} else {
				// 肯定没有登陆
				uri = "/login.jsp";
			}
			request.getRequestDispatcher(uri).forward(request, response);
		}
	}

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
	}

	@Override
	public void destroy() {
	}

}