首页  思维导图  详情

Spring-MVC

2021-07-26 10:31:41   43  举报





AI智能生成

SpringMVC学习过程

spring mvc

springMVC

作者其他创作

大纲/内容

小知识点

关于400状态码

1、关于400报错：肯定是和传递参数有关比如：底层是个整数，传递一个字符串

HTTP Status 400 – 错误的请求
Type Status Report
描述由于被认为是客户端对错误（例如：畸形的请求语法、
无效的请求信息帧或者虚拟的请求路由）
服务器无法或不会处理当前请求。

什么时候需要配置注解驱动

1、将 Object 数据转化为 JSON 数据，就是做Ajax的第二步，使用注解驱动完成om.writeValueAsString();
【原因】
将 Object 数据转化为 JSON 数据，需要由消息转换器 HttpMessageConverter 完成。而转换器的
开启，需要由mvc:annotation-driven/来完成。
【解决方案】
1).加入jackson的依赖，springmvc框架默认是用jackson工具库，处理java对象到json的转换
2).在springmvc配置文件加入注解驱动mvc:annotaion-driven
3).在处理器方法的上面加入@ResponseBody【响应到前端】

2、解决静态资源和动态资源的冲突。在配置了DispatcherServlet中央调度器的url-pattern以后，如果是设置
了" / "就会拦截所有的请求，包括静态资源
1、和注解<mvc:default-servlet-handler>的冲突

处理静态资源方式：

2、和注解<mvc:resources/>的冲突

处理方式：

【解决方法】：加入<mvc:annotation-driven>注解

3、关于异常处理中的冲突，【原因】当自己不配注解驱动的情况，系统会默认扫描到自己所定义的异常类。
加入注解驱动

1springmvc-简介

SprintMVC就是基于spring的一个模块。是专门用来做web开发的，SpringMVC也是一个容器
也可以创建对象，使用组件扫描器扫描包查找注解，创建对象，spring使用@Repository，@
Controller，@Service，@Component老创建对象并放到spring容器中去，SpringMVC能够
创建对象，并且放到S平ringMVC容器中去，使用的是@Controller注解创建对象

SpringMVC创建的对象就是控制器对象，将这个创建的对象放到SpringMVC容器中，实际上
这个对象就是一个普通的java对象，他没有实现HttpServlet，他本身不是一个Servlet，只是
SpringMVC框架赋予了它一些特殊的功能

重要的类：SpringMVC底层使用DispatcherServlet这个类来创建调度器对象，并创建SpringMVC容器

2、SpringMVC-WEB开发步骤

1、加入依赖

spring-webmvc依赖，这个依赖会间接的把spring需要的依赖导入
jsp，servlet的依赖

2、创建调度器对象，并创建springmvc容器

1）DispatcherServlet【中央调度器】是一个servlet，父类就是HttpServlet
2）DispatcherServlet【前端控制器-front controller】
3）DispatcherServlet：负责接受用户的请求，调度其他控制对象
并且吧请求的处理结果返回给用户

3、关于DispatcherServlet创建的规则

1、他是一个servlet，需要在web.xml文件中声明

2、创建springmvc容器对象需要跟spring一样指定那个配置文件位置

3、通知tomcat在服务器启动阶段创建这个对象。

4、声明
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>DispatcherServlet</servlet-class>
<init-param>
<init-name>contextConfigLocation</init-name>
<init-value>classpatch:springmvc.xml</init-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>*.do</url-pattern>//拦截的请求
<servlet-mapping>

注意URL-parrern的设置

4、中央调度器的执行规则

浏览器发送请求---->中央调度器（DispatcherServlet）进行拦截 -------> 扫描创建的controller，找到对应的请求
-------> 对应的请求进行处理，处理以后返回结果给中央调度器

5、视图解析器创建

1、关于数据的安全。
- 有些时候，某些数据不允许用户访问到，
比如我们发起某个请求以后通过转发的形式跳转到某个show.jsp.
但是用户如果猜到了这个show.jsp就可以直接通过地址栏访问，是不安全的
- 解决方法：
将需要保护的数据放在WEB-INF下，用户是没有访问权限的是安全的，比如web.xml配置文件
我们可以在web-info下新建文件夹存放资源文件

2、那么这个安全的数据怎么才能通过转发访问呢？
- 需要使用视图解析器
- 视图解析器需要在springMVC配置文件中声明，他是一个类通过bean标签声明
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/view/"/>
<property name="suffix" value=".jsp"/>
</bean>

1、@Controller注解：创建控制器对象，接受请求，处理请求。

6、重点注解

2、@RequestMapping注解：请求映射，和一个请求方法进行绑定，让这个方法去处理请求

1、value：请求的url地址，唯一值

2、method：请求的方式，使用的是RequestMethod类中的枚举值，比如：RequestMethod.GET

3、使用在方法上表示请求路径

4、使用在类上表示这个类中的处理器方法的url都需要加上这个模块名

3、关于请求参数的获取

1、使用HttpServletRequest，HttpServletResponse，HttpSession，这个三个参数可以直接出现在方法参数上，由框架进行自动赋值

2、使用逐个接收的形式接收参数，就是浏览器请求的参数出现在方法的形参列表中，但是名字必须相同

3、关于过滤器解决请求乱码的问题，框架提供了一个过滤器：characterencodingfilter

需要配置三个初始化参数

1、encoding：UTF-8

2、forceRequestEncoding：true

3、forceResponseEncoding：true

4、如果请求中参数名称和方法参数名称不一致，使用@RequestParam()注解进行重新命名

@RequestParam(value = "name",required = false) String cname,
@RequestParam(value = "age",required = false) Integer cage

5、使用对象来进行参数的获取，要求是请求参数名和属性名必须一致

- 使用的包：vo:Value Object 值对象，也是ViewObject表现层对象
一个WEB页面的一堆数据参数对应一个VO
- 使用对象需要先创建页面参数对应的类，这个类就是一普通类需要set，get方法

- 作为参数出现在方法参数上
这个参数作为对象，属性会自动赋值，他会根据名称找到对应的属性值，使用set方法进行赋值

6【扩展】，Map，List，集合等都可以作为参数传进来，但是需要前端对数据进行处理
如果以后用到，百度查看使用方法

4、关于返回值类型

1、ModelAndView

1、返回数据和视图

2、使用方法是处理器方法的返回值是ModelAndView

3、需要创建对象，ModelAndView，使用add方法加入数据，使用setViewName方法设置请求路径

关于视图解析器

1、视图解析器的目的是简化请求转发的地址

2、就是使用请求的逻辑路径

3、配置方法：在springmvc配置文件中，声明bean标签，这个标签是

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/view/"/>
<property name="suffix" value=".jsp"/>
</bean>

4、使用方法是直接返回名称比如:mv.setName("show")

4、如果一次处理中需要转发视图并且需要处理数据，可以使用ModelAndView

2、String

1、这个指的是返回视图文件的逻辑名称比如：return "show";

2、这个出现在一次请求中只需要返回视图不须要返回数据的情况下

public String doView(){

return "视图的逻辑路径或者完整路径";
}
【注意】：如果设置了视图解析器就不能使用完整路径

3、void

1、这个void就是指只有数据信息，没有视图信息

2、常用在Ajax请求中，只需要处理数据，不需要返回视图信息

处理Ajax需要引入一个新的依赖就是处理json数据格式的jack-son依赖

3、使用void做AJax请求，需要自己手动将请求发给前端浏览器

4、Object：【是对象，是数据，不是视图，在框架中就是指ajax请求】

1、使用springmvc做Ajax的步骤

1、加入处理json数据格式的依赖
使用的springmvc默认的jack-son依赖

2、在springmvc配置文件中声明，<mvc:annotation-driven>注解驱动
目的是完成这一步
String json = om.writeValueAsString(student);

3、使用注解@ResponseBody注解
完成的是
response.setContextType("application/json;charset=urf-8");
PrintWrite out = response.getWrite();
out.print(json);

2、底层实现原理

1、springmvc处理方法返回Object，可以转换为json数据，响应ajax请求
2、<mvc : annotation-driven> 注解驱动
这个注解驱动实现的功能是：
完成java对象到json，xml，text，html，二进制等数据格式的转换
这个功能底层使用了一个接口
HttpMessageConverter接口：【消息转换器】
功能：定义了数据转换的方法。

- 就是说在程序启动的时候，tomcat会自动创建HttpMessageConverter接口的实现类
这个接口实现类自带的是4个实现类，他会创建这是个实现类对象

- 但是这个四个实现类不能满足需求，就是我们的对象转换为json格式的需求
因此需要加入依赖：就是处理json数据的jack-son依赖，然后在springmvc的
配置文件中加入<mvc : annotation-driven> 注解驱动，那么在服务器启动阶段
他会创建7个实现类，就是新增了导入依赖创建的3个实现类，【不同版本数量不一样】

- 作用就是将对应数据转换为对应的数据格式

5、关于使用springmvc做AJax的注意

1、返回List集合的json数据

2、返回Map集合的json数据

3、返回就是一个普通的字符串，他不是json数据

1、必须使用@ResponseBody注解，不然会被当做视图处理

2、出现乱码，查看编码格式：Content-Type: text/html;charset=ISO-8859-1
解决乱码的方式：
@RequestMapping(value = "/doStringAjax.do",produces = "text/plain;charset=UTF-8")

5、关于中央调度器【DisapatcherServlet】url-pattern的设置

1、使用*.do

1、将所有的以.do结尾的请求交给DispatcherServlet处理

2、其他的请求交给web服务器默认的defaultServlet进行处理

3、优点是不会拦截静态资源，之会拦截指定的url-pattern设置的资源

2、使用 "/"

1、会拦截所有静态资源文件，全都交给DispatcherServlet进行拦截处理

2、解决静态资源无法访问的方法

1、使用配置文件<mvc:default-servlet-handler />

1、使用默认的servlet转发，配置springmvc
<mvc:default-servlet-driven>
目的是，拦截静态资源的请求访问，并转发给默认的那个defaultServlet进行处理

原理：给程序内存中增加一个对象：DefaultHttpRequestHandler,这个对象处理静态资源的访问

2、这个配置会和@RequestMapping发生冲突
解决办法就是配置注解驱动
<mvc:annotation-driven />

2、使用配置文件<mvc: resources/>

1、<mvc:resources mapping="/html/**" location="/html/"/>

第二种方式读取静态资源文件
mapping：就是你的资源文件比如：html/user.html
可以简写是 /html/** - > 含义：html目录下的所有静态资源文件
location：就是静态资源的根目录

2、<mvc:resources mapping="/static/**" location="/static/"/>

第三种方式，简略，提取到父包

7、关于路径

1、什么是相对路径？什么是绝对路径

1、比如说：http://localhost:8080/myweb/userlogin.html
这个就是绝对路径

2、在项目中使用表单
<form action="/login.html">
</form>
或者
action="login.html"
都属于相对路径

2、请求的url使用 / -- 也就是action="/login.html"

1、他的参考地址就是项目的根路径

2、比如：http://localhost:8080/springmvc_day03/doListAjax.do
参考地址：http://localhost:8080/springmvc_day03
资源地址：/doListAjax.do

3、请求的url不适用 / 也就是action="login.html"

1、他的参考地址就是当前页面的根

2、比如：http://localhost:8080/springmvc_day03/user/doListAjax.do
参考地址：http://localhost:8080/springmvc_day03/user/
资源路径：doListAjax.do

4、在jsp中可以使用EL表达式将项目名前缀替代

第一种方式配置：action="${pageContext.request.contextPath }/student/doview.do"

第二种方式配置

1、
<%
String basePath = request.getScheme() + "://" +
request.getServerName() + ":" + request.getServerPort() +
request.getContextPath() + "/";
%>

2、
指定 base 标签
<head>
<base href="<%=basePath%>">
<title>title</title>
</head>

3、SSM整合开发

1、什么是SSM整合开发

SSM = Spring + SpringMVC + MyBatis

SSM整合也叫做SSI整合（MyBatis的前身是IBatis）。

整合中有个概念就是容器，
第一个容器：SpringMVC容器。存放的是controller对象以及web开发相关的对象
第二个容器：Spring容器。存放的是service，dao，工具类等业务处理的对象
我们开发人员需要做的就是把对象放到合适的容器中进行管理。

难点：这是两个容器，是两个盒子，如何让这两个盒子创建连接是重点
其实Spring和SpringMVC的关系以及确定好了。
SpringMVC是Spring的子容器。类似于java中的继承关系，但是他不是一个确切的继承。
在子容器中，controller对象可以调用父容器的service方法处理业务逻辑

2、SSM整合的开发步骤

1、编写pom.xml文件

1、加入依赖

1、SpringMVC的依赖

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>

2、Spring的依赖

加入SpringMVC的依赖会自动导入Spring依赖

3、Mybatis的依赖

<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.1</version>
</dependency>

4、Mysql驱动依赖

<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.1</version>
</dependency>

5、阿里数据库Druid的依赖

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.12</version>
</dependency>

6、servlet的依赖

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>

7、jsp的依赖

<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.2.1-b03</version>
<scope>provided</scope>
</dependency>

8、处理json数据的依赖

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.0</version>
</dependency>

9、Spring处理事务的依赖

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>

2、配置resource，资源的位置

<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.txt</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.txt</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>

3、配置编译工具版本

<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>

2、编写web.xml文件

1、创建第一个容器：SpringMVC容器

声明中央调度去对象，并创建S平ringMVC容器
DispatcherServlet对象

<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
声明配置文件的位置
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:conf/dispatcherServlet.xml</param-value>
</init-param>
声明对象创建的时机，在tomcat服务器启动以后自动创建第一个创建
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>

2、创建第二个容器：Spring容器

声明监听器对象，这个监听器是框架提供的，目的是创建spring容器
使用对象：ContextLoaderListener

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:conf/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

3、设置字符集编码格式

使用过滤器对象，这个过滤器是框架提供的
characterEncodingFilter

<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
设置编码格式
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
设置参数为true
<init-param>
<param-name>forceRequestEncoding</param-name>
<param-value>true</param-value>
</init-param>
设置参数为true
<init-param>
<param-name>forceResponseEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

3、创建业务的基本包

1、controllerer：控制器对象

2、dao：数据库访问对象

3、service：业务处理对象

4、domain：实体类对象

5、vo：对应前端表单提交参数的对象

6、util：工具包

7、exception:异常处理包

8、handler：全局处理包

9、aspect：功能增强包：aop

4、编写配置文件

1、jdbc.properties配置文件数据库信息

jdbc_url=jdbc:mysql://localhost:3306/mybatis
jdbc_user=root
jdbc_pwd=ht520520
jdbc_max=20

2、编写spring配置文件

1、引入properties资源文件，目的是读取jdbc信息

<context:property-placeholder location="classpath:jdbc.properties"/>
placeholder:占位符

2、编写数据库连接池，使用的是阿里公司的Druid

3、声明SqlSessionFactoryBean：目的是创建sqlSessionFactory

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactpryBean">
<property name="dataSource" ref="dataSource"/>
这里是声明mybatis的配置文件的，上面是数据库资源文件的
<property name="configLocation" value="classpath:conf/mybatis.xml"/>
</bean>

4、给所有的dao类创建动态代理，就是类似于sqlSession.getMapper().这里是一次性全部生成

5、使用组件扫描器扫描注解创建对象

<context:component-scan base-package="com.javase.service"/>

3、编写mybatis配置文件

1、设置日志信息settings

<settings>
设置显示日志信息
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

2、设置sql映射文件中查询结果的简单写法

3、指定sql映射文件地址，就是mapper

4、编写springMVC配置文件

1、创建组件扫描器，扫描对应包，创建对应的控制器对象

<context:component-scan base-package="com.javase.controller"/>

2、创建视图解析器，访问WEB-INF下的资源，并且以后的返回视图直接使用逻辑名称

3、声明注解驱动：< mvc: annotation driven/>

1、如果使用springmvc做AJAX请求，必须加入这个注解

2、如果是设置静态资源的访问，<mvc:defalut-servlet driven>
这个会和@RequestMapping发生冲突，导致controller不会执行。因此加入注解驱动

3、如果设置另一个静态资源的访问办法，就是<mvc:resources />，也会和第2个一样发生冲突，因此必须设置注解驱动

5、关于转发和重定向

1、转发：forward

1、就是servlet中的request.getRequstDispatchet("show.jsp").forward(req,res);

2、默认视图返回就是一个转发操作，携带数据

1、未设置视图解析器：return "/WEB-INF/view/show.jsp";

2、设置了视图解析器：return "show";

3、即使设置了视图解析器，也可以使用forward转发

1、语法规则：setViewName("forward:/WEB-INF/jsp/show.jsp");

2、解决了：在设置了视图解析器以后的
非WEB-INF目录下资源访问的问题

ModelAndView mv = new ModelAndView();
mv.addObject("msg","转发操作");
mv.setViewName("forward:/jsp/queryUser.jsp");
return mv;

2、重定向：redirect

1、就是之前的servlet中的response.sendRedirect("/html/show.jsp");

2、语法规则：setViewName("redirect:资源的完成路径")

3、- 重定向操作
- 重定向时在两次请求中传递数据

4、框架实现了两次请求的数据传递
- 在第一次请求时将数据存储到mv中
会将这个数据当做第二次请求的参数也就是get请求的参数
使用EL表达式的param.name的形式读取

5、【注意】重定向无法访问WEB-INF目录下的资源，没有访问权限

6、关于框架中的统一异常处理方案

1、什么是异常的统一处理方案？

1、sprinmvc框架提供了一种统一的，全局的异常处理的方法，目的是让业务处理和异常处理分开，程序员专注于业务处理
就是解耦合

2、我的理解就是：所有出现的异常都往上抛出，有一个类专门去处理了这些抛出的异常，
就是说我这个方法调用了所有的方法，只要有异常出现，我就给处理掉，业务逻辑或者其他地方就不需要使用try...catch捕获

2、使用什么完成异常处理？

1、@ExceptionHandler

这个是做异常处理的

2、@ControllerAdvice

这个是做处理通知的

3、关于全局异常处理的实现步骤

1、创建全局异常处理类：在handler包下创建：GlobalExceptionHandler

2、在这个类上添加注解@ControllerAdvice

1、添加这个注解需要在springmvc配置文件中声明组件扫描器，扫描此注解创建对象

2、一旦controller出现异常就会找到异常处理类

3、使用在类上，表示这是一个异常处理类

controllerAdvice：控制器增强（控制器通知），也就是给控制器增加功能的，这里增加的是异常
处理的功能。

3、添加注解

<context:component-scan base-package="com.javase.handler"/>

4、添加异常处理对象

<mvc:annotation-driven />  <context:component-scan base-package="com.javase.handler"/>

5、关于连个注解的使用规则

1、ControllerAdvice

2、@ExceptionHandler

1、默认的异常处理

1、默认的异常处理
2、也是返回一个视图和数据的modelandview
3、这个就是默认的异常处理机制，除了自己定义的异常以外的其他异常都会在这个全局
的处理方法中进行异常的处理
4、需要声明注解@ExceptionHandler
参数：value：指定异常类，如果使用的是Exception.class就是所有异常
5、有一个参数就是异常参数

@ExceptionHandler(value = Exception.class)
public ModelAndView defaultException(Exception e){
ModelAndView mv = new ModelAndView();
mv.addObject("e",e);
mv.addObject("error","系统错误");
mv.setViewName("forward:/error/username_error.jsp");
return mv;
}

2、自定义的异常处理

@ExceptionHandler(value = UserNameException.class)
public ModelAndView nameError(Exception e){
ModelAndView mv = new ModelAndView();
mv.addObject("e",e);
mv.addObject("error","用户名错误");
mv.setViewName("forward:/error/username_error.jsp");
return mv;
}

7、关于拦截器

1、关于springMVC中的拦截器，需要实现HandlerInterceptor接口

功能解释：

1、拦截器的功能和过滤器类似

2、过滤器是过滤请求参数，设置字符集编码等工作

3、拦截器是拦截用户请求，对请求做判断处理的

4、拦截器是全局的，可以对多个controller进行拦截

5、一个项目中可以有0个或者多个拦截器，他们在一起拦截用户的请求
拦截器常用在登录处理，权限处理，日志记录等方面

拦截器的实现步骤

1、创建普通类实现HandlerInterceptor接口

2、实现三个方法：preHandle，postHandle，afterCompletion

3、在springmvc文件中声明拦截器

<mvc:interceptors>

<mvc:interceptor>

<mvc:mapping path="/user/**"/>

<bean class="com.javase.handler.MyHandlerInterceptor"/>
</mvc:interceptor>
</mvc:interceptors>

4、关于同时使用两个拦截器

原理：springmvc框架会创建一个ArrayList集合存放拦截器
先创建的拦截器先放进去
就是按照声明的拦截器的顺序出现在集合中。

8、拦截器和过滤器的部分区别

1、过滤器是Tomcat服务器创建的对象拦截器是springmvc容器创建的对象

2、过滤器实现了Filter接口拦截器实现了HandlerInterceptor接口

3、过滤器是用来设置request，response的参数，属性等，侧重于对数据的过滤
拦截器是用来拦截用户请求，能够截断（停止）请求的

4、过滤器在拦截器之前执行

5、过滤器只有一个执行时间点拦截器有三个执行时间点

6、过滤器可以处理jsp，html，js等资源
拦截器侧重于controller中的请求的拦截，如果你的请求不能被DispatcherServlet中央调度器接收
则不会被拦截器拦截

7、过滤器是过滤请求和响应拦截器是普通的方法执行操作

【注意】：必须声明mvc:annotation-dirven注解驱动