Spring MVC框架——基本应用全解

缺乏、安全感 2022-05-18 07:40 257阅读 0赞

**打个广告，帮朋友卖点东西，东西超便宜的哟，厂家直接出货，绝对低于市场价！！！ ****一般都比市场价便宜3—7折【都是牌子货】，如果您感兴趣，可以扫描屏幕下方的二维码，感谢关注！！！**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTcyMTMz_size_16_color_FFFFFF_t_70][] 微信

--------------------

# 一、入门内容 #

## 1、运行原理图 ##

![70][]

对比：Struts2执行流程

 strutsPrepareAndExcuteFilter拦截请求（控制层），拦截请求，转发请求

 寻找Action执行

 ActionProxy：strutsActionProxy extends defaultActionProxy

 ActionMapping去寻找执行类Action

## 2、与struts2的对比 ##

*  实现机制：Springmvc基于servlet实现。Servlet比过滤器快。Struts2是基于过滤器实现的。
 *  运行速度：Struts2是多例，请求来了以后，struts2创建多少个对象；Springmvc是单例。
 *  参数封装来分析：Struts基于属性进行封装。Springmvc基于方法封装。

## 3、入门案例 ##

### 1.需要的jar包 ###

因为springmvc是spring的一部分，故jar包和之前的相同，只是要加一个jar：spring-webmvc-3.2.0.RELEASE.jar

### 2.程序编写 ###

首先要在在web.xml中配置前端控制器：DispatcherServlet

<servlet>
         <servlet-name>springmvc</servlet-name>
         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    </servlet>
    <servlet-mapping>
         <servlet-name>springmvc</servlet-name>
         <url-pattern>*.do</url-pattern>
    </servlet-mapping>

然后编写一个controller（类似struts2中的action）:

public class MyController implements Controller{
    	public ModelAndView handleRequest(HttpServletRequest arg0,
    			HttpServletResponse arg1) throws Exception {
    		// 接受请求，接受参数，验证参数
    		//封装参数，调用业务方法
    		//返回视图
    		ModelAndView mv = new ModelAndView();
    		//设置页面回显数据,键值对
    		mv.addObject("hello", "欢迎学习springmvc！");
    		
    		//指定跳转的视图
    		//返回物理视图
    		//mv.setViewName("/WEB-INF/jsps/index.jsp");
    		//返回逻辑视图
    		mv.setViewName("index");
    		
    		return mv;
    	}
    }

之后在spring配置文件中（这里为springmvc.xml）首先要引入新的命名空间，如下：

<beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans 
    		http://www.springframework.org/schema/mvc 
    		http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd >

然后就可以在spring配置文件中配置如下：

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>
    	 	
    
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>
    
    <bean name="/hello.do" class="cn.itcast.controller.MyController"></bean>

说明：即通过url为.../hello.do来访问该controller，如果在上面的controller类中返回的是物理视图，就可直接跳到index页面中，如果返回的是逻辑视图，还需要配置如下部分：

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

配置完如上部分后，还需要在web.xml文件中将该配置文件加载进去：

<servlet>
            <servlet-name>springmvc</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            
           <init-param>
               <param-name>contextConfigLocation</param-name>
               <param-value>classpath:springmvc.xml</param-value>   
           </init-param>
      </servlet>

说明： 配置文件也可以默认加载，但必须满足如下规范：

*  文件命名：servlet-name-servlet.xml，这里的（web.xml）名为springmvc，故配置文件名应为springmvc-servlet.xml
 *  路径规范：必须在WEB-INF目录下面

最后在index中便可通过$\{hello\}来取值。

# 二、语法详情 #

## 1、处理器映射器 ##

就是将从浏览器发送过来的url地址进行处理，将url和controller对应起来，但是还未执行controller。

### 1.BeanNameUrlHandlerMapping ###

根据url请求去匹配bean的name属性url，从而获取Controller，如下：

只需要访问http:..../hello.do即可。

### 2.SimpleUrlHandlerMaping ###

根据浏览器url匹配简单url的key，key又通过Controller的id找到Controller，如下：

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
             <props>
    		     <prop key="/abc.do">myController</prop>
    		     <prop key="/ss.do">***</prop>
    		     <prop key="/mine.do">***</prop>
    		 </props>
        </property>
    </bean>
    
    <bean id="myController" class="cn.itcast.controller.MyController"></bean>

在上述配置中，如果访问.../abc.do将会访问自定义的controller

### 3.ControllerClassNameHandlerMapping ###

根据类名（MyController）类名.do来访问,类名首字母小写，如下：

<bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"></bean>
    
    <bean  class="cn.itcast.controller.MyController"></bean>

在上述配置中只要访问..../myController(就是自定义的controller的类名的首字母小写)，即可访问自定义的MyController

注意：3个处理器映射器是可以共存的

## 2、处理器适配器 ##

用来执行相应的controller的。处理器适配器的类型与自定义controller时所实现的接口是对应的，每一种适配器处理一种实现特定接口的controller。

### 1.SimpleControllerHandlerAdapter ###

controller需要实现的接口为Controller，返回modelAndView，如下：

controller中

public class MyController implements Controller{
    	public ModelAndView handleRequest(HttpServletRequest arg0,
    			HttpServletResponse arg1) throws Exception {
    		ModelAndView mv = new ModelAndView();
    		mv.addObject("hello", "欢迎学习springmvc！");
    		//指定跳转的视图
    		//返回物理视图
    		//mv.setViewName("/WEB-INF/jsps/index.jsp");
    		//返回逻辑视图
    		mv.setViewName("index");
    		return mv;
    	}
    }

配置中

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

### 2.HttpRequestHandlerAdapter ###

controller需要实现的接口为HttpRequestHandler，无返回值，如下：

controller中

public class HttpController implements HttpRequestHandler{
    	public void handleRequest(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    		//给Request设置值，在页面进行回显
    		request.setAttribute("hello", "这是HttpRequestHandler！");
    		//跳转页面
    		request.getRequestDispatcher("/WEB-INF/jsps/index.jsp").forward(request, response);
    	}
    }

注意：因为无返回值，故在跳转页面时只能是物理视图，不能是逻辑视图。

配置中

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

注意：2个处理器适配器可以共存

## 3、注解的使用 ##

如果使用注解开发，那么再spring配置文件中要有如下配置：

<context:component-scan base-package="cn.itcast"></context:component-scan>
    		
    
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"></bean>
    		
    
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"></bean>
    		
    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
       <property name="prefix" value="/WEB-INF/jsps/"></property>
       <property name="suffix" value=".jsp"></property>		
    </bean>

注意：可以使用如下配置

<mvc:annotation-driven/>

来替代注解处理器和适配器，并且还自动支持json格式数据。但是注意此时（使用json格式数据）在javaBean中不能添加@XmlRootElement（提供对xml视图支持）。

然后自定义的Controller类可以使用注解来开发，举例如下：

@Controller//相对应<bean class="UserController"/>
    public class UserController {
    	@RequestMapping("hello.do")//相对于<bean name="/hello.do" class="..."></bean>
    	public String hello(){
    		return "index";//跳转到index.jsp
    	}
    }

注意：

1.requestMapping可以写为：

*  requestMapping(“hello”)
 *  requestMapping(“/hello.do”)
 *  requestMapping(value=”/hello.do”)
 *  requestMapping(value=”/hello.do”,method=RequestMethod.GET)//指定只接受get请求
 *  requestMapping(value=”/hello.do”,method=\{RequestMethod.POST, RequestMethod.GET\})//get和post请求都可以

2.RequestMaping设置根路径：

@Controller//相对应<bean class="UserController"/>
    @RequestMapping("/user")//这里
    public class UserController {
    	@RequestMapping("hello.do")
    	public String hello(){
    		return "index";
    	}
    }

之后再访问需要.../user/hello.do来访问hello方法

在接收参数时可以使用@RequestParam注解，如：

//接受int类型参数
    @RequestMapping("recieveInt")
    public String recieveInt(@RequestParam(defaultValue="2",value="ss",required=true) Integer id){		
    	System.out.println(id);
    	return "success";
    }

那么在表单中：

注意：name的值与controller中的value对应，如果没有传递的值默认值为2，required设置为true表示必须传递值，否则报错。

# 三、参数的接收与封装 #

## 1、参数的接收 ##

与Struts2的参数基于属性封装不同，Springmvc参数的封装是基于方法进行封装的。

### 1.接收int型参数 ###

首先在页面中：

那么在controller中：

//接受int类型参数
    @RequestMapping("recieveInt")
    public String recieveInt(Integer id){
    	System.out.println(id);
    	return "success";
    }

注意：在方法中的参数名要与表单中提交过来的方法名一致。

### 2.接收String型参数 ###

首先在页面中：

那么在controller中：

//接受字符类型参数
    @RequestMapping("recieveStr")
    public String recieveStr(String username)
    {
    	System.out.println(username);
    	return "success";
    }

### 3.接收数组型参数 ###

首先在页面中：

那么在controller中：

//接受数组类型参数
    @RequestMapping("recieveArray")
    public String recieveArray(Integer[] ids){	
    	System.out.println(ids);
    	return "success";
    }

### 4.接收bean型参数 ###

首先在页面中：

那么在controller中：

//接受参数封装User对象
    @RequestMapping("recieveUser")
    public String recieveUser(User user){		
    	System.out.println(user);	
    	return "success";
    }

注意：这里的表单中提交过来的数据的name要与user bean中属性名相同

### 5.接收包装型参数 ###

首先包装类如下：

public class UserCustom {
    	private User user;
            //get set
    }

然后在页面中：

那么在controller中：

//接受包装类型参数
    @RequestMapping("recieveUserCustom")
    public String recieveUserCustom(UserCustom usercustom){
    	System.out.println(userCustom);
    	return "success";
    }

注意：表单数据的名称

### 6.接收集合型参数 ###

因为在方法中参数不能是集合，故想要接收集合类型参数需要通过包装类来完成。

1.接收List类型参数

首先其包装类如下：

public class UserCustom {
    	private List<User> userList;
    	//set get
    }

然后在页面中：

那么在controller中：

//接受集合类型参数
    @RequestMapping("recieveList")
    public String recieveList(UserCustom userCustom){	
    	System.out.println(userCustom);
    	return "success";
    }

2.接收Map类型参数

首先其包装类如下：

public class UserCustom {
    	private Map<String,Object> maps = new HashMap<String, Object>();
            //get set
    }

然后在页面中：

那么在controller中：

//接受集合类型参数
    @RequestMapping("recieveMap")
    public String recieveMap(UserCustom userCustom){		
    	System.out.println(userCustom);
    	return "success";
    }

## 2、参数的封装 ##

Springmvc通过命令设计模式接受页面参数。现在实现将from表单中的数据封装到bean中，首先先有一个user bean：

public class User {
    	private Integer id;
    	private String username;
    	private Date birthday;
    	private String sex;
    	private String address;
            //get and set
    }

然后创建一个controller，通过它来跳转到form表单页面：

public class ToAddController implements Controller{
    	public ModelAndView handleRequest(HttpServletRequest request,
    			HttpServletResponse response) throws Exception {
    		ModelAndView mv = new ModelAndView();
    		//调转到add添加页面视图
    		mv.setViewName("add");
    		return mv;
    	}
    }

它在配置文件中的主要配置如下：

那么这时访问.../toAdd.do将会执行该controller，然后通过它跳到下面的jsp中：

提交的url(...command.do)在spring配置中：

即，将由CommandController来处理：

public class CommandController extends AbstractCommandController{
    	//指定参数绑定到那个javaBean
    	public CommandController(){
    		this.setCommandClass(User.class);
    	}
    	@Override
    	protected ModelAndView handle(HttpServletRequest request,
    			HttpServletResponse response, Object command, BindException errors)
    			throws Exception {
    		//把命令对象强转成User对象
    		User user = (User) command;
    		ModelAndView mv = new ModelAndView();
    		mv.addObject("user", user);	
    		mv.setViewName("index");		
    		return mv;
    	}
    }

这时将跳转到index 页面，来显示user的信息：

<body>
    ${user.username } <br>
    ${user.birthday } <br>
    ${user.sex } <br>
    ${user.address } <br>
    </body>

注意：可能出现的问题

问题1：中文乱码

*  Get请求乱码

![70 1][]

*  post请求乱码

通过配置Spring编码过滤器来解决，在web.xml中配置：

<filter>
       <filter-name>characterEncoding</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>
    </filter>
    <filter-mapping>
       <filter-name>characterEncoding</filter-name>
       <url-pattern>/*</url-pattern>
    </filter-mapping>

问题2：日期格式的转换

如上例子中如果在日期栏中添加的是：2016/10/4 这样的格式的话date是可以提交上去的（默认，与系统格式一致），但是如果是：2016-10-4等，提交上去的将会为null，在CommandController中再添加方法initBinder（自动执行），可以转换日期格式：

public class CommandController extends AbstractCommandController{
    	public CommandController(){		
    	}
    	//。。。。。。
    	@Override
    	protected void initBinder(HttpServletRequest request,
    			ServletRequestDataBinder binder) throws Exception {
    		String str = request.getParameter("birthday");
    		if(str.contains("/")){
    			binder.registerCustomEditor(Date.class, 
    					new CustomDateEditor(new SimpleDateFormat("yyyy/MM/dd"), true));
    		}else{
    			binder.registerCustomEditor(Date.class, 
    					new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), true));	
    		}
    	}
    }

# 四、页面的回显 #

在spring mvc中通过model来实现页面中数据的回显，相当于application域对象。下面以显示集合对象中的数据为例说明：

首先在controller中添加要显示在页面中的数据：

@RequestMapping("list")
    public String list(Model model){
    	List<User> userList = new ArrayList<User>();
    		
    	User user1 = new User();
    	user1.setId(1);
    	user1.setSex("男");
    	user1.setUsername("张山峰");
    	user1.setAddress("武当山");
    	user1.setBirthday(new Date());
    		
    	User user2 = new User();
        User user3 = new User();
            //。。。			
    	userList.add(user1);
    	userList.add(user2);
    	userList.add(user3);
    	
    	model.addAttribute("userList", userList);//将该对象放到model中
    	return "list";
    }

之后在页面中取出：

<table border="1" style="color: blue">
       <tr>
           <td>姓名</td>
           <td>生日</td>
           <td>性别</td>
           <td>地址</td>
           <td>操作</td>
       </tr>
       <c:forEach items="${userList}" var="user">
       <tr>
          <td>${user.username }</td>
          <td>${user.birthday }</td>
          <td>${user.sex }</td>
          <td>${user.address }</td>
          <td>
              <a href="${pageContext.request.contextPath }/rest/user/updateByID.do?id=${user.id }">修改</a>
           </td>
       </tr>
       </c:forEach>
    </table>

附加：如果点击修改后的实现：

//修改
    @RequestMapping("updateByID")
    public String updateByID(Integer id,Model model){
    	User user1 = new User();
    	user1.setId(id);
        //。。。。	
    	model.addAttribute("user", user1);
    	return "edit";
    }

# 五、其它 #

## 1、URL模版映射 ##

在spring mvc 中url 格式为...controller.do?参数，这不符合restfull软件架构（无扩展名，无参数）。为了实现Restfull风格设计可以进行如下修改：

首先假如有如下url请求：

而处理的controller为：

@RequestMapping("updateByID")
    public String updateByID(Integer id){
          //。。。。
    }

想去掉后面根加的请求参数可以将其写为：

并且在controller中修改为：

@RequestMapping("updateByID/{id}")
    public String updateByID(@PathVariable Integer id){
          //。。。。		
    }

而想去掉.do扩展名，则可以在web.xml中配置的url拦截改为：

<servlet-mapping>
      <servlet-name>springmvc</servlet-name>
      <url-pattern>*.do</url-pattern>
      </servlet-mapping>
      
      <servlet-mapping>
      <servlet-name>springmvc</servlet-name>
      <url-pattern>/rest/*</url-pattern>
      </servlet-mapping>

注意：第二个映射的rest是默认的。

此时url访问将变为：

<a href="${pageContext.request.contextPath }/rest/user/updateByID/${user.id }"

## 2、转发和重定向 ##

### 1.转发（forward） ###

在本类(同一个controller中方法与方法之间进行转发)进行转发：

@RequestMapping("forward")
    public String forward(){	
    	return "forward:list.do";
    }

在不同类中进行转发：

@RequestMapping("forward")
    public String forward(){		
    	return "forward:/items/list.do";
    }

### 2.重定向（redirect） ###

@RequestMapping("redirect")
    public String redirect(){		
    	return "redirect:/items/list.do";
    }

## 3、整合JSON数据 ##

首先需要在处理器适配器中进行如下配置：

或者如前面注解中的

### 1.接收json数据，输出json数据 ###

接收后转为pojo，然后将pojo输出为json格式，首先在页面中：

function requestJson(){
        //模拟json格式数据
        var jsonObj=JSON.stringify({"username":"小明","sex":"男","address":“”河南});
        $.ajax({
                type:'POST',
                url:'${pageContext.request.contextPath}/user/requestJson.do',
                contentType:'application/json;charset=utf-8',
                data:jsonObj,
                success:function(data){//这里的data表示的是返回的数据
                        alert(data.username)
                }
        })
    }

在后台代码中：

@RequestMapping("requestJson")
    public @ResponseBody User requestJson(@RequestBody User user){
        Sysotem.out.println(user);
        return user;//这里不再是页面了
    }

### 2.接收pojo数据，输出json数据 ###

首先在页面中：

function requestPo(){
        $.ajax({
                type:'POST',
                url:'${pageContext.request.contextPath}/user/requestPo.do',
                data:'username=小明&sex=男&address=河南',
                success:function(data){//这里的data表示的是返回的数据
                        alert(data.username)
                }
        })
    }

在后台代码中：

@RequestMapping("requestPo")
    public @ResponseBody User requestJson(User user){
        Sysotem.out.println(user);
        return user;//这里不再是页面了
    }

## 4、Springmvc对多视图的支持 ##

对多视图支持，表示的是springmvc可以根据条件生成多种格式的数据（如通过提交的url的扩展名相应的返回xml格式数据【.xml】或者json格式数据【.json】）。首先导入相应的jar包（json如上，只导xml），然后在配置文件中配置多视图的支持：

<bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
           
           <property name="contentNegotiationManager">
             <bean class="org.springframework.web.accept.ContentNegotiationManagerFactoryBean">
                <property name="mediaTypes">
                   <map>
                      <entry key="json" value="application/json"></entry>
    		  <entry key="xml" value="application/xml"></entry>
                   </map>
    	   </property>
             </bean>
          </property>
          
           <property name="defaultViews">
    	   
    	   <list>
    		
    		<bean class="org.springframework.web.servlet.view.json.MappingJacksonJsonView"></bean>
    		
    		
    		<bean class="org.springframework.web.servlet.view.xml.MarshallingView">
    		   <constructor-arg>
    		      <bean class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
    		                     <property name="classesToBeBound">
    		                              <list>
    		                                    <value>com.shen.domain.User</value>
    		                              </list>
    		                        </property>
    		                  </bean>
    		     </constructor-arg>
    		      </bean>
    		</list>	
    	</property>
    </bean>

此外为了支持xml格式的输出，还要在输出的相应的实体类中加上如下注解：

@XmlRootElement
    public class User {
    }

在java代码中如下：

@RequestMapping("multView")
    public String multView(){
    	User user1 = new User();
    	user1.setId(1);
    	user1.setSex("男");
    	user1.setUsername("张山峰");
    	user1.setAddress("武当山");
    	user1.setBirthday(new Date());
    	return user1;
    }

## 5、spring MVC的拦截器 ##

需要引入的命名空间为：

xmlns:mvc="http://www.springframework.org/schema/mvc"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/mvc 
             http://www.springframework.org/schema/mvc/spring-mvc.xsd ">

### 1.局部拦截器 ###

针对单个处理器映射器，就叫局部拦截器。

### 2.全局拦截器 ###

在配置文件中：

<mvc:interceptors>
    	
    	<mvc:interceptor>
    		<mvc:mapping path="/**"/>
    		<bean class="com.shen.interceptor.Interceptor1"></bean>
    	</mvc:interceptor>
    	<mvc:interceptor>
    		<mvc:mapping path="/**"/>
    		<bean class="com.shen.interceptor.Interceptor2"></bean>
    	</mvc:interceptor>
    </mvc:interceptors>

然后拦截器代码：

public class Interceptor1 implements HandlerInterceptor{
    	//preHandle在处理器映射器之前进行执行
    	//return false:拦截 return true:放行
    	public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1,
    			Object arg2) throws Exception {
    		System.out.println("这是第一个拦截器Interceptor1。。。preHandle");
    		return true;
    	}
    	//还没有调用Controller，还没返回modelAndView执行
    	public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1,
    			Object arg2, ModelAndView arg3) throws Exception {
    		System.out.println("这是第一个拦截器Interceptor1。。。postHandle");
    	}
    	//返回modelAndView之后执行
    	public void afterCompletion(HttpServletRequest arg0,
    			HttpServletResponse arg1, Object arg2, Exception arg3)
    					throws Exception {
    		System.out.println("这是第一个拦截器Interceptor1。。。afterCompletion");
    	}
    }

public class Interceptor2 implements HandlerInterceptor{
    	public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1,
    			Object arg2) throws Exception {
    		System.out.println("这是第二个拦截器Interceptor2。。。preHandle");
    		return true;
    	}
    	public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1,
    			Object arg2, ModelAndView arg3) throws Exception {
    		System.out.println("这是第二个拦截器Interceptor2。。。postHandle");	
    	}
    	public void afterCompletion(HttpServletRequest arg0,
    			HttpServletResponse arg1, Object arg2, Exception arg3)
    					throws Exception {
    		System.out.println("这是第二个拦截器Interceptor2。。。afterCompletion");	
    	}
    }

然后测试：

1.第一个拦截器放行，第二个拦截器也放行：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td> <p>这是第一个拦截器Interceptor1。。。preHandle</p> <p>这是第二个拦截器Interceptor2。。。preHandle</p> <p>这是第二个拦截器Interceptor2。。。postHandle</p> <p>这是第一个拦截器Interceptor1。。。postHandle</p> <p>这是第二个拦截器Interceptor2。。。afterCompletion</p> <p>这是第一个拦截器Interceptor1。。。afterCompletion</p> </td> 
  </tr> 
 </tbody> 
</table>

2.第一个拦截器放行，第二个不放行：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td> <p>这是第一个拦截器Interceptor1。。。preHandle</p> <p>这是第二个拦截器Interceptor2。。。preHandle</p> <p>这是第一个拦截器Interceptor1。。。afterCompletion</p> </td> 
  </tr> 
 </tbody> 
</table>

说明：Springmvc规定：凡是preHandle返回true，afterCompletion必须执行。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTcyMTMz_size_16_color_FFFFFF_t_70]: /images/20220518/d3d430010ed44137880edd61b7bc9362.png
[70]: /images/20220518/34d4238ae11a48bb86eff24de9299e32.png
[70 1]: /images/20220518/edf207088e584bec94a037550016b8fa.png