SpringMVC框架技术

SpringMVC概述

基本介绍

springmvc是spring框架的一个模块，springmvc和spring无需通过中间整合层进行整合。springmvc是一个基于mvc的web框架。

SpringMVC的执行过程

执行细节

1. DispatcherServlet处理url请求，并通过处理器映射器（HandlerMapping）找到对应的Handler
2. 处理器映射器会返回一个执行链（就是一个封装好的对象HandlerExecutionChain），里面包含了Handler以及多个拦截器（HandlerInterceptor）
3. DispacherServlet不会直接执行Handler，而是请求处理器适配器（HandlerAdapter）去执行，然后HandlerAdapter会返回一个ModelAndView（模型视图对象）对象
4. DispatcherServlet请求视图解析器（View resolver）对ModelAndView进行解析并返回view
5. 视图渲染将模型数据填充到request域中
6. response响应

执行细节（详细版本）

1. 发起请求到前端控制器(DispatcherServlet)

2. 前端控制器请求HandlerMapping查找 Handler（可以根据xml配置、注解进行查找）

3. 处理器映射器HandlerMapping向前端控制器返回Handler

4. 前端控制器调用处理器适配器去执行Handler

5. 处理器适配器去执行Handler

6. Handler执行完成给适配器返回ModelAndView

7. 处理器适配器向前端控制器返回ModelAndView（ModelAndView是springmvc框架的一个底层对象，包括 Model和view）

8. 前端控制器请求视图解析器去进行视图解析，根据逻辑视图名解析成真正的视图(jsp)

9. 视图解析器向前端控制器返回View

10. 前端控制器进行视图渲染，视图渲染将模型数据(在ModelAndView对象中)填充到request域

11. 前端控制器向用户响应结果

SpringMVC执行过程中涉及的组件

1. 前端控制器DispatcherServlet（不需要程序员开发）

   作用：接收请求，响应结果，相当于转发器，中央处理器。DispatcherServlet减少了其它组件之间的耦合度。

2. 处理器映射器HandlerMapping(不需要程序员开发)

   作用：根据请求的url查找Handler

3. 处理器适配器HandlerAdapter

   作用：按照特定规则（HandlerAdapter要求的规则）去执行Handler

4. 处理器Handler(需要程序员开发)

   注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler

5. 视图解析器View resolver(不需要程序员开发)

   作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）

6. 视图View(需要程序员开发jsp)

   View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf…）

入门程序

配置步骤（非注解开发版）

配置DispatcherServlet转发器

  <servlet>
    <servlet-name>springMvcservlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    <init-param>
      <param-name>contextConfigLocationparam-name>
      <param-value>classpath:springMvc.xmlparam-value>
    init-param>
  servlet>
  <servlet-mapping>
    <servlet-name>springMvcservlet-name>
    <url-pattern>*.actionurl-pattern>
  servlet-mapping>

注意：

1. 在配置的时候需要配置init-param，这里是为了初始化Spring容器

2. 关于url-pattern（Servlet的拦截方式）

   • 拦截固定后缀的url，比如设置为 .do、.action， 例如：/user/add.action

     此方法最简单，不会导致静态资源（jpg,js,css）被拦截。

   • 拦截所有，设置为/，例如：/user/add /user/add.action

     此方法可以实现REST风格的url，很多互联网类型的应用使用这种方式。但是此方法会导致静态文件（jpg,js,css）被拦截后不能正常显示。需要特殊处理。

   • 拦截所有，设置为/*，此设置方法错误，因为请求到Action，当action转到jsp时再次被拦截，提示不能根据jsp路径mapping成功。

配置处理器适配器

在Spring的配置文件中进行配置

<bean id="adapter" class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

1. 处理器适配器可以处理所有实现了Controller接口的类
2. SimpleControllerHandlerAdapter：即简单控制器处理适配器，所有实现了org.springframework.web.servlet.mvc.Controller 接口的Bean作为SpringMVC的后端控制器。

编写控制器Handler

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/*
	必须实现Controller接口
*/
public class ItemList01 implements Controller {
    @Override
    public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception {

        List<Items> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            Items items = new Items();
            items.setPrice((i+1)*120.0f);
            items.setCreatetime(new Date());
            items.setDetail("这是第"+(i+1)+"个作品");
            items.setId(i);
            items.setName("电脑"+i);
            list.add(items);
        }
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("itemsList",list);
        modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");
        return modelAndView;
    }
}

编写处理器映射器

在Spring的配置文件中配置

<bean id="handlerMapping" class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

配置编写的处理器

在Spring的配置文件中配置

<bean name="/queryList/itemsList.action" class="zzuli.zw.learnSpringMVC.controller.ItemList01"/>

name值将来作为访问路径url

配置试图解析器

在Spring配置文件中配置

<bean id="resolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"/>

非注解的处理器映射器和处理器适配器

非注解的处理器映射器

在非注解情况下，我们可以使用两种方式的处理器映射器：

1. 
   <bean id="handlerMapping" class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
   

   这种方式的处理器映射器会根据配置的Handler的name来查找Handler

   此时的Handler配置方式

   <bean name="/queryList/itemsList.action" class="zzuli.zw.learnSpringMVC.controller.ItemList01"/>
   

2. <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
       <property name="mappings">
           <props>
               <prop key="/queryList/itemsList02.action">list01prop>
               <prop key="/query/itemsList.action">list01prop>
           props>
       property>
   bean>
   

   其中key为url路径，值为配置的Handler的id

   此时的Handler的配置方式

   
   <bean id="list01" name="/queryList/itemsList.action" class="zzuli.zw.learnSpringMVC.controller.ItemList01"/>
   

3. 注意：

   • 以上两种适配器并非只能配置一种，两种可以同时配置，SpringMVC可以根据需要使用不同的映射器查找
   • 不论哪种映射器，都是需要根据url来查找Handler的

非注解的处理器适配器

在非注解情况下我们也可以使用两种适配器，他们有不同的使用场景

1. 
   <bean id="adapter" class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
   

   使用这种适配器，处理器必须实现Controller接口才行

   此时的处理器：

   public class ItemList01 implements Controller {
       @Override
       public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse){
   
           List list = new ArrayList<>();
           ModelAndView modelAndView = new ModelAndView();
           modelAndView.addObject("itemsList",list);
           modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");
           return modelAndView;
       }
   }
   

   可以看到，里面只有一个方法，而且最终返回的是ModelAndView对象

2. <bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"/>
   

   使用这种适配器，处理器必须实现HttpRequestHandler接口

   此时的处理器：

   public class ItemList02 implements HttpRequestHandler {
       @Override
       public void handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws ServletException, IOException {
           
       }
   }
   

   可以看到，里面同样只有一个方法，但是返回值为void，这就意味着我们可以使用response来返回json串

3. 两种方式的比较：

   • 第一种使用起来相对比较简单一点，但是不能返回流
   • 第二种和之前的原始方式很相似，比较麻烦，但是可以通过response返回流
   • 不管是第一种还是第二种都有一个缺陷就是只能写一种方法，不太方便

注解开发中的处理器映射器和处理器适配器

注解中的处理器映射器和处理器适配器需要配对使用

一般使用的是以下两个：

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

使用注解配置有两种方式：

1. <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
   <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>
   

2. <mvc:annotation-driven/>
   

3. 实际开发过程中推荐使用第二种方式进行配置

实际案例

@Controller("itemList")
public class ItemList03 {

    @RequestMapping("/itemsList/queryItems")
    public ModelAndView queryItems(){
        List list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            Items items = new Items();
            items.setPrice((i+1)*120.0f);
            items.setCreatetime(new Date());
            items.setDetail("这是第"+(i+1)+"个作品");
            items.setId(i);
            items.setName("电脑"+i);
            list.add(items);
        }
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("itemsList",list);
        modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");
        return modelAndView;
    }
}

其中我们可以使用@RequestMapping注解来替代原来非注解配置url的方式。

配置jsp路径的前缀和后缀

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

为视图解析器配置两个参数即可

配置之前

modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");

配置之后

modelAndView.setViewName("items/itemsList");

@RequestMapping

通过@RequestMapping注解可以定义不同的处理器映射规则。

URL映射

在class上添加@RequestMapping(url)指定通用请求前缀， 限制此类下的所有方法请求url必须以请求前缀开头，通过此方法对url进行分类管理。

如下：

@RequestMapping放在类名上边，设置请求前缀 

@Controller
    
@RequestMapping("/item")

方法名上边设置请求映射url：

@RequestMapping放在方法名上边，如下：

@RequestMapping("/queryItem ")

请求方法限定

限定GET方法

@RequestMapping(method = RequestMethod.GET)
//如果通过Post访问则报错：HTTP Status 405 - Request method 'POST' not supported

限定POST方法

@RequestMapping(method = RequestMethod.POST)

GET和POST都可以

@RequestMapping(method={RequestMethod.GET,RequestMethod.POST})

Controller中方法的返回值

ModelAndView

controller方法中定义ModelAndView对象并返回，对象中可添加model数据、指定view。

public ModelAndView selectByName(){
    ItemsQueryAo query = new ItemsQueryAo();
    Items items = new Items();
    items.setName("电脑");
    query.setItems(items);
    List list = itemsService.getByName(query);
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("itemsList",list);
    modelAndView.setViewName("items/itemsList");
    return modelAndView;
}

该方式默认使用请求转发

String

public String queryAll(Model model){
        List list = itemsService.getByName(null);
        model.addAttribute("itemsList",list);
        return "items/itemsList";
  }

controller方法返回字符串可以指定逻辑视图名，通过视图解析器解析为物理视图地址。

使用该凡是返回的字符串默认使用请求转发的方式解析，同时可以使用加前缀的方式来实现转发和重定向

//重定向
return "redirect:selectAll.action";

//请求转发
return "forward:selectAll.action";

void

在controller方法形参上可以定义request和response，使用request或response指定响应结果：

public void query(HttpServletRequest request, HttpResponse response){

}

参数绑定

处理器适配器在执行Handler之前需要把http请求的key/value数据绑定到Handler方法形参数上。

默认支持的参数类型

• HttpServletRequest
• HttpServletResponse
• HttpSession
• Model/ModelMap

参数绑定介绍

注解适配器对RequestMapping标记的方法进行适配，对方法中的形参会进行参数绑定，早期springmvc采用PropertyEditor（属性编辑器）进行参数绑定，将request请求的参数绑定到方法形参上，3.X之后springmvc就开始使用Converter进行参数绑定。

简单类型

• 整型
• 字符串
• 浮点数
• 布尔类型

@RequestParam

使用@RequestParam常用于处理简单类型的绑定。

value：参数名字，即入参的请求参数名字，如value=“item_id”表示请求的参数区中的名字为item_id的参数的值将传入

required：是否必须，默认是true，表示请求中一定要有相应的参数，否则将报；

TTP Status 400 - Required Integer parameter ‘XXXX’ is not present

defaultValue：默认值，表示如果请求中没有同名参数时的默认值

定义如下：

public String editItem(@RequestParam(value="item_id",required=true) String id) {

}

形参名称为id，但是这里使用value=" item_id"限定请求的参数名为item_id，所以页面传递参数的名必须为item_id。

注意：如果请求参数中没有item_id将跑出异常：

HTTP Status 500 - Required Integer parameter ‘item_id’ is not present

这里通过required=true限定item_id参数为必需传递，如果不传递则报400错误，可以使用defaultvalue设置默认值，即使required=true也可以不传item_id参数值

public String query(@RequestParam(value = "id",required = true,defaultValue = "1") Integer id){
    System.out.println(id);
    return "forward:/hello.html";
}

POJO/domain

将pojo对象中的属性名于传递进来的属性名对应，如果传进来的参数名称和对象中的属性名称一致则将参数值设置在pojo对象中

public void query(@RequestParam(value = "id",defaultValue = "1") Integer id,User user){
    user.setId(id);
    System.out.println(user);
}

包装pojo/domain（待定）

所谓包装pojo就是类似于以下方式的对象：

Public class QueryVo {
	private Items items;
}

自定义参数绑定

Converter接口

在实际开发过程中我们可能需要处理各种各样的数据类型，一些简单的数据类型SpringMVC已经帮我们处理好了，但是想Date这种比较复杂的数据类型就需要我们根据需求去自定义转换器，SpringMVC为我们提供了一个接口，我们可以自己去进行实现。

public class DateConverter implements Converter {
    @Override
    public Date convert(String s) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        try {
            return simpleDateFormat.parse(s);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
}

Converter支持泛型，第一个泛型变量是要转换的参数，第二个是目标参数类型，例如上面就是将String转换为Date类型。

配置自定义的参数绑定

注意：

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>

<mvc:annotation-driven conversion-service="conversionService"/>

如果需要进行自定义绑定，那么只需要留下面的配置就可以了，上面的会产生冲突，使配置失效

绑定List类型

需求：

在实际项目开发过程中，可能会需要批量增加或者删除信息，比如说批量删除购物车中的内容，或者学校系统批量增加学生信息。这时候就需要用到List集合来接受参数。

在ItemsQueryAo中添加字段

private List customList;

Controller层设计

@RequestMapping(value = "/testList",method = {RequestMethod.GET,RequestMethod.POST})
public String testList(ItemsQueryAo queryAo){
    //Stream流
    Stream.of(queryAo.getCustomList()).forEach(System.out::println);
    return "items/itemsList";
}

jsp视图层设计

<%这里需要注意，customList是ItemsQueryAo中的字段名称，后面是序号%>

参数绑定总结

• 内置的参数绑定

  HttpServletRequest、HttpServletResponse、HttpSession、Model

• 基本类型参数绑定

  int、double/float、String、boolean

• 简单的pojo/domain

  前端的input中name名称与pojo/domain中的字段相对应即可

• 复合的pojo/domain

  为了便于程序的拓展与维护，我们往往会使用复合的pojo，复合的pojo中包含简单的pojo，在使用的时候前端页面需要：

  pojo：

  private ItemsCustom itemsCustom;
  

• List类型绑定

数据校验

所需jar包

<dependency>
    <groupId>org.hibernategroupId>
    <artifactId>hibernate-validatorartifactId>
    <version>6.1.4.Finalversion>
dependency>
<dependency>
    <groupId>org.jboss.logginggroupId>
    <artifactId>jboss-loggingartifactId>
    <version>3.4.1.Finalversion>
dependency>
<dependency>
    <groupId>javax.validationgroupId>
    <artifactId>validation-apiartifactId>
    <version>2.0.1.Finalversion>
dependency>

校验器以及错误信息资源配置

<bean id="validator" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean">
    <property name="providerClass" value="org.hibernate.validator.HibernateValidator"/>
    <property name="validationMessageSource" ref="messageSource"/>
bean>
<bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
    <property name="basenames">
        <list>
            <value>classpath:Messagevalue>
        list>
    property>
    <property name="defaultEncoding" value="UTF-8"/>
    <property name="fileEncodings" value="utf-8"/>
    <property name="cacheSeconds" value="120"/>
bean>

Controller层配置

public void edits(@Validated ItemsCustom itemsCustom,BindingResult bindingResult){
    if (bindingResult.hasErrors()){
        for (ObjectError allError : bindingResult.getAllErrors()) {
            System.out.println(allError.getCode());
        }
    }
}

JavaBean

@Size(min = 2,max = 15,message = "{mvc.items.name.length}")
private String name;

博客参考

https://blog.csdn.net/yangqh521/article/details/81906944

注意

编码问题：

<property name="defaultEncoding" value="UTF-8"/>

不适用于校验JavaBean中复合的JavaBean。

数据回显

在实际开发中我们有时会用到数据回显，所谓的数据回显实际上就是将数据存放到request域中，这样数据就不会丢失，在jsp页面中这种回显数据的方式还是很常用的。主要可以通过三种方式来实现数据回显。

SpringMVC默认支持的数据回显方式

SpringMVC在默认情况下会将pojo数据存入request域中，key等于pojo类型（首字母小写）。

但是在一些情况下，可能jsp页面中使用的并非pojo类型（首字母小写),这时就需要使用一个注解：

@RequestAttribute("itemsCustom")

使用@ModelAttribute注解

该注解用在方法上，作用是将方法的返回值存入到request域中

@ModelAttribute("itemsCustom")
public ItemsCustom getThis(){
    return new ItemsCustom();
}

使用Model对象

@RequestMapping("/sele")
public String toEdits(Model model){
    model.addAttribute("itemsCustom",new ItemsCustom());
    return "items/edit";
}

文件上传及案例

需要导入的jar包：

由于SpringMVC的上传是依赖于fileupload上传组件以及commons-io的，因此需要在pom.xml中添加相应的依赖。

<dependency>
    <groupId>commons-iogroupId>
    <artifactId>commons-ioartifactId>
    <version>2.6version>
dependency>
<dependency>
    <groupId>commons-fileuploadgroupId>
    <artifactId>commons-fileuploadartifactId>
    <version>1.3.1version>
dependency>

配置多部件解析器

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="maxUploadSize" value="5242880"/>
    <property name="defaultEncoding" value="UTF-8"/>
bean>

多部件解析器用来解析前端表单的file控件内容，需要在SpringMVC的配置文件中进行相应的配置。

前端

<form action="" method="post" enctype="multipart/form-data">
    <input type="file" name="files">
    <input type="submit" value="提交">
form>

在表单设计时，我遇到了一个问题：本来只要设计enctype="multipart/form-data"就可以了，但是在使用SpringMVC的过程中，我发现只设计成会报异常，必须指定method=“post”，不知道是什么愿意，记录一下。

后端

 @RequestMapping(value = "/uploading")
    public void upload(@RequestPart(value = "files") MultipartFile files, HttpServletRequest request) throws IOException {
        if (files != null){
            String oldFileName = files.getOriginalFilename();
            if (oldFileName != null && !oldFileName.trim().isEmpty()) {
                String suffix = oldFileName.substring(oldFileName.indexOf("."));
                if (!suffix.trim().isEmpty()) {
                    String newFileName = oldFileName.substring(0, oldFileName.indexOf("."));
                    int index = newFileName.lastIndexOf("//");
                    if (index != -1){
                        newFileName = newFileName.substring(index+1);
                    }
                    String newUUID = UUID.randomUUID().toString().replaceAll("-", "").toUpperCase();
                    String newUUIDFileName = newFileName+newUUID+suffix;
                    String realPath = request.getServletContext().getRealPath("/WEB-INF/files");
                    Date date = new Date();
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(date);
                    int year = calendar.get(Calendar.YEAR);
                    int month = calendar.get(Calendar.MONTH);
                    int day = calendar.get(Calendar.DATE);
                    StringBuilder sb = new StringBuilder();
                    String finalFilePath = sb.append(realPath).append("/").append(year).append("/").append(month)
                            .append("/").append(day).append("/").append(newUUIDFileName).toString();
                    File file = new File(finalFilePath);
                    file.mkdirs();
                    files.transferTo(file);
//                    IOUtils.copy(files.getInputStream(),new FileOutputStream(file));
                    //将数据写入数据库
                }else{
                    //输出错误信息，图片格式无法识别
                }
            }else{
                //输出错误信息，请选择图片！
            }
        }

    }

主要就是通过参数绑定：MultipartFile来进行解析。

注意：表单中的name也需要和MulitpartFile的名称相同，也可以通过RequestParam注解来自行指定。

SpringMVC进行json交互

SpringMVC进行json交互主要依赖jackson，所以需要在pom.xml中添加相应的依赖。同时如果没有使用mvc的注解驱动，那么需要自己在控制器适配器中注入相应的依赖。

RequestBody注解

对于前端的设计来说，有的框架会将所有的表单数据封装为json对象，发送给后端，后端收到的是字符串，这是通过这个注解可以自动将前端发来的json串转换为Java对象。如果使用使用key/value的传统方式进行前后端交互，那么就不用使用此注解。

ResponseBody注解

和上面的相对应，该注解将返回值转换为json格式传递给前端解析。

SpringMVC对RESTful的支持

RESTful概述

RESTful架构，就是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用。

RESTful是一种规范，这种规范在URI路径上体现的比较明显，传统方式下我们传递参数往往通过以下的方式

/items/query.action?a=1&b=2

这种格式使用起来比较复杂，不直观，在使用RESTful规范后可以写成下面的格式

/items/query/1/2

这种方式更为简洁，直观。

SpringMVC使用RESTful规范

SpringMVC配置文件

<mvc:resources mapping="/js/" location="/js/**"/>

使用RESTful规范可能会导致静态资源无法访问，因此我们需要在配置文件中配置静态资源路径进行过滤。

Controller

@RequestMapping("/add/{a}/{b}")
public String add(@PathVariable int a,@PathVariable int b, Model model){
    String result = "结果为：" + a + b;
    model.addAttribute("msg",result);
    return "test";
}

web.xml配置

	<servlet>
        <servlet-name>springMvcservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
        <init-param>
            <param-name>contextConfigLocationparam-name>
            <param-value>classpath:springMVC-config.xmlparam-value>
        init-param>
    servlet>
    <servlet-mapping>
        <servlet-name>springMvcservlet-name>
		
        <url-pattern>/url-pattern>
    servlet-mapping>

上面注释掉的是之前的使用方式，通过后缀配置url，使用RESTful需要按照下方的方式进行配置。

拦截器

拦截器的作用类似于之前的Filter，但是并不是Filter，SpringMVC使用了动态代理对方法进行增强，功能更为强大。

使用SpringMVC的拦截器

实现HandlerInterceptor接口：

public class HandlerInterceptor01 implements HandlerInterceptor {
    /**
     * 该方法是在Controller执行之前进行的，可以用来进行登录校验等工作，返回值为boolean类型，如果返回为true表示可以放行，否则则进行拦截
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                             Object handler) throws Exception {
        return false;
    }
    /**
     *进入Handler方法之后，返回modelAndView之前执行，可以用来设置一些页面公用的东西，比如路径导航等
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
                           Object handler, ModelAndView modelAndView) throws Exception {
    }
    /**
     * 执行Handler完成执行此方法，该方法可以用来进行全局异常处理，也可以记录日志等
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                Object handler, Exception ex) throws Exception {
    }
}

在SpringMVC的配置文件中配置拦截器

SpringMVC拦截的是处理器映射器映射的路径即注解中RequestMapping中的路径，在配置过程中，可以配置多个拦截器。

这里有两种配置方式，一种是将自定义的拦截器注入到注解处理器映射器中，一种是配置类似全局拦截器的方式。这里只对第二种进行讲解。

<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean class="zzuli.zw.learnSpringMVC.controller.HandlerInterceptor01"/>
    mvc:interceptor>
mvc:interceptors>

这里可以配置多个拦截器，而且是顺序执行的。

拦截器应用

需求

进行登录认证，如果是公众网页直接放行，否则重定向到登录界面

Controller

@Controller
public class LoginController {
	// 登陆
	@RequestMapping("/login")
	public String login(HttpSession session, String username, String password)
			throws Exception {

		// 调用service进行用户身份验证
		// ...

		// 在session中保存用户身份信息
		session.setAttribute("username", username);
		// 重定向到商品列表页面
		return "redirect:/items/queryItems.action";
	}
	// 退出
	@RequestMapping("/logout")
	public String logout(HttpSession session) throws Exception {

		// 清除session
		session.invalidate();
		// 重定向到商品列表页面
		return "redirect:/items/queryItems.action";
	}
}

拦截器实现

public class LoginInterceptor implements HandlerInterceptor {
	//进入 Handler方法之前执行
	//用于身份认证、身份授权
	//比如身份认证，如果认证通过表示当前用户没有登陆，需要此方法拦截不再向下执行
	@Override
	public boolean preHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler) throws Exception {
		//获取请求的url
		String url = request.getRequestURI();
		//判断url是否是公开 地址（实际使用时将公开 地址配置配置文件中）
		//这里公开地址是登陆提交的地址
		if(url.indexOf("login.action")>=0){
			//如果进行登陆提交，放行
			return true;
		}
		//判断session
		HttpSession session  = request.getSession();
		//从session中取出用户身份信息
		String username = (String) session.getAttribute("username");
		
		if(username != null){
			//身份存在，放行
			return true;
		}
		//执行这里表示用户身份需要认证，跳转登陆页面
		request.getRequestDispatcher("/WEB-INF/jsp/login.jsp")
            .forward(request, response);
		
		//return false表示拦截，不向下执行
		//return true表示放行
		return false;
	}