SpringMVC的核心技术之一--拦截器

项目中的应用：比如用户的登录拦截----------我们可以在prehandle方法中写我们的业务逻辑代码来判断请求是不是正确的，用户只有登录过我们的系统之后才可以访问我们的应用，可以判断在session会话中有没有登录信息，如果有，让prehandle方法返回true，如果没有就在会话中返回false，提示用户登录。

温故知新：springmvc执行流程：

1.由*调度器接收请求
2.*调度器把请求交给了处理器映射器

处理器映射器：是一些类，他们需要实现HandlerMapping接口。
处理器映射器作用：根据请求的信息，找到处理此请求的处理器对象。
也就是根据some.do 找到MyController.把找到的
MyController对象保存到 “处理器执行链”的对象中。

3.*调度器把“处理器执行链”的处理器对象（MyController）,
交给的处理器的适配器

处理器适配器：是一些类，需要实现HandlerAdapter接口。
处理器适配器作用：根据处理器对象找到对应的处理器适配器对象（根据你的电脑的型号找到适合电源）。
每个处理器接口都有一个适配器对象

4.*调度器，根据找到的处理器适配器。
通过这个处理器适配器执行处理器方法（调用MyController的handlerRequest()方法），
处理器调用完成后，会得到ModelAndView(数据和视图)

5.*调度器把处理后的ModelAndView交给了视图解析器

视图解析器：是一些类，需要实现ViewResovler接口
视图解析器作用：根据他的前缀，后缀，组成视图的完整路径， 并创建视图文件的对应视图对象
在框架中， 视图是用View接口表示的。

==========================================================================
配置式开发中的映射器和适配器

1.处理器映射器：
org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping
org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping

使用的是 BeanNameUrlHandlerMapping

2.处理器的适配器
org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter
org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter
org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter

使用的是 SimpleControllerHandlerAdapter ， 处理Controller接口的

/****拦截器讲解/
拦截器的使用类似servlet中的过滤器（由tomcat创建），而拦截器由SpringMVC创建（在本节中）

22-interceptor:一个拦截器
拦截器拦截用户的请求， 可以对请求做判断，处理的。 可以控制请求是否被处理。
拦截器的执行时间点：获取到处理器的适配器之后，在处理器方法执行之前，拦截用户的请求。

拦截器的数量：在一个项目中拦截器可以0-多个。

拦截器是全局的， 对所有的处理器对象都可以使用。

实现拦截器的步骤：
1.定义类实现拦截器的接口HandlerInterceptor
2.在springmvc的配置文件中，声明拦截器的存在，指定拦截器的uri地址。

步骤：
1.新建 web project
2.导入jar:
1)spring的核心jar:spring-beans.jar,spring-core.jar,spring-context.jar,spring-expression.jar
2)spring-aop.jar
3)web相关的jar:spring-web.jar
4)springmvc的实现jar:spring-webmvc.jar
5)日志：commons-logging.jar
3.重点：修改web.xml ， 注册springmvc的核心对象：*调度器DispatherServlet

1. *调度器DispatherServlet是一个Servlet
2. *调度器的作用：1）接收用户的请求；2）响应处理结果。
3. *调度器也叫做前端控制器(front controller)
   4.新建jsp，发起一个请求。
   定义请求参数 name ,age (使用整数表示年龄)

5.新建控制器对象，是一个普通的java类
1）在类的上面加入注解@Controller，创建处理器对象
2）在类中自定义方法，处理某个请求， 在方法的上面加入@RequestMapping.
方法定义形参 name ,age

6.新建jsp，显示请求的处理结果

7.定义类实现HandlerInterceptor接口， 实现接口中的三个方法。

8.定义springmvc的配置文件
1）声明组件扫描器，指定@Controller注解所在的包名
2）声明视图解析器，处理视图
3）声明拦截器对象，指定拦截的请求uri

package com.bjpowernode.interceptors;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

//拦截器
public class MyInterceptor implements HandlerInterceptor {

private long btime;
/**
 * preHandle：预处理方法，用户的请求首先到达此方法。在方法中可以对请求做判断处理。
 * 
 * 参数：
 *  Object handler：处理器对象
 * 
 * 返回值：boolean
 *  true:请求是能被处理的， 拦截器的所有方法都会执行， afterCompletion也能被执行。
 *  
 *      拦截器MyInterceptor的preHandle()
		执行了MyController的doSome方法
		拦截器MyInterceptor的postHandle()
		拦截器MyInterceptor的afterCompletion()
		
 *  false: 请求不会被处理，到拦截器就截止了。
 *      拦截器MyInterceptor的preHandle()
 *  
 *  
 *  preHandle()可以看做是整个应用的总开关。
 *  
 */
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
		throws Exception {
	btime = System.currentTimeMillis();
	System.out.println("拦截器MyInterceptor的preHandle()");
	return true;
}

/**
 * postHandle:后处理方法，在处理器方法执行后执行的。 特点能够获取到处理器方法的返回值。
 *            可以对返回值做处理，修改数据，修改视图。 做二次处理
 * 参数：
 *  Object handler：处理器对象
 *  ModelAndView mv：处理器方法的返回值
 */
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
		ModelAndView mv) throws Exception {
	System.out.println("拦截器MyInterceptor的postHandle()");
	//修改原来的执行结果，增加数据
	if( mv !=null ){
		//增加数据
		mv.addObject("msg", "postHandle");
		
		//修改视图
		mv.setViewName("other");
	}
	
}

/**
 * afterCompletion:最后执行的方法， 在方法中可以做资源的回收， 内存释放。
 *                  只有当拦截器的preHander()方法返回true，它才能执行。           
 * 参数：
 *  Object handler：处理器对象
 *  Exception ex：指定程序中的异常对象
 *  
 * 请求处理完成：在视图处理完成后，认为请求处理完成， afterCompletion方法是在视图处理完成后执行的。
 */
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
		throws Exception {
	System.out.println("拦截器MyInterceptor的afterCompletion()");
	
	long etime = System.currentTimeMillis();
	System.out.println("请求的处理时长："+(etime - btime));
	
}

}
/SpringMVC.xml/

<?xml version="1.0" encoding="UTF-8"?>

<!-- 声明组件扫描器，指定@Controller注解的包名 -->
<context:component-scan base-package="com.bjpowernode.controllers" />

<!-- 声明视图解析器对象：框架提供的类， 处理视图的。
          实现ViewResolver接口的类叫做视图解析器
 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<!-- 指定前缀：表示视图文件的目录 -->
	<property name="prefix" value="/WEB-INF/jsp/" />
	<!-- 指定后缀：表示视图文件的扩展名 -->
	<property name="suffix" value=".jsp" />
</bean>

<!-- 声明拦截器对象，指定拦截器的uri -->
<mvc:interceptors>
	<!-- 第一个拦截器 -->
	<mvc:interceptor>
		<!-- 拦截的uri -->
		<mvc:mapping path="/**"/>
		<!-- 指定拦截器 -->
		<bean class="com.bjpowernode.interceptors.MyInterceptor" />
	</mvc:interceptor>
</mvc:interceptors>

/**Mycontroller/
package com.bjpowernode.controllers;

import javax.servlet.http.HttpServletRequest;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

/**

• @Contorller:创建处理器对象，默认是单例对象

•     位置：在类的上面
  

• @RequestMapping:请求映射

•     value:在类的上面使用，value表示请求地址的公共部分， 我们叫做模块名称
  

*/
@Controller
@RequestMapping(“test”)
public class MyController {

//自定义方法处理请求。


@RequestMapping(value="some.do")
public ModelAndView doSome( Integer age,String name){
	
	System.out.println("执行了MyController的doSome方法");
	//处理some.do的请求， doSome就相当于 Servlet的doGet
	ModelAndView mv = new ModelAndView();
	//调用Service处理业务，将处理结果显示到视图
	mv.addObject("myname", name);
	mv.addObject("myage", age);
	//指定视图
	mv.setViewName("show");
	
	return mv;
}

}
/*web.xml/

<?xml version="1.0" encoding="UTF-8"?> 01-primary index.html index.htm index.jsp default.html default.htm default.jsp myweb org.springframework.web.servlet.DispatcherServlet contextConfigLocation classpath:springmvc.xml

<!-- 在服务器启动的时候，创建对象 -->
<load-on-startup>1</load-on-startup>

myweb characterEncodingFilter org.springframework.web.filter.CharacterEncodingFilter encoding utf-8 forceRequestEncoding true

<!-- 强制应答(HttpServletResponse)对象，使用encoding的字符编码 -->
<init-param>
	<param-name>forceResponseEncoding</param-name>
	<param-value>true</param-value>
</init-param>

characterEncodingFilter /*