MVC你要的菜都上齐了,请慢用

Java学习之道

共 30159字,需浏览 61分钟

 ·

2021-07-16 16:18

点击上方 Java学习之道,选择 设为星标

每天18:30点,干货准时奉上!

来源: blog.csdn.net/ATFWUS/article/details/105726312
作者: ATFWUS

Part1认识Spring MVC

1.Spring MVC概述

  • Spring MVC属于SpringFrameWork的后续产品,已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。
  • 使用 Spring 可插入的 MVC 架构,从而在使用Spring进行WEB开发时,可以选择使用Spring的Spring MVC框架或集成其他MVC开发框架,如Struts1(现在一般不用),Struts 2(一般老项目使用)等。
  • Spring MVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架,通过把模型-视图-控制器分离,将web层进行职责解耦,把复杂的web应用分成逻辑清晰的几部分,简化开发,减少出错,方便组内开发人员之间的配合。
  • Spring MVC属于表现层的框架。

2.MVC的理解

  • MVC全名是Model View Controller模型视图控制器,每个部分各司其职。
  • Model:数据模型,JavaBean的类,用来进行数据封装。
  • View:指JSP、HTML用来展示数据给用户。
  • Controller:用来接收用户的请求,整个流程的控制器。用来进行数据校验等。

3.Spring MVC在Spring中的地位

Part2简单使用Spring MVC

1.写一个jsp页面

写一个测试使用的index.jsp页面,仅包含一个超链接标签。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Spring MVC来啦~</title>
</head>
<body>
    <h1>测试</h1>
    <a href="atfwus">开始</a>
</body>
</html>

2.写一个控制器

  • 加上Spring MVC的注解。
  • 返回字符串success。
@Controller
public class ATFWUS {
    @RequestMapping(path = "/atfwus")
    public String sayHello(){
        System.out.println("ATFWUS!!!");
        return "success";
    }

3.编写Spring MVC的配置文件

配置视图解析器,并告知Spring需要扫描的包。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation=" http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd  http://www.springframework.org/schema/mvc
 http://www.springframework.org/schema/mvc/spring-mvc.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context.xsd"
>

    <!-- 配置spring创建容器时要扫描的包 -->
    <context:component-scan base-package="com.atfwus"></context:component-scan>
    <!-- 配置视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
    <mvc:annotation-driven/>
</beans>

4.编写成功的跳转页面

-在WEB-INF/pages里面写 success.jsp页面。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Success</title>
</head>
<body>
    <h3>Success!!!</h3>
</body>
</html>

5.配置web.xml文件

配置Spring MVC的核心控制器。

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >


<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <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:springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

6.启动服务器,测试

Part3Spring MVC工作流程剖析

1.例子中的流程分析

麻雀虽小,五脏俱全,在上述的小case中,已经包含Spring MVC的主要部分。我们看一下上述case的执行流程吧:

  • 因为在web.xml中配置了load-on-startup,所以,服务器一启动,就创建了DispatcherServlet对象。
  • DispatcherServlet标签的内部,配置了springmvc.xml的位置,所以服务器开始加载这个配置文件。
  • 用户点击index.jsp的超链接标签,向服务器发送了请求。
  • 请求到达DispatcherServlet核心控制器。
  • 控制器根据配置@RequestMapping注解找到执行的具体方法。
  • 方法执行完毕,返回字符串success
  • 根据配置的视图解析器,前往指定的目录中查找指定名称且后缀为jsp的文件。
  • 查找文件成功,服务器开始渲染页面,做出响应。
  • 跳转到success页面。

2.Spring MVC的请求响应流程

  1. 用户通过浏览器发送请求至服务器,然后直接进入前端控制器DispatcherServlet
  2. DispatcherServlet收到请求后,开始调用HandlerMapping处理器映射器,请求获取Handle
  3. 处理器映射器根据请求url找到具体的处理器,生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServ3let
  4. DispatcherServlet 调用 HandlerAdapter处理器适配器,请求执行Handler
  5. HandlerAdapter 经过适配调用 具体处理器(Handler,也叫后端控制器);
  6. Handler执行完成返回ModelAndView
  7. HandlerAdapterHandler执行结果ModelAndView返回给DispatcherServlet
  8. DispatcherServletModelAndView传给ViewResolver视图解析器进行解析;
  9. ViewResolver解析后视图后返回具体View对象;
  10. DispatcherServlet将模型数据填充至视图中(对View进行渲染视图);
  11. DispatcherServlet通过服务器返回响应的结果给用户。

3.Spring MVC核心组件

(1)前端控制器 DispatcherServlet

  • 接收请求、转发请求,响应结果,相当于是一个中转站,是整个流程中的核心部分。
  • 统一调度,降低组件之间的耦合性,提高每个组件的扩展性。
  • 此组件框架提供。(2)处理器映射器HandlerMapping
  • 根据请求的URL来查找Handler。
  • 此组件框架提供。(3)处理器适配器HandlerAdapter
  • 按照特定规则去执行Handler。
  • 需要对适配器进行拓展。(4)处理器Handler
  • Handler 是继DispatcherServlet前端控制器的后端控制器,在DispatcherServlet的控制下Handler对具体的用户请求进行处理。
  • 此组件需要根据需求编写。(5)视图解析器View resolver
  • 进行视图的解析,根据视图逻辑名解析成真正的视图。
  • 此组件框架提供。(6)视图View
  • View是一个接口, 它的实现类支持不同的视图类型,如(html,jsp,pdf)。
  • 此组件需要根据具体需求编写。

Part4Spring MVC参数绑定机制

1.绑定说明

  • SpringMVC的参数绑定过程是把表单提交的请求参数,作为控制器中方法的参数进行绑定的。
  • 表单提交的数据都是k=v格式。
  • 支持绑定的数据类型:
    • 基本数据类型和字符串类型。
    • 实体类型(JavaBean)。
    • 集合数据类型(List、map集合等)。

2.基本数据类型和String类型

必须保证提交表单的name和参数的名称是相同的。

控制类:

@Controller
@RequestMapping("/param")
public class ParamController {
  @RequestMapping("/saveAccount")
  public String saveAccount(String username,String password){
      System.out.println(username+password);
      return "success";
  }
}

jsp页面:

<a href="param/testParam?username=atfwus&password=atfwus">请求参数绑定</a>

3.JavaBean

  • 提交表单的name和JavaBean中的属性名称需要一致。
  • 如果一个JavaBean类中包含其他的引用类型,那么表单的name属性需要编写成:对象.属性。(如data.msg)bean:
public class Data implements Serializable {
private Integer status;
private String msg;
//getters and setters
@Override
//Override toString methond
}
public class Account implements Serializable {
private String username;
private String password;
private double money;
private Data data;
//getters and setters
@Override
//Override toString methond
}

控制器:

@Controller
@RequestMapping("/param")
public class ParamController {
  @RequestMapping("/saveAccount")
  public String saveAccount(Account acount){
      System.out.println(acount);
      return "success";
  }
}

jsp页面:

<form action="param/saveAccount" method="post">
    名称:<input type="text" name="username"/><br/>
    密码:<input type="text" name="password"/><br/>
    余额:<input type="text" name="money"/><br/>
    状态:<input type="text" name="data.status"/><br/>
    信息:<input type="text" name="data.msg"/><br/>
    <input type="submit" value="提交" />
</form>

4.集合类型封装

  • 在jsp页面中的表单name里面写list[index].属性(index为集合下标)。
  • 其它部分与JavaBean基本一致。

5.Spring MVC解决请求参数乱码

SpringMVC内置了解决请求参数乱码的过滤器,只需在web.xml中配置即可。

<!--  配置解决中文乱码的控制器-->
<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>
</filter>
<filter-mapping>
  <filter-name>characterEncodingFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

6.自定义类型转换器

  • 表单提交的任何数据类型全部都是字符串类型。
  • Spring框架内部会默认进行数据类型转换。
  • 如果想自定义数据类型转换,可以实现Converter的接口

自定义一个类型转换的工具类并实现Converter接口:

public class StringToDate implements Converter<String,Date{
    @Override
    public Date convert(String source) {
        if(source==null){
            throw new RuntimeException("数据为空!");
        }
        DateFormat df=new SimpleDateFormat("yyyy年-MM月-dd号");
        try {
            return df.parse(source);
        } catch (ParseException e) {
            throw new RuntimeException("转换异常!");
        }
    }
}

配置文件中注册自定义类型转换器:

<!--    配置自定义类型转换器-->
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
     <property name="converters">
        <set>
            <bean id="StringToDate" class="com.atfwus.utils.StringToDate"></bean>
        </set>
    </property>
</bean>
<mvc:annotation-driven conversion-service="conversionService"/>

7.获取servlet原生API

  • SpringMVC支持使用原始 ServletAPI对象作为控制器方法的参数。
  • 具体API如下:
    • HttpServletRequest
    • HttpServletResponse
    • HttpSession
    • java.security.Principal
    • Locale
    • InputStream
    • OutputStream
    • Reader
    • Writer
  • 只需要在控制器的方法参数定义这些这些API的对象即可。

Part5Spring MVC常用注解

1.@RequestMapping:

  • 用于处理请求 url 映射的注解,可用于类或方法上。用于类上,则表示类中的所有响应请求的方法都是以该地址作为父路径。
  • 作用在类上是 第一级的访问目录,作用在方法上是 第二级的访问目录。
  • 路径可以不写 / 表示应用的根目录开始。
  • 在请求的页面中,路径可以省略${ pageContext.request.contextPath },但是不能写/。
  • 属性:
    • path:指定请求路径的url。
    • value:和path属性是一样的。
    • mthod:指定该方法的请求方式。
    • params:指定限制请求参数的条件。
    • headers:发送的请求中必须包含的请求头。
    • consumes:指定处理请求的提交内容类型,如application/json, text/html。
    • produces:指定返回的内容类型,仅当request请求头中的类型中包含该指定类型才返回。

2.@RequestParam:

  • 作用:把请求中的指定名称的参数传递给控制器中的形参赋值。
  • 属性:
    • value:请求参数中的名称。
    • required:请求参数中是否必须提供此参数,默认值是true,必须提供。例如:
public String atfwus(@RequestParam(value="username",required=false)String name)

3.@RequestBody:

  • 作用:用于获取请求体的内容(get方式没有请求体)。
  • 属性:
    • required:是否必须有请求体,默认值是true。例如:
public String atfwus(@RequestBody String body)

4.@PathVariable:

  • 作用:用于绑定url中的占位符。例如:url中有/delete/{id},{id}就是占位符。
  • url支持占位符是 springmvc支持 rest风格 URL的一个重要标志。
  • 属性:
    • value:指定url中的占位符名称。例如:
@RequestMapping(path="/hello/{id}")
public String atfwus(@PathVariable(value="id") String id) {

5.@RequestHeader:

  • 作用:获取指定请求头的值.
  • 属性:
    • value:请求头的名称。例如:
public String atfwus(@RequestHeader(value="Accept") String header)

6.@CookieValue:

  • 作用:用于获取指定cookie的名称的值。
  • 属性:
    • value:cookie的名称。例如:
public String atfwus(@CookieValue(value="JSESSIONID") String cookieValue)

7.@ModelAttribute:

  • 出现在方法上:表示当前方法会在控制器方法执行前先执行。
  • 出现在参数上:获取指定的数据给参数赋值。
  • 用途:当提交表单数据不是完整的实体数据时,保证没有提交的字段使用数据库原来的数据。
  • 如果所在方法有返回值,那么直接返回,如果没有,需要提供一个map集合,先将数据存入map集合。8.@SessionAttributes:
  • 作用:用于多次执行控制器方法间的参数共享。
  • 属性:
    • value:指定存入属性的名称。例如:
@Controller
@RequestMapping("/anno")
@SessionAttributes(value={"msg"})
public class AnnoController {
  @RequestMapping(value="/testSessionAttributes")
  public String testSessionAttributes(Model model){
  model.addAttribute("msg","atfwus");
  return "success";
  }
  @RequestMapping(value="/getSessionAttributes")
  public String getSessionAttributes(ModelMap modelMap){
  String msg = (String) modelMap.get("msg");
  System.out.println(msg);
  return "success";
  }
  @RequestMapping(value="/delSessionAttributes")
  public String delSessionAttributes(SessionStatus status){
  status.setComplete();
  return "success";
  }
}

Part6Spring MVC响应数据

1.String类型返回值

  • Controller方法返回字符串可以指定逻辑视图的名称,根据视图解析器为物理视图的地址。
  • 如上述例子中,返回success,然后试图解析器解析后,跳转到success.jsp页面。
  • 实际用途:调用此方法的同时,将数据存入到model中,然后框架将数据存入request中,将数据转发到新的页面。

2.void类型返回值

  • 如果控制器的方法返回值编写是void,默认会跳转到@RequestMapping(value="/initUpdate") initUpdate的页面。
  • 可以使用请求转发或者重定向跳转到指定的页面。还可以直接响应。
@RequestMapping("/testVoid")
public void testVoid(HttpServletRequest request, HttpServletResponse response) throws Exception {
  // 请求转发
  request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);

  // 重定向
  response.sendRedirect(request.getContextPath()+"/index.jsp");

  // 解决中文乱码
  response.setCharacterEncoding("UTF-8");
  response.setContentType("text/html;charset=UTF-8");

  // 直接进行响应
  response.getWriter().print("响应");
}

3.ModelAndView对象类型返回值

  • ModelAndView对象是Spring提供的一个对象,可以用来调整具体的JSP视图。
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
  // 创建ModelAndView对象
  ModelAndView mv = new ModelAndView();
  String name="ATFWUS";
  // 把name存储到mv对象中,也会把name存入到request对象
  mv.addObject("user",name);
  // 跳转页面
  mv.setViewName("success")
  return mv;
}

4.Spring MVC提供的转发和重定向

  • forward请求转发:
return "forward:/WEB-INF/pages/success.jsp";
  • redirect重定向:
return "redirect:/add.jsp";

5.响应json数据(ResponseBody)

配置静态资源不进行拦截:

  • DispatcherServlet会拦截到所有的资源,导致静态资源(img、css、js)也会被拦截到,如果需要设置不拦截,需要在springmvc.xml中进行配置。
  • mvc:resources:标签配置不过滤。
  • location元素表示webapp目录下的包下的所有文件
  • mapping元素表示以/static开头的所有请求路径。
<!-- 设置静态资源不过滤 -->
<mvc:resources location="/css/" mapping="/css/**"/>
<mvc:resources location="/images/" mapping="/images/**"/>
<mvc:resources location="/js/" mapping="/js/**"/>

使用@RequestBody注解把json的字符串转换成JavaBean的对象:发送ajax请求:

<script>
    $(function(){
        $("#btn").click(function(){
            $.ajax({
                // 编写json格式,设置属性和值
                url:"user/testAjax",
                contentType:"application/json;charset=UTF-8",
                data:'{"username":"atfwus","password":"atfwus","age":19}',
                dataType:"json",
                type:"post",
                success:function(data){
                 // 服务器端响应的json的数据,进行解析
                 alert(data);
                }
            });
        });
    });
</script>

控制器代码:

  • 在导入相关的jar包的前提下,Spring MVC可以直接把相关的json数据转换成JavaBean。
  • jar包:jackson-annotationsjackson-datablindjackson-core
@RequestMapping("/testJson")
public void testJson(@RequestBody User user) {
  System.out.println(user);
}

使用@ResponseBody注解把JavaBean对象转换成json字符串:

  • @ResponseBody作用:该注解用于将Controller的方法返回的对象,通过适当的HttpMessageConverter转换为指定格式后,写入到Response对象的body数据区。
@RequestMapping("/testAjax")
public @ResponseBody User testAjax(@RequestBody User user){
  // 后端把json字符串封装到user对象中
  System.out.println(user);
  // 响应
  user.setUsername("ATFWUS");
  return user;
}

Part7Spring MVC文件上传

  • 文件上传时form表单的 enctype取值必须是:multipart/form-data
  • 文件上传时method属性取值必须是 Post
  • 文件上传需要提供一个文件选择域<input type=”file” />
  • 下列代码需要的jar包:commons-fileuploadcommons-iojersey-clientjersey-core

1.jsp页面

<form action="/user/fileupload1" method="post" enctype="multipart/form-data">
        选择文件:<input type="file" name="upload" /><br/>
        <input type="submit" value="上传" />
</form>

2.传统文件上传

// 使用fileupload组件完成文件上传
@RequestMapping("/fileupload1")
public String fileuoload1(HttpServletRequest request) throws Exception {
    // 上传的位置
    String path = request.getSession().getServletContext().getRealPath("/uploads/");
    // 判断,该路径是否存在
    File file = new File(path);
    if(!file.exists()){
        // 创建该文件夹
        file.mkdirs();
    }
    // 解析request对象,获取上传文件项
    DiskFileItemFactory factory = new DiskFileItemFactory();
    ServletFileUpload upload = new ServletFileUpload(factory);
    // 解析request
    List<FileItem> items = upload.parseRequest(request);
    // 遍历
    for(FileItem item:items){
        // 进行判断,当前item对象是否是上传文件项
        if(item.isFormField()){
            // 说明普通表单向
        }else{
            // 说明上传文件项
            // 获取上传文件的名称
            String filename = item.getName();
            // 把文件的名称设置唯一值,uuid
            String uuid = UUID.randomUUID().toString().replace("-""");
            filename = uuid+"_"+filename;
            // 完成文件上传
            item.write(new File(path,filename));
            // 删除临时文件
            item.delete();
        }
    }
    return "success";
}

3.Spring MVC上传文件

  • SpringMVC框架提供了MultipartFile对象,该对象表示上传的文件,要求变量名称必须和表单file标签的name属性名称相同。
  • 配置文件解析器:
<!--配置文件解析器对象-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="maxUploadSize" value="1000000" />
</bean>
  • 控制器代码:
// 使用fileupload组件完成文件上传
@RequestMapping("/fileupload2")
public String fileuoload2(HttpServletRequest request, MultipartFile upload) throws Exception {
    // 上传的位置
    String path = request.getSession().getServletContext().getRealPath("/uploads/");
    // 判断,该路径是否存在
    File file = new File(path);
    if(!file.exists()){
        // 创建该文件夹
        file.mkdirs();
    }
    // 说明上传文件项
    // 获取上传文件的名称
    String filename = upload.getOriginalFilename();
    // 把文件的名称设置唯一值,uuid
    String uuid = UUID.randomUUID().toString().replace("-""");
    filename = uuid+"_"+filename;
    // 完成文件上传
    upload.transferTo(new File(path,filename));
    return "success";
}

4.跨服务器文件上传:

  • 将文件跨服务器进行上传。
@RequestMapping("/fileupload3")
public String fileuoload3(MultipartFile upload) throws Exception {
    // 定义上传文件服务器路径
    String path = "http://localhost:8090/uploads/";
    // 说明上传文件项
    // 获取上传文件的名称
    String filename = upload.getOriginalFilename();
    // 把文件的名称设置唯一值,uuid
    String uuid = UUID.randomUUID().toString().replace("-""");
    filename = uuid+"_"+filename;
    // 创建客户端的对象
    Client client = Client.create();
    // 和图片服务器进行连接
    WebResource webResource = client.resource(path + filename);
    // 上传文件
    webResource.put(upload.getBytes());
    return "success";
}

Part8Spring MVC异常处理

系统的 dao、service、controller出现异常都会通过 throws Exception向上抛出,最后由 Spring MVC前端控制器交由异常处理器进行异常处理。

1.自定义异常类

public class SysException extends Exception{
  // 存储提示信息的
  private String message;
  //get and set
  public SysException(String message) {
      this.message = message;
  }
}

2.自定义异常处理器

public class SysExceptionResolver implements HandlerExceptionResolver{
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
      // 获取到异常对象
      SysException e = null;
      if(ex instanceof SysException){
          e = (SysException)ex;
      }else{
          e = new SysException("出异常了");
      }
      // 创建ModelAndView对象
      ModelAndView mv = new ModelAndView();
      mv.addObject("errorMsg",e.getMessage());
      mv.setViewName("error");
      return mv;
  }
}

3.配置异常处理器

<!-- 配置异常处理器 -->
<bean id="sysExceptionResolver" class="cn.atfwus.exception.SysExceptionResolver"/>

4.测试异常处理

@RequestMapping("/testException")
public String testException() throws SysException {
    try {
        // 模拟异常
        int a = 0/0;
    } catch (Exception e) {
        // 打印异常信息
        e.printStackTrace();
        // 抛出自定义异常
        throw new SysException("出异常了");
    }
    return "success";
}

Part9Spring MVC拦截器

  • Spring MVC 的处理器拦截器类似于 Servlet 开发中的过滤器 Filter,用于对处理器进行预处理和后处理。
  • 拦截器和过滤器的区别:
    • 过滤器是Servlet规范的一部分,任何框架都可以使用过滤器技术。拦截器是SpringMVC框架独有的。
    • 过滤器配置了/*,可以拦截任何资源。拦截器只会对控制器中的方法进行拦截。
  • 拦截器是AOP思想的一种实现方式。
  • 可以定义拦截器链,连接器链就是将拦截器按着一定的顺序结成一条链,在访问被拦截的方法时,拦截器链中的拦截器会按着定义的顺序执行。
  • 如果需要自定义拦截器,需要实现HandlerInterceptor接口。

1.自定义拦截器类

需要实现HandlerInterceptor接口。

public class MyInterceptor1 implements HandlerInterceptor{

  // 预处理,controller方法执行前
  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
      System.out.println("MyInterceptor前");
      // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
      return true;
  }


  // 后处理方法,controller方法执行后,success.jsp执行之前
  public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
      System.out.println("MyInterceptor执行");
      // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
  }


  //success.jsp页面执行后,该方法会执行
  public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
      System.out.println("MyInterceptor最后");
  }
}

2.配置拦截器

<!--配置拦截器-->
<mvc:interceptors>
    <!--配置拦截器-->
    <mvc:interceptor>
        <!--要拦截的具体的方法-->
        <mvc:mapping path="/user/*"/>
        <!--不要拦截的方法
        <mvc:exclude-mapping path=""/>
            -->

        <!--配置拦截器对象-->
        <bean class="cn.atfwus.controller.cn.itcast.interceptor.MyInterceptor1" />
    </mvc:interceptor>

    <!--配置第二个拦截器-->
    <mvc:interceptor>
        <!--要拦截的具体的方法-->
        <mvc:mapping path="/**"/>
        <!--不要拦截的方法
        <mvc:exclude-mapping path=""/>
        -->

        <!--配置拦截器对象-->
        <bean class="cn.itcast.controller.cn.atfwus.interceptor.MyInterceptor2" />
    </mvc:interceptor>
</mvc:interceptors>

3.接口中的方法

  • preHandle方法:是controller方法执行前拦截的方法。可以使用request或者response跳转到指定的页面。return true放行,执行下一个拦截器,如果没有拦截器,执行controller中的方法。return false不放行,不会执行controller中的方法。
  • postHandle方法:是controller方法执行后执行的方法,在JSP视图执行前。可以使用request或者response跳转到指定的页面。如果指定了跳转的页面,那么controller方法跳转的页面将不会显示。
  • postHandle方法:是在JSP执行后执行。request或者response不能再跳转页面了。

Part10总结Spring MVC优势分析

  1. 方便与Spring框架集成(如IoC容器、AOP等);
  2. 能够使我们进行更简洁的Web层的开发;
  3. 清晰的角色划分,前端控制器(dispatcherServlet) , 请求到处理器映射(handlerMapping), 处理器适配器(HandlerAdapter), 视图解析器(ViewResolver)。
  4. 可以支持各种视图技术,而不仅仅局限于JSP;
  5. 支持各种请求资源的映射策略。
  6. 可适配、非侵入:可以根据不同的应用场景,选择合适的控制器子类 (simple型、command型、form型、wizard型、multi-action型或者自定义),而不是从单一控制器 (比如Action/ActionForm)继承。
  7. 简单而强大的JSP标签库(SpringTag Library):支持包括诸如数据绑定和主题之类的许多功能。
  8. 非常灵活的数据验证、格式化和数据绑定机制。
  9. 支持Restful风格。
  10. 灵活的model转换:在Springweb框架中,使用基于Map的 键/值对来达到轻易地与各种视图技术的集成。

SpringMVC 和 Struts2 对比:

相同点:

  • 它们都是表现层框架,都是基于 MVC模型编写的。
  • 它们的底层都离不开原始 ServletAPI。
  • 它们处理请求的机制都是一个核心控制器。不同点:
  • Spring MVC 的入口是 Servlet, 而 Struts2 是 Filter。
  • Spring MVC 是基于方法设计的,而 Struts2是基于类,Struts2每次执行都会创建一个动作类。所以 Spring MVC 会稍微比 Struts2 快些。
  • Spring MVC 使用更加简洁,同时还支持 JSR303, 处理 ajax 的请求更方便。
  • Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些,但执行效率并没有比 JSTL 提升,尤其是 struts2的表单标签,远没有 html执行效率高。
  • 与spring整合不一样。Spring MVC是spring框架的一部分,不需要整合。
-- END --

 | 更多精彩文章 -



加我微信,交个朋友
长按/扫码添加↑↑↑

浏览 26
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报