SpringMVC

最新推荐文章于 2024-07-17 19:46:36 发布

的卢小码

最新推荐文章于 2024-07-17 19:46:36 发布

阅读量184

点赞数

本文链接：https://blog.csdn.net/caozongjin/article/details/122204466

版权

java framework 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1 SpringMVC概述

1.1 SpringMVC简介

SpringMVC也叫Spring web mvc。是Spring框架的一部分，是在Spring3.0后发布的。

1.2 SpringMVC 优点

1.基于MVC架构

基于MVC架构，功能分工明确。解耦合。

2.容易理解，上手快；使用简单。

就可以开发一个注解的SpringMVC项目，SpringMVC也是轻量级的，jar很小。不依赖的特定的接口和类。

3.作为Spring框架一部分，能够使用Spring的IoC和Aop。方便整合Strtus,MyBatis,Hiberate,JPA等其他框架。

4.SpringMVC强化注解的使用，在控制器，Service，Dao都可以使用注解。方便灵活。

使用@Controller创建处理器对象,@Service创建业务对象，@Autowired或者@Resource在控制器类中注入Service, Service类中注入Dao。

1.3 第一个注解的SpringMVC程序

所谓SpringMVC的注解式开发是指，在代码中通过对类与方法的注解，便可完成处理器在springmvc容器的注册。注解式开发是重点。

新建web maven工程
加入依赖

<dependency>  
    <groupId>javax.servlet</groupId>  
    <artifactId>javax.servlet-api</artifactId>  
    <version>3.1.0</version>  
    <scope>provided</scope>  
</dependency>  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-webmvc</artifactId>  
    <version>5.2.5.RELEASE</version>  
</dependency>

重点：在web.xml中注册springmvc框架的核心对象DispatcherServlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!--声明，注册springmvc的核心对象DispatcherServlet
        需要在tomcat服务器启动后，创建DispatcherServlet对象的实例。
        为什么要创建DispatcherServlet对象的实例呢？
        因为DispatcherServlet在他的创建过程中， 会同时创建springmvc容器对象，
        读取springmvc的配置文件，把这个配置文件中的对象都创建好， 当用户发起
        请求时就可以直接使用对象了。

        servlet的初始化会执行init（）方法。 DispatcherServlet在init（）中{
           //创建容器，读取配置文件
           WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
           //把容器对象放入到ServletContext中
           getServletContext().setAttribute(key, ctx);
        }
        启动tomcat报错，读取这个文件 /WEB-INF/springmvc-servlet.xml（/WEB-INF/myweb-servlet.xml）
        springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml .
    -->
    <servlet>
        <servlet-name>myweb</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--自定义springmvc读取的配置文件的位置-->
        <init-param>
            <!--springmvc的配置文件的位置的属性-->
            <param-name>contextConfigLocation</param-name>
            <!--指定自定义文件的位置-->
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>

        <!--在tomcat启动后，创建Servlet对象
            load-on-startup:表示tomcat启动后创建对象的顺序。它的值是整数，数值越小，
                            tomcat创建对象的时间越早。 大于等于0的整数。
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>myweb</servlet-name>
        <!--
            使用框架的时候， url-pattern可以使用两种值
            1. 使用扩展名方式， 语法 *.xxxx , xxxx是自定义的扩展名。 常用的方式 *.do, *.action, *.mvc等等
               不能使用 *.jsp
               http://localhost:8080/myweb/some.do
               http://localhost:8080/myweb/other.do

            2.使用斜杠 "/"
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

创建一个发起请求的页面 index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
     <p>第一个springmvc项目</p>
     <p><a href="some.do">发起some.do的请求</a> </p>
     <p><a href="other.do">发起other.do的请求</a> </p>
</body>
</html>

创建控制器(处理器)类

/**
 *  @Controller:创建处理器对象，对象放在springmvc容器中。
 *  位置：在类的上面
 *  和Spring中讲的@Service ,@Component
 *
 *  能处理请求的都是控制器（处理器）： MyController能处理请求，
 *                         叫做后端控制器（back controller）
 *
 *  没有注解之前，需要实现各种不同的接口才能做控制器使用
 */
@Controller
public class MyController {
    /*
       处理用户提交的请求，springmvc中是使用方法来处理的。
       方法是自定义的， 可以有多种返回值， 多种参数，方法名称自定义
     */

    /**
     * 准备使用doSome方法处理some.do请求。
     * @RequestMapping: 请求映射，作用是把一个请求地址和一个方法绑定在一起。
     *                  一个请求指定一个方法处理。
     *       属性： 1. value 是一个String，表示请求的uri地址的（some.do）。
     *                value的值必须是唯一的， 不能重复。 在使用时，推荐地址以“/”
     *       位置：1.在方法的上面，常用的。
     *            2.在类的上面
     *  说明： 使用RequestMapping修饰的方法叫做处理器方法或者控制器方法。
     *  使用@RequestMapping修饰的方法可以处理请求的，类似Servlet中的doGet, doPost
     *
     *  返回值：ModelAndView 表示本次请求的处理结果
     *   Model: 数据，请求处理完成后，要显示给用户的数据
     *   View: 视图， 比如jsp等等。
     */
    @RequestMapping(value = {"/some.do","/first.do"})
    public ModelAndView doSome(){  // doGet()--service请求处理
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        //添加数据， 框架在请求的最后把数据放入到request作用域。
        //request.setAttribute("msg","欢迎使用springmvc做web开发");
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");

        //指定视图, 指定视图的完整路径
        //框架对视图执行的forward操作， request.getRequestDispather("/show.jsp).forward(...)
        //mv.setViewName("/show.jsp");
        //mv.setViewName("/WEB-INF/view/show.jsp");
        //mv.setViewName("/WEB-INF/view/other.jsp");


        //当配置了视图解析器后，可以使用逻辑名称（文件名），指定视图
        //框架会使用视图解析器的前缀 + 逻辑名称 + 后缀 组成完成路径， 这里就是字符连接操作
        ///WEB-INF/view/ + show + .jsp
        mv.setViewName("show");

        //mv.setView( new RedirectView("/a.jsp"));

        //返回mv
        return mv;
    }

    @RequestMapping(value = {"/other.do","/second.do"})
    public ModelAndView doOther(){
        ModelAndView mv  = new ModelAndView();
        mv.addObject("msg","====欢迎使用springmvc做web开发====");
        mv.addObject("fun","执行的是doOther方法");
        mv.setViewName("other");
        return mv;
    }
}

创建一个作为结果的jsp，显示请求的处理结果。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>/WEB-INF/view/show.jsp从request作用域获取数据</h3><br/>
    <h3>msg数据：${msg}</h3><br/>
    <h3>fun数据：${fun}</h3>
</body>
</html>

创建springmvc的配置文件（spring的配置文件一样）
1）声明组件扫描器，指定@Contorller注解所在的包名
2）声明视图解析器。帮助处理视图的。

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

    <!--声明组件扫描器-->
    <context:component-scan base-package="com.bjpowernode.controller" />

    <!--声明 springmvc框架中的视图解析器， 帮助开发人员设置视图文件的路径-->
    <bean  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀：视图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/" />
        <!--后缀：视图文件的扩展名-->
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

SpringMVC框架为了避免对于请求资源路径与扩展名上的冗余，在视图解析器InternalResouceViewResolver中引入了请求的前辍与后辍。而ModelAndView中只需给出要跳转页面的文件名即可，对于具体的文件路径与文件扩展名，视图解析器会自动完成拼接。

1.4 SpringMVC执行流程

在这里插入图片描述

（1）浏览器提交请求到中央调度器

（2）中央调度器直接将请求转给处理器映射器。

（3）处理器映射器会根据请求，找到处理该请求的处理器，并将其封装为处理器执行链后返回给中央调度器。

（4）中央调度器根据处理器执行链中的处理器，找到能够执行该处理器的处理器适配器。

（5）处理器适配器调用执行处理器。

（6）处理器将处理结果及要跳转的视图封装到一个对象ModelAndView中，并将其返回给处理器适配器。

（7）处理器适配器直接将结果返回给中央调度器。

（8）中央调度器调用视图解析器，将ModelAndView中的视图名称封装为视图对象。

（9）视图解析器将封装了的视图对象返回给中央调度器

（10）中央调度器调用视图对象，让其自己进行渲染，即进行数据填充，形成响应对象。

（11）中央调度器响应浏览器。

2 SpringMVC注解式开发

2.1 @RequestMapping定义请求规则

2.1.1 指定模块名称

通过@RequestMapping注解可以定义处理器对于请求的映射规则。该注解可以注解在方法上，也可以注解在类上，但意义是不同的。value属性值常以“/”开始。

@RequestMapping的value属性用于定义所匹配请求的URI。但对于注解在方法上与类上，其value属性所指定的URI，意义是不同的。一个@Controller所注解的类中，可以定义多个处理器方法。当然，不同的处理器方法所匹配的URI是不同的。这些不同的URI被指定在注解于方法之上的@RequestMapping的value属性中。但若这些请求具有相同的URI部分，则这些相同的URI，可以被抽取到注解在类之上的@RequestMapping的value属性中。此时的这个URI表示模块的名称。URI的请求是相对于Web的根目录。

/**
 * @RequestMapping:
 *    value ： 所有请求地址的公共部分，叫做模块名称
 *    位置： 放在类的上面
 */
@Controller
@RequestMapping("/user")
public class MyController {

    /**
     * @RequestMapping : 请求映射
     *             属性： method， 表示请求的方式。 它的值RequestMethod类枚举值。
     *                    例如表示get请求方式， RequestMethod.GET
     *                    post方式， RequestMethod.POST
     *
     *  你不用get方式，错误是：
     *  HTTP Status 405 - Request method 'GET' not supported
     */
    //指定some.do使用get请求方式
    @RequestMapping(value = "/some.do",method = RequestMethod.GET)
    public ModelAndView doSome(){  // doGet()--service请求处理
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");
        mv.setViewName("show");
        return mv;
    }

    //指定other.do是post请求方式
    @RequestMapping(value = "/other.do",method = RequestMethod.POST)
    public ModelAndView doOther(){
        ModelAndView mv  = new ModelAndView();
        mv.addObject("msg","====欢迎使用springmvc做web开发====");
        mv.addObject("fun","执行的是doOther方法");
        mv.setViewName("other");
        return mv;
    }

    //不指定请求方式，没有限制
    @RequestMapping(value = "/first.do")
    public ModelAndView doFirst(HttpServletRequest request,
                                HttpServletResponse response,
                                HttpSession session){
        ModelAndView mv  = new ModelAndView();
        mv.addObject("msg","====欢迎使用springmvc做web开发====" + 			       request.getParameter("name"));
        mv.addObject("fun","执行的是doFirst方法");
        mv.setViewName("other");
        return mv;
    }
}

2.1.2 对请求提交方式的定义

对于@RequestMapping，其有一个属性method，用于对被注解方法所处理请求的提交方式进行限制，即只有满足该method属性指定的提交方式的请求，才会执行该被注解方法。

Method属性的取值为RequestMethod枚举常量。常用的为RequestMethod.GET与RequestMethod.POST，分别表示提交方式的匹配规则为GET与POST提交。

客户端浏览器常用的请求方式，及其提交方式有以下几种：

请求方式	提交方式
表单请求	默认GET，可以指定POST
AJAX请求	默认GET，可以指定POST
地址栏请求	GET
超链接请求	GET
src资源路径请求	GET

也就是说，只要指定了处理器方法匹配的请求提交方式为POST，则相当于指定了请求发送的方式：要么使用表单请求，要么使用AJAX请求。其它请求方式被禁用。

当然，若不指定method属性，则无论是GET还是POST提交方式，均可匹配。即对于请求的提交方式无要求。

2.2 处理器方法的参数

处理器方法可以包含以下四类参数，这些参数会在系统调用时由系统自动赋值，即程序员可在方法内直接使用。

➢ HttpServletRequest

➢ HttpServletResponse

➢ HttpSession

➢ 请求中所携带的请求参数

2.2.1 逐个参数接收

只要保证请求参数名与该请求处理方法的参数名相同即可。

/**
     * 逐个接收请求参数：
     *   要求： 处理器（控制器）方法的形参名和请求中参数名必须一致。
     *          同名的请求参数赋值给同名的形参
     * 框架接收请求参数
     *   1. 使用request对象接收请求参数
     *      String strName = request.getParameter("name");
     *      String strAge = request.getParameter("age");
     *   2. springmvc框架通过 DispatcherServlet 调用 MyController的doSome()方法
     *      调用方法时，按名称对应，把接收的参数赋值给形参
     *      doSome（strName，Integer.valueOf(strAge)）
     *      框架会提供类型转换的功能，能把String转为 int ，long ， float， double等类型。
     *
     *  400状态码是客户端错误， 表示提交请求参数过程中，发生了问题。
     */
    @RequestMapping(value = "/receiveproperty.do")
    public ModelAndView doSome(String name, Integer age){
        System.out.println("doSome, name="+name+"   age="+age);
        //可以在方法中直接使用 name ， age
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",Integer.valueOf(age));
        //show是视图文件的逻辑名称（文件名称）
        mv.setViewName("show");
        return mv;
    }

2.2.2 请求参数中文乱码问题

对于所接收的请求参数，若含有中文，则会出现中文乱码问题。Spring对于请求参数中的中文乱码问题，给出了专门的字符集过滤器：spring-web-5.2.5.RELEASE.jar的org.springframework.web.filter包下的CharacterEncodingFilter类。

解决方案

在web.xml中注册字符集过滤器，即可解决Spring的请求参数的中文乱码问题。不过，最好将该过滤器注册在其它过滤器之前。因为过滤器的执行是按照其注册顺序进行的。

<!--注册声明过滤器，解决post请求乱码的问题-->
<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>
    <!--强制请求对象（HttpServletRequest）使用encoding编码的值-->
    <init-param>
        <param-name>forceRequestEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
    <!--强制应答对象（HttpServletResponse）使用encoding编码的值-->
    <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>

源码分析

protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String encoding = this.getEncoding();
        if (encoding != null) {
            if (this.isForceRequestEncoding() || request.getCharacterEncoding() == null) {
                request.setCharacterEncoding(encoding);
            }

            if (this.isForceResponseEncoding()) {
                response.setCharacterEncoding(encoding);
            }
        }

        filterChain.doFilter(request, response);
    }

2.2.3 校正请求参数名@RequestParam

所谓校正请求参数名，是指若请求URL所携带的参数名称与处理方法中指定的参数名不相同时，则需在处理方法参数前，添加一个注解@RequestParam(“请求参数名”)，指定请求URL所携带参数的名称。该注解是对处理器方法参数进行修饰的。value属性指定请求参数的名称。

/**
 * 请求中参数名和处理器方法的形参名不一样
 * @RequestParam: 逐个接收请求参数中， 解决请求中参数名形参名不一样的问题
 *      属性： 1. value 请求中的参数名称
 *            2. required 是一个boolean，默认是true
 *                true：表示请求中必须包含此参数。
 *      位置： 在处理器方法的形参定义的前面
 */
@RequestMapping(value = "/receiveparam.do")
public ModelAndView receiveParam(@RequestParam(value = "rname",required = false) String name,
                                 @RequestParam(value = "rage",required = false) Integer age){
    System.out.println("doSome, name="+name+"   age="+age);
    //可以在方法中直接使用 name ， age
    //处理some.do请求了。 相当于service调用处理完成了。
    ModelAndView mv  = new ModelAndView();
    mv.addObject("myname",name);
    mv.addObject("myage",age);
    //show是视图文件的逻辑名称（文件名称）
    mv.setViewName("show");
    return mv;
}

2.2.4 对象参数接收

将处理器方法的参数定义为一个对象，只要保证请求参数名与这个对象的属性同名即可。

/**
 * 处理器方法形参是java对象， 这个对象的属性名和请求中参数名一样的
 * 框架会创建形参的java对象， 给属性赋值。 请求中的参数是name，框架会调用setName()
 * @return
 */
@RequestMapping(value = "/receiveobject.do")
public ModelAndView receiveParam( Student myStudent){
    System.out.println("receiveParam, name="+myStudent.getName()+"   age="+myStudent.getAge());
    //可以在方法中直接使用 name ， age
    //处理some.do请求了。 相当于service调用处理完成了。
    ModelAndView mv  = new ModelAndView();
    mv.addObject("myname",myStudent.getName());
    mv.addObject("myage",myStudent.getAge());
    mv.addObject("mystudent",myStudent);
    //show是视图文件的逻辑名称（文件名称）
    mv.setViewName("show");
    return mv;
}

2.3 处理器方法的返回值

使用@Controller注解的处理器的处理器方法，其返回值常用的有四种类型：

➢ 第一种：ModelAndView

➢ 第二种：String

➢ 第三种：无返回值void

➢ 第四种：返回自定义类型对象

2.3.1 返回ModelAndView

若处理器方法处理完后，需要跳转到其它资源，且又要在跳转的资源间传递数据，此时处理器方法返回ModelAndView比较好。当然，若要返回ModelAndView，则处理器方法中需要定义ModelAndView对象。

在使用时，若该处理器方法只是进行跳转而不传递数据，或只是传递数据而并不向任何资源跳转（如对页面的Ajax异步响应），此时若返回ModelAndView，则将总是有一部分多余：要么Model多余，要么View多余。即此时返回ModelAndView将不合适。

2.3.2 返回String

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

/**
 * 处理器方法返回String--表示逻辑视图名称，需要配置视图解析器
 */
@RequestMapping(value = "/returnString-view.do")
public String doReturnView(HttpServletRequest request,String name, Integer age){
    System.out.println("doReturnView, name="+name+"   age="+age);
    //可以自己手工添加数据到request作用域
    request.setAttribute("myname",name);
    request.setAttribute("myage",age);
    // show : 逻辑视图名称，项目中配置了视图解析器
    // 框架对视图执行forward转发操作
    return "show";
}

//处理器方法返回String,表示完整视图路径， 此时不能配置视图解析器
    @RequestMapping(value = "/returnString-view2.do")
    public String doReturnView2(HttpServletRequest request,String name, Integer age){
        System.out.println("===doReturnView2====, name="+name+"   age="+age);
        //可以自己手工添加数据到request作用域
        request.setAttribute("myname",name);
        request.setAttribute("myage",age);
        // 完整视图路径，项目中不能配置视图解析器
        // 框架对视图执行forward转发操作
        // /WEB-INF/view//WEB-INF/view/show.jsp.jsp
        // /WEB-INF/view/WEB-INF/view/show.jsp.jsp
        return "/WEB-INF/view/show.jsp";
    }

2.3.3 返回void

对于处理器方法返回void的应用场景，AJAX响应.

若处理器对请求处理后，无需跳转到其它任何资源，此时可以让处理器方法返回void。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
     <script type="text/javascript" src="js/jquery-3.4.1.js"></script>
     <script type="text/javascript">
         $(function(){
             $("button").click(function(){
                 //alert("button click");
                 $.ajax({
                     //url:"returnVoid-ajax.do",
                     //url:"returnStudentJsonArray.do",
                     url:"returnStringData.do",
                     data:{
                         name:"zhangsan",
                         age:20
                     },
                     type:"post",
                     dataType:"text",
                     //dataType:"json",
                     success:function(resp){
                         //resp从服务器端返回的是json格式的字符串 {"name":"zhangsan","age":20}
                         //jquery会把字符串转为json对象， 赋值给resp形参。

                         // [{"name":"李四同学","age":20},{"name":"张三","age":28}]
                         //alert(resp.name + "    "+resp.age);

                         /*$.each(resp,function(i,n){
                             alert(n.name+"   "+n.age)
                         })*/
                         alert("返回的是文本数据："+resp);

                     }
                 })
             })
         })
     </script>
</head>
<body>
     <p>处理器方法返回String表示视图名称</p>
     <form action="returnString-view.do" method="post">
          姓名：<input type="text" name="name"> <br/>
          年龄：<input type="text" name="age"> <br/>
          <input type="submit" value="提交参数">
     </form>
     <br/>
     <p>处理器方法返回String表示视图完整路径</p>
     <form action="returnString-view2.do" method="post">
          姓名：<input type="text" name="name"> <br/>
          年龄：<input type="text" name="age"> <br/>
          <input type="submit" value="提交参数">
     </form>
    <br/>
    <br/>
    <button id="btn">发起ajax请求</button>

</body>
</html>

//处理器方法返回void， 响应ajax请求
    //手工实现ajax，json数据： 代码有重复的 1. java对象转为json； 2. 通过HttpServletResponse输出json数据
    @RequestMapping(value = "/returnVoid-ajax.do")
    public void doReturnVoidAjax(HttpServletResponse response, String name, Integer age) throws IOException {
        System.out.println("===doReturnVoidAjax====, name="+name+"   age="+age);
       //处理ajax， 使用json做数据的格式
       //service调用完成了， 使用Student表示处理结果
        Student student  = new Student();
        student.setName("张飞同学");
        student.setAge(28);

        String json = "";
        //把结果的对象转为json格式的数据
        if( student != null){
            ObjectMapper om  = new ObjectMapper();
            json  = om.writeValueAsString(student);
            System.out.println("student转换的json===="+json);
        }

        //输出数据，响应ajax的请求
        response.setContentType("application/json;charset=utf-8");
        PrintWriter pw  = response.getWriter();
        pw.println(json);
        pw.flush();
        pw.close();

    }

2.3.4 返回对象Object

处理器方法也可以返回Object对象。这个Object可以是Integer，String，自定义对象，Map，List等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出现的。

返回对象，需要使用@ResponseBody注解，将转换后的JSON数据放入到响应体中。

2.3.4.1 环境搭建

maven pom.xml

由于返回Object数据，一般都是将数据转化为了JSON对象后传递给浏览器页面的。而这个由Object转换为JSON，是由Jackson工具完成的。所以需要导入Jackson的相关Jar包。

<!--Jackson依赖-->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-core</artifactId>
  <version>2.9.0</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.0</version>
</dependency>

声明注解驱动

将Object数据转化为JSON数据，需要由消息转换器HttpMessageConverter完成。而转换器的开启，需要由<mvc:annotation-driven/>来完成。 SpringMVC使用消息转换器实现请求数据和对象，处理器方法返回对象和响应输出之间的自动转换当Spring容器进行初始化过程中，在<mvc:annotation-driven/>处创建注解驱动时，默认创建了七个HttpMessageConverter对象。也就是说，我们注册<mvc:annotation-driven/>，就是为了让容器为我们创建HttpMessageConverter对象。

<!--注解驱动-->
<mvc:annotation-driven />

HttpMessageConverter接口 : HttpMessageConverter是Spring3.0 新添加的一个接口，负责将请求信息转换为一个对象（类型为T），将对象（类型为T）输出为响应信息

HttpMessageConverter<T>接口定义的方法：  
    boolean canRead(Class<?> clazz,MediaType mediaType): 指定转换器可以读取的对象类型，即转换器是否可将请求信息转换为clazz 类型的对象，同时指定支持MIME 类型(text/html,applaiction/json等)  
    boolean canWrite(Class<?> clazz,MediaType mediaType):指定转换器是否可将clazz 类型的对象写到响应流中，响应流支持的媒体类型在MediaType 中定义。 
    LIst<MediaType> getSupportMediaTypes()：该转换器支持的媒体类 型。  
    T read(Class<? extends T> clazz,HttpInputMessage inputMessage)：将请求信息流转换为T 类型的对象。  
    void write(T t,MediaType contnetType,HttpOutputMessgae outputMessage):将T类型的对象写到响应流中，同时指定相应的媒体类型为contentType

HttpMessageConverter接口实现类	作用
ByteArrayHttpMessageConverter	负责读取二进制格式的数据和写出二进制格式的数据
StringHttpMessageConverter	负责读取字符串格式的数据和写出字符串格式的数据
ResourceHttpMessageConverter	负责读取资源文件和写出资源文件数据
SourceHttpMessageConverter	能够读/写来自HTTP的请求与响应的javax.xml.transform.Source ,支持DOMSource, SAXSource, 和 StreamSource 的XML格式
AllEncompassingFormHttpMessageConverter	负责处理表单(form)数据
Jaxb2RootElementHttpMessageConverter	使用 JAXB负责读取和写入xml 标签格式的数据
MappingJackson2HttpMessageConverter	负责读取和写入json格式的数据。利用Jackson的ObjectMapper读写json数据，操作Object类型数据，可读取application/json，响应媒体类型为application/json

2.3.4.2 返回自定义类型对象

返回自定义类型对象时，不能以对象的形式直接返回给客户端浏览器，而是将对象转换为JSON格式的数据发送给浏览器的。

由于转换器底层使用了Jackson转换方式将对象转换为JSON数据，所以需要导入Jackson的相关Jar包。

现在做ajax， 主要使用json的数据格式。 实现步骤：
 1.加入处理json的工具库的依赖， springmvc默认使用的jackson。
 2.在sprigmvc配置文件之间加入 <mvc:annotation-driven> 注解驱动。
   json  = om.writeValueAsString(student);
 3.在处理器方法的上面加入@ResponseBody注解
     response.setContentType("application/json;charset=utf-8");
     PrintWriter pw  = response.getWriter();
     pw.println(json);

/**
     * 处理器方法返回一个Student，通过框架转为json，响应ajax请求
     * @ResponseBody:
     *    作用：把处理器方法返回对象转为json后，通过HttpServletResponse输出给浏览器。
     *    位置：方法的定义上面。 和其它注解没有顺序的关系。
     * 返回对象框架的处理流程：
     *  1. 框架会把返回Student类型，调用框架的中ArrayList<HttpMessageConverter>中每个类的canWrite()方法
     *     检查那个HttpMessageConverter接口的实现类能处理Student类型的数据--MappingJackson2HttpMessageConverter
     *
     *  2.框架会调用实现类的write（）， MappingJackson2HttpMessageConverter的write()方法
     *    把李四同学的student对象转为json， 调用Jackson的ObjectMapper实现转为json
     *    contentType: application/json;charset=utf-8
     *
     *  3.框架会调用@ResponseBody把2的结果数据输出到浏览器， ajax请求处理完成
     */
    @RequestMapping(value = "/returnStudentJson.do")
    @ResponseBody
    public Student doStudentJsonObject(String name, Integer age) {
        //调用service，获取请求结果数据 ， Student对象表示结果数据
        Student student = new Student();
        student.setName("李四同学");
        student.setAge(20);
        return student; // 会被框架转为json

    }

2.3.4.3 返回List集合

/**
 *  处理器方法返回List<Student>
 * 返回对象框架的处理流程：
 *  1. 框架会把返回List<Student>类型，调用框架的中ArrayList<HttpMessageConverter>中每个类的canWrite()方法
 *     检查那个HttpMessageConverter接口的实现类能处理Student类型的数据--MappingJackson2HttpMessageConverter
 *
 *  2.框架会调用实现类的write（）， MappingJackson2HttpMessageConverter的write()方法
 *    把李四同学的student对象转为json， 调用Jackson的ObjectMapper实现转为json array
 *    contentType: application/json;charset=utf-8
 *
 *  3.框架会调用@ResponseBody把2的结果数据输出到浏览器， ajax请求处理完成
 */
@RequestMapping(value = "/returnStudentJsonArray.do")
@ResponseBody
public List<Student> doStudentJsonObjectArray(String name, Integer age) {

    List<Student> list = new ArrayList<>();
    //调用service，获取请求结果数据 ， Student对象表示结果数据
    Student student = new Student();
    student.setName("李四同学");
    student.setAge(20);
    list.add(student);

    student = new Student();
    student.setName("张三");
    student.setAge(28);
    list.add(student);


    return list;

}

2.3.4.4 返回字符串对象

若要返回非中文字符串，将前面返回数值型数据的返回值直接修改为字符串即可。但若返回的字符串中带有中文字符，则接收方页面将会出现乱码。此时需要使用@RequestMapping的produces属性指定字符集。 produces，产品，结果，即该属性用于设置输出结果类型。

/**
     * 处理器方法返回的是String ， String表示数据的，不是视图。
     * 区分返回值String是数据，还是视图，看有没有@ResponseBody注解
     * 如果有@ResponseBody注解，返回String就是数据，反之就是视图
     *
     * 默认使用“text/plain;charset=ISO-8859-1”作为contentType,导致中文有乱码，
     * 解决方案：给RequestMapping增加一个属性 produces, 使用这个属性指定新的contentType.
     * 返回对象框架的处理流程：
     *  1. 框架会把返回String类型，调用框架的中ArrayList<HttpMessageConverter>中每个类的canWrite()方法
     *     检查那个HttpMessageConverter接口的实现类能处理String类型的数据--StringHttpMessageConverter
     *
     *  2.框架会调用实现类的write（）， StringHttpMessageConverter的write()方法
     *    把字符按照指定的编码处理 text/plain;charset=ISO-8859-1
     *
     *  3.框架会调用@ResponseBody把2的结果数据输出到浏览器， ajax请求处理完成
     */
    @RequestMapping(value = "/returnStringData.do",produces = "text/plain;charset=utf-8")
    @ResponseBody
    public String doStringData(String name,Integer age){
        return "Hello SpringMVC 返回对象，表示数据";
    }

2.4 解读<url-pattern/>

2.4.1 配置详解

*.do

在没有特殊要求的情况下，SpringMVC的中央调度器DispatcherServlet的<url-pattern/>常使用后辍匹配方式，如写为*.do 或者 *.action, *.mvc等。

/

可以写为/，因为DispatcherServlet会将向静态资源的获取请求，例如.css、.js、.jpg、.png等资源的获取请求，当作是一个普通的Controller请求。中央调度器会调用处理器映射器为其查找相应的处理器。当然也是找不到的，所以在这种情况下，所有的静态资源获取请求也均会报404错误。

<servlet-mapping>
        <servlet-name>myweb</servlet-name>
        <!--
            使用框架的时候， url-pattern可以使用两种值
            2.使用斜杠 "/"
              当你的项目中使用了  / ，它会替代 tomcat中的default。(默认tomcat处理静态资源		defaultServlet)
              导致所有的静态资源都给DispatcherServlet处理， 默认情况下DispatcherServlet没有处理静态资源的能力。
              没有控制器对象能处理静态资源的访问。所以静态资源（html，js，图片，css）都是404.

              动态资源some.do是可以访问，的因为我们程序中有MyController控制器对象，能处理some.do请求。

        -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>

2.4.2 静态资源访问

<url-pattern/>的值并不是说写为/后，静态资源就无法访问了。经过一些配置后，该问题也是可以解决的。

使用<mvc:default-servlet-handler/>

声明了<mvc:default-servlet-handler />后，springmvc框架会在容器中创建DefaultServletHttpRequestHandler处理器对象。它会像一个检查员，对进入DispatcherServlet的URL进行筛查，如果发现是静态资源的请求，就将该请求转由Web应用服务器默认的Servlet处理。一般的服务器都有默认的Servlet。在Tomcat中，有一个专门用于处理静态资源访问的Servlet 名叫DefaultServlet。其<servlet-name/>为default。可以处理各种静态资源访问请求。该Servlet注册在Tomcat服务器的web.xml中。在Tomcat安装目录/conf/web.xml。

<servlet>
    <servlet-name>default</servlet-name>
    <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
    <init-param>
        <param-name>debug</param-name>
        <param-value>0</param-value>
    </init-param>
    <init-param>
        <param-name>listings</param-name>
        <param-value>false</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

<mvc:default-servlet-handler/>表示使用DefaultServletHttpRequestHandler处理器对象。而该处理器调用了Tomcat的DefaultServlet来处理静态资源的访问请求。

<!-- default-servlet-handler 和 @RequestMapping注解 有冲突， 需要加入annotation-driven 解决问题-->
<mvc:annotation-driven />
<!--第一种处理静态资源的方式：
    需要在springmvc配置文件加入 <mvc:default-servlet-handler>
    原理是： 加入这个标签后，框架会创健控制器对象DefaultServletHttpRequestHandler（类似我们自己创建的MyController）.
    DefaultServletHttpRequestHandler这个对象可以把接收的请求转发给 tomcat的default这个servlet。
-->
<mvc:default-servlet-handler />

使用<mvc:resources/>

在Spring3.0版本后，Spring定义了专门用于处理静态资源访问请求的处理器ResourceHttpRequestHandler。并且添加了<mvc:resources/>标签，专门用于解决静态资源无法访问问题。需要在springmvc配置文件中添加如下形式的配置：

<!--第二种处理静态资源的方式
    mvc:resources 加入后框架会创建 ResourceHttpRequestHandler这个处理器对象。
    让这个对象处理静态资源的访问，不依赖tomcat服务器。
    mapping:访问静态资源的uri地址， 使用通配符 **
    location：静态资源在你的项目中的目录位置。

    images/**:表示 images/p1.jpg  , images/user/logo.gif , images/order/history/list.png
-->
<mvc:resources mapping="/images/**" location="/images/" />
<mvc:resources mapping="/html/**" location="/html/" />
<mvc:resources mapping="/js/**" location="/js/" />

<!--mvc:resources和@RequestMapping有一定的冲突-->
<mvc:annotation-driven />

<!--使用一个配置语句，指定多种静态资源的访问-->
<!--<mvc:resources mapping="/static/**" location="/static/" />-->

3 SSM整合

3.1 主要文件

pom.xml

 <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- jsp依赖 -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2.1-b03</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
        <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>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.9</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.12</version>
        </dependency>
    </dependencies>

    <build>
        <!--目的是把src/main/java目录中的xml文件包含到输出结果中。输出到classes目录中-->
        <resources>
            <resource>
                <directory>src/main/java</directory><!--所在的目录-->
                <includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
        <plugins>
            <!-- 编码和编译和JDK版本 -->
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

spring.xml

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

    <!--读配置-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
    init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--sqlsessionFactory-->
    <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:mybatis.xml"/>
    </bean>

    <!--mybatis扫描器 创建dao对象-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sessionFactory"/>
        <property name="basePackage" value="com.example.dao"/>
    </bean>

    <!--service 注解驱动-->
    <context:component-scan base-package="com.example.service"/>
</beans>

springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--controller注解驱动-->
    <context:component-scan base-package="com.example.controller"/>

    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/view/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--注解驱动-->
    <mvc:annotation-driven/>
</beans>

mybatis.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--settings：控制mybatis全局行为-->
   <!-- <settings>
        &lt;!&ndash;设置mybatis输出日志&ndash;&gt;
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>-->

    <!--设置别名-->
    <typeAliases>
        <!--name:实体类所在的包名(不是实体类的包名也可以)-->
        <package name="com.example.dto"/>
    </typeAliases>


    <!-- sql mapper(sql映射文件)的位置-->
    <mappers>
        <!--
          name：是包名， 这个包中的所有mapper.xml一次都能加载
          使用package的要求：
           1. mapper文件名称和dao接口名必须完全一样，包括大小写
           2. mapper文件和dao接口必须在同一目录
        -->
        <package name="com.example.dao"/>
    </mappers>
</configuration>

controller

@Controller
@RequestMapping("/student")
public class StudentController {

    @Resource
    private StudentService service;

    //注册学生
    @RequestMapping("/addStudent.do")
    public ModelAndView addStudent(Student student){
        ModelAndView mv = new ModelAndView();
        String tips = "注册失败";
        //调用service处理student
        int nums = service.addStudent(student);
        if( nums > 0 ){
            //注册成功
            tips = "学生【" + student.getName() + "】注册成功";
        }
        //添加数据
        mv.addObject("tips",tips);
        //指定结果页面
        mv.setViewName("result");
        return mv;

    }

    //处理查询，响应ajax
    @RequestMapping("/queryStudent.do")
    @ResponseBody
    public List<Student> queryStudent(){
        //参数检查， 简单的数据处理
        List<Student> students = service.findStudents();
        return students;
    }
}

dao.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjpowernode.dao.StudentDao">
    <select id="selectStudents" resultType="Student">
        select id,name,age from student order by id desc
    </select>

    <insert id="insertStudent">
        insert into student(name,age) values(#{name},#{age})
    </insert>
</mapper>

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String basePath = request.getScheme() + "://" +
            request.getServerName() + ":" + request.getServerPort() +
            request.getContextPath() + "/";
%>
<html>
<head>
    <title>功能入口</title>
    <base href="<%=basePath%>" />
</head>
<body>
    <div align="center">
    <p>SSM整合的例子</p>
    <img src="images/ssm.jpg" />
    <table>
        <tr>
            <td><a href="addStudent.jsp"> 注册学生</a></td>
        </tr>
        <tr>
            <td><a href="listStudent.jsp">浏览学生</a></td>
        </tr>
    </table>
    </div>
    
</body>
</html>

addStudent.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String basePath = request.getScheme() + "://" +
            request.getServerName() + ":" + request.getServerPort() +
            request.getContextPath() + "/";
%>

<html>
<head>
    <title>注册学生</title>
    <base href="<%=basePath%>" />
</head>
<body>
    <div align="center">
        <form action="student/addStudent.do" method="post">
            <table>
                <tr>
                    <td>姓名：</td>
                    <td><input type="text" name="name"></td>
                </tr>
                <tr>
                    <td>年龄：</td>
                    <td><input type="text" name="age"></td>
                </tr>
                <tr>
                    <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</td>
                    <td><input type="submit" value="注册"></td>
                </tr>
            </table>
        </form>
    </div>
</body>
</html>

listStudent.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String basePath = request.getScheme() + "://" +
            request.getServerName() + ":" + request.getServerPort() +
            request.getContextPath() + "/";
%>
<html>
<head>
    <title>查询学生ajax</title>
    <base href="<%=basePath%>" />
    <script type="text/javascript" src="js/jquery-3.4.1.js"></script>
    <script type="text/javascript">
        $(function(){
            //在当前页面dom对象加载后，执行loadStudentData（）
            loadStudentData();

            $("#btnLoader").click(function(){
                //loadStudentData();
                alert($("#country > option:selected").val());

                alert($("#country > option:selected").text());
            })
        })

        function loadStudentData(){
            $.ajax({
                url:"student/queryStudent.do",
                type:"get",
                dataType:"json",
                success:function(data){
                    //清除旧的数据
                    $("#info").html("");
                    //增加新的数据
                    $.each(data,function(i,n){
                        $("#info").append("<tr>")
                            .append("<td>"+n.id+"</td>")
                            .append("<td>"+n.name+"</td>")
                            .append("<td>"+n.age+"</td>")
                            .append("</tr>")

                    })
                }
            })
        }
    </script>
</head>
<body>
    <div align="center">
        <table>
            <thead>
             <tr>
                 <td>学号</td>
                 <td>姓名</td>
                 <td>年龄</td>
             </tr>
            </thead>
            <tbody id="info">

            </tbody>
        </table>
        <input type="button" id="btnLoader" value="查询数据">
        <select id="country">
            <option value="1">中国</option>
            <option value="2">俄罗斯</option>
            <option value="3">西班牙</option>
        </select>
    </div>
</body>
</html>

3.2 相对路径

在页面中，有路径问题，访问路径有“/”开头的，还有没有“/”。

<a href="test/some.do">没有“/”开头</a>
<a href="/test/some.do">有“/”开头</a>
<a href="http://www.baidu.com">有协议开头的地址</a>

地址的区别：

有协议开头的例如http://www.baidu.com，称为绝对地址。地址是唯一的，能够直接访问。
没有协议开头的，例如test/some.do，/test/some.do称为相对地址。相对地址单独使用不能表示某个资源，不能访问。相对地址必须有参考地址在一起，才能表示一个资源的完整地址，才能访问。

参考地址：有“/”和没有“/”参考地址是不同的。

没有“/”开头的

当前访问地址：http://localhost:8080/path/index.jsp
资源名称：idnex.jsp
资源路径：http://localhost:8080/path

在index.jsp中访问 a href=“test/some.do”。

点击some.do后，地址变成http://localhost:8080/path/test/some.do。

此时：http://localhost:8080/path/test/some.do
资源名称：some.do
资源路径：http://localhost:8080/path/test/

再去点击some.do后，地址变成http://localhost:8080/path/test/test/some.do。

没有“/”开头的地址：参考地址+当前的相对地址，组合在一起是最后的访问地址。

解决方式：

1)使用${pageContext.request.contextPath}。表示访问项目路径(上下文context path)
<a href="${pageContext.request.contextPath}/text/some.do">发起请求test/some.do</a>
优点：好理解
缺点：每个链接地址，都需要加el表达式

2)固定当前页中的 没有“/”开头地址的参考地址，使用HTML中base标签
<%
    String basePath = request.getScheme() + "://" +
            request.getServerName() + ":" + request.getServerPort() +
            request.getContextPath() + "/";
%>
<head>
    <title>Title</title>
    <base href="<%=basePath%>" />
</head>

有“/”开头的地址

当前访问地址：http://localhost:8080/path/index.jsp
index.jsp中有 /test/some.do
点击/test/some.do,地址变成 http://localhost:8080/test/some.do

有“/”开头的地址，参考地址是服务器地址，也就是从协议开始到端口号的位置 http://localhost:8080

地址组成：http://localhost:8080/test/some.do
地址缺少访问路径：/path

解决方式：

在路径前面加入el表达式${pageContext.request.contextPath}
<a href="${pageContext.request.contextPath}/text/some.do">发起请求/test/some.do</a>

4 SpringMVC核心技术

4.1 请求重定向和转发

当处理器对请求处理完毕后，向其它资源进行跳转时，有两种跳转方式：请求转发与重定向。而根据所要跳转的资源类型，又可分为两类：跳转到页面与跳转到其它处理器。注意，对于请求转发的页面，可以是WEB-INF中页面；而重定向的页面，是不能为WEB-INF中页的。因为重定向相当于用户再次发出一次请求，而用户是不能直接访问WEB-INF中资源的。

SpringMVC框架把原来Servlet中的请求转发和重定向操作进行了封装。现在可以使用简单的方式实现转发和重定向。

forward:表示转发，实现request.getRequestDispatcher(“xx.jsp”).forward()

redirect:表示重定向，实现response.sendRedirect(“xxx.jsp”)

4.1.1 请求转发

处理器方法返回ModelAndView时，需在setViewName()指定的视图前添加forward:，且此时的视图不再与视图解析器一同工作，这样可以在配置了解析器时指定不同位置的视图。视图页面必须写出相对于项目根的路径。forward操作不需要视图解析器。处理器方法返回String,在视图路径前面加入forward: 视图完整路径。

/**
 * 处理器方法返回ModelAndView,实现转发forward
 * 语法： setViewName("forward:视图文件完整路径")
 * forward特点： 不和视图解析器一同使用，就当项目中没有视图解析器
 */
@RequestMapping(value = "/doForward.do")
public ModelAndView doSome(){
    //处理some.do请求了。 相当于service调用处理完成了。
    ModelAndView mv  = new ModelAndView();
    mv.addObject("msg","欢迎使用springmvc做web开发");
    mv.addObject("fun","执行的是doSome方法");
    //显示转发
    //mv.setViewName("forward:/WEB-INF/view/show.jsp");

    mv.setViewName("forward:/hello.jsp");
    return mv;
}

4.1.2 请求重定向

在处理器方法返回的视图字符串的前面添加redirect:，则可实现重定向跳转。

/**
 * 处理器方法返回ModelAndView,实现重定向redirect
 * 语法：setViewName("redirect:视图完整路径")
 * redirect特点： 不和视图解析器一同使用，就当项目中没有视图解析器
 *
 * 框架对重定向的操作：
 * 1.框架会把Model中的简单类型的数据，转为string使用，作为hello.jsp的get请求参数使用。
 *   目的是在 doRedirect.do 和 hello.jsp 两次请求之间传递数据
 *
 * 2.在目标hello.jsp页面可以使用参数集合对象 ${param}获取请求参数值
 *    ${param.myname}
 *
 * 3.重定向不能访问/WEB-INF资源
 */
@RequestMapping(value = "/doRedirect.do")
public ModelAndView doWithRedirect(String name,Integer age){
    //处理some.do请求了。 相当于service调用处理完成了。
    ModelAndView mv  = new ModelAndView();
    //数据放入到 request作用域
    mv.addObject("myname",name);
    mv.addObject("myage",age);
    //重定向
    //mv.setViewName("redirect:/hello.jsp");
    //http://localhost:8080/ch08_forard_redirect/hello.jsp?myname=lisi&myage=22

    //重定向不能访问/WEB-INF资源
    mv.setViewName("redirect:/WEB-INF/view/show.jsp");
    return mv;
}

4.2 异常处理

SpringMVC框架处理异常的常用方式：使用@ExceptionHandler注解处理异常。

使用注解@ExceptionHandler可以将一个方法指定为异常处理方法。该注解只有一个可选属性value，为一个Class<?>数组，用于指定该注解的方法所要处理的异常类，即所要匹配的异常。而被注解的方法，其返回值可以是ModelAndView、String，或void，方法名随意，方法参数可以是Exception及其子类对象、HttpServletRequest、HttpServletResponse等。系统会自动为这些方法参数赋值。对于异常处理注解的用法，也可以直接将异常处理方法注解于Controller之中。

@RequestMapping(value = "/some.do")
public ModelAndView doSome(String name,Integer age) throws MyUserException {
    //处理some.do请求了。 相当于service调用处理完成了。
    ModelAndView mv  = new ModelAndView();

    //try {
        //根据请求参数抛出异常
        if (!"zs".equals(name)) {
            throw new NameException("姓名不正确！！！");
        }

        if (age == null || age > 80) {
            throw new AgeException("年龄比较大！！！");
        }

    //}catch(Exception e){
    //   e.printStackTrace();
    //}

    mv.addObject("myname",name);
    mv.addObject("myage",age);
    mv.setViewName("show");
    return mv;
}

需要使用注解@ControllerAdvice，字面理解就是“控制器增强”，是给控制器对象增强功能的。使用@ControllerAdvice修饰的类中可以使用@ExceptionHandler。当使用@RequestMapping注解修饰的方法抛出异常时，会执行@ControllerAdvice修饰的类中的异常处理方法。 @ControllerAdvice是使用@Component注解修饰的，可以<context:component-scan>扫描到@ControllerAdvice所在的类路径(包名)，创建对象。

/**
 * @ControllerAdvice : 控制器增强（也就是说给控制器类增加功能--异常处理功能）
 *           位置：在类的上面。
 *  特点：必须让框架知道这个注解所在的包名，需要在springmvc配置文件声明组件扫描器。
 *  指定@ControllerAdvice所在的包名
 */
@ControllerAdvice
public class GlobalExceptionHandler {
    //定义方法，处理发生的异常
    /*
        处理异常的方法和控制器方法的定义一样， 可以有多个参数，可以有ModelAndView,
        String, void,对象类型的返回值

        形参：Exception，表示Controller中抛出的异常对象。
        通过形参可以获取发生的异常信息。

        @ExceptionHandler(异常的class)：表示异常的类型，当发生此类型异常时，
        由当前方法处理
     */

    @ExceptionHandler(value = NameException.class)
    public ModelAndView doNameException(Exception exception){
        //处理NameException的异常。
        /*
           异常发生处理逻辑：
           1.需要把异常记录下来， 记录到数据库，日志文件。
             记录日志发生的时间，哪个方法发生的，异常错误内容。
           2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员。
           3.给用户友好的提示。
         */
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","姓名必须是zs，其它用户不能访问");
        mv.addObject("ex",exception);
        mv.setViewName("nameError");
        return mv;
    }


    //处理AgeException
    @ExceptionHandler(value = AgeException.class)
    public ModelAndView doAgeException(Exception exception){
        //处理AgeException的异常。
        /*
           异常发生处理逻辑：
           1.需要把异常记录下来， 记录到数据库，日志文件。
             记录日志发生的时间，哪个方法发生的，异常错误内容。
           2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员。
           3.给用户友好的提示。
         */
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","你的年龄不能大于80");
        mv.addObject("ex",exception);
        mv.setViewName("ageError");
        return mv;
    }

    //处理其它异常， NameException, AgeException以外，不知类型的异常
    @ExceptionHandler
    public ModelAndView doOtherException(Exception exception){
        //处理其它异常
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","你的年龄不能大于80");
        mv.addObject("ex",exception);
        mv.setViewName("defaultError");
        return mv;
    }
}

springmvc.xml

<!--处理需要的两步-->
<context:component-scan base-package="com.bjpowernode.handler" />
<mvc:annotation-driven />

4.3 拦截器

SpringMVC中的Interceptor拦截器是非常重要和相当有用的，它的主要作用是拦截指定的用户请求，并进行相应的预处理与后处理。其拦截的时间点在“处理器映射器根据用户提交的请求映射出了所要执行的处理器类，并且也找到了要执行该处理器类的处理器适配器，在处理器适配器执行处理器之前”。当然，在处理器映射器映射出所要执行的处理器类时，已经将拦截器与处理器组合为了一个处理器执行链，并返回给了中央调度器。

4.3.1 一个拦截器的执行

自定义拦截器，需要实现HandlerInterceptor接口。而该接口中含有三个方法：

➢ preHandle(request,response, Object handler)：该方法在处理器方法执行之前执行。其返回值为boolean，若为true，则紧接着会执行处理器方法，且会将afterCompletion()方法放入到一个专门的方法栈中等待执行。

➢ postHandle(request,response, Object handler,modelAndView)：该方法在处理器方法执行之后执行。处理器方法若最终未被执行，则该方法不会执行。由于该方法是在处理器方法执行完后执行，且该方法参数中包含ModelAndView，所以该方法可以修改处理器方法的处理结果数据，且可以修改跳转方向。

➢ afterCompletion(request,response, Object handler, Exception ex)：当preHandle()方法返回true时，会将该方法放到专门的方法栈中，等到对请求进行响应的所有工作完成之后才执行该方法。即该方法是在中央调度器渲染（数据填充）了响应页面之后执行的，此时对ModelAndView再操作也对响应无济于事。

afterCompletion最后执行的方法，清除资源，例如在Controller方法中加入数据

//拦截器类：拦截用户的请求。
public class MyInterceptor implements HandlerInterceptor {

    private long btime = 0;
    /*
     * preHandle叫做预处理方法。
     *   重要：是整个项目的入口，门户。 当preHandle返回true 请求可以被处理。
     *        preHandle返回false，请求到此方法就截止。
     *
     * 参数：
     *  Object handler ： 被拦截的控制器对象
     * 返回值boolean
     *   true：请求是通过了拦截器的验证，可以执行处理器方法。
         *   拦截器的MyInterceptor的preHandle()
             =====执行MyController中的doSome方法=====
             拦截器的MyInterceptor的postHandle()
             拦截器的MyInterceptor的afterCompletion()
         *
     *   false：请求没有通过拦截器的验证，请求到达拦截器就截止了。 请求没有被处理
     *      拦截器的MyInterceptor的preHandle()
     *
     *
     *  特点：
     *   1.方法在控制器方法（MyController的doSome）之前先执行的。
     *     用户的请求首先到达此方法
     *
     *   2.在这个 方法中可以获取请求的信息， 验证请求是否符合要求。
     *     可以验证用户是否登录， 验证用户是否有权限访问某个连接地址（url）。
     *      如果验证失败，可以截断请求，请求不能被处理。
     *      如果验证成功，可以放行请求，此时控制器方法才能执行。
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        btime = System.currentTimeMillis();
        System.out.println("拦截器的MyInterceptor的preHandle()");
        //计算的业务逻辑，根据计算结果，返回true或者false
        //给浏览器一个返回结果
        //request.getRequestDispatcher("/tips.jsp").forward(request,response);
        return true;
    }

    /*
       postHandle:后处理方法。
       参数：
        Object handler：被拦截的处理器对象MyController
        ModelAndView mv:处理器方法的返回值

        特点：
         1.在处理器方法之后执行的（MyController.doSome()）
         2.能够获取到处理器方法的返回值ModelAndView,可以修改ModelAndView中的
         数据和视图，可以影响到最后的执行结果。
         3.主要是对原来的执行结果做二次修正，

         ModelAndView mv = MyController.doSome();
         postHandle(request,response,handler,mv);
     */
    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response,
                           Object handler, ModelAndView mv) throws Exception {
        System.out.println("拦截器的MyInterceptor的postHandle()");
        //对原来的doSome执行结果，需要调整。
        if( mv != null){
            //修改数据
            mv.addObject("mydate",new Date());
            //修改视图
            mv.setViewName("other");
        }
    }

    /*
      afterCompletion:最后执行的方法
      参数
        Object handler:被拦截器的处理器对象
        Exception ex：程序中发生的异常
      特点:
       1.在请求处理完成后执行的。框架中规定是当你的视图处理完成后，对视图执行了forward。就认为请求处理完成。
       2.一般做资源回收工作的， 程序请求过程中创建了一些对象，在这里可以删除，把占用的内存回收。
     */
    @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("计算从preHandle到请求处理完成的时间："+(etime - btime ));
    }
}

springmvc.xml

<!--声明拦截器： 拦截器可以有0或多个-->
<mvc:interceptors>
    <!--声明第一个拦截器-->
    <mvc:interceptor>
        <!--指定拦截的请求uri地址
            path：就是uri地址，可以使用通配符 **
                  ** ： 表示任意的字符，文件或者多级目录和目录中的文件
            http://localhost:8080/myweb/user/listUser.do
            http://localhost:8080/myweb/student/addStudent.do
        -->
        <mvc:mapping path="/**"/>
        <!--声明拦截器对象-->
        <bean class="com.bjpowernode.handler.MyInterceptor" />
    </mvc:interceptor>
</mvc:interceptors>

在这里插入图片描述

4.3.2 多个拦截器的执行

<!--声明拦截器： 拦截器可以有0或多个
    在框架中保存多个拦截器是ArrayList，
    按照声明的先后顺序放入到ArrayList
-->
<mvc:interceptors>
    <!--声明第一个拦截器-->
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <!--声明拦截器对象-->
        <bean class="com.bjpowernode.handler.MyInterceptor" />
    </mvc:interceptor>
    <!--声明第二个拦截器-->
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean class="com.bjpowernode.handler.MyInterceptor2" />
    </mvc:interceptor>
</mvc:interceptors>

两个拦截器，第一个preHandle=true,第二个拦截器preHandle=true

111111-拦截器的MyInterceptor的preHandle()
22222-拦截器的MyInterceptor的preHandle()
=====执行MyController中的doSome方法=====
22222-拦截器的MyInterceptor的postHandle()
111111-拦截器的MyInterceptor的postHandle()
22222-拦截器的MyInterceptor的afterCompletion()
111111-拦截器的MyInterceptor的afterCompletion()

两个拦截器，第一个preHandle=true,第二个拦截器preHandle=false

111111-拦截器的MyInterceptor的preHandle()
22222-拦截器的MyInterceptor的preHandle()
111111-拦截器的MyInterceptor的afterCompletion()

两个拦截器，第一个preHandle=false,第二个拦截器preHandle=true|false

111111-拦截器的MyInterceptor的preHandle()

当有多个拦截器时，形成拦截器链。拦截器链的执行顺序，与其注册顺序一致。需要再次强调一点的是，当某一个拦截器的preHandle()方法返回true并被执行到时，会向一个专门的方法栈中放入该拦截器的afterCompletion()方法。

多个拦截器中方法与处理器方法的执行顺序如下图：

在这里插入图片描述

从图中可以看出，只要有一个preHandle()方法返回false，则上部的执行链将被断开，其后续的处理器方法与postHandle()方法将无法执行。但，无论执行链执行情况怎样，只要方法栈中有方法，即执行链中只要有preHandle()方法返回true，就会执行方法栈中的afterCompletion()方法。最终都会给出响应。

为什么使用对个拦截器？

把验证功能分散到独立的拦截器。每个拦截器做单一的验证处理。
组合多个拦截器。

总结：

多个拦截器，串在一个链条上的。多个拦截器和一个控制器对象在一个链条上，框架中使用HandlerExecutionChain(处理器执行链)，表示这个执行链条。

public class HandlerExecutionChain {

	private static final Log logger = LogFactory.getLog(HandlerExecutionChain.class);

	private final Object handler; //存放控制器对象，MyController

	@Nullable
	private HandlerInterceptor[] interceptors;//存放多个拦截器对象。MyInterceptor1,2

	@Nullable
	private List<HandlerInterceptor> interceptorList;
}

4.3.3 拦截器和过滤器对比

拦截器是springMVC框架中的对象。过滤器是servlet中的对象。
拦截器的对象是框架容器创建的，过滤器对象是tomcat创建的。
拦截器是侧重对于请求做判断的，处理的，可以截断请求。过滤器是侧重于对request，response对象的属性，参数设置值的。例如request.setCharacterEncoding(“utf-8”)。
拦截器的执行时间有3个，拦截器方法之前，之后，请求完成后。过滤器是在请求之前。
拦截器是拦截对controller，动态资源请求的。过滤器可以过滤所有请求动态和静态的。
拦截器和过滤器一起执行，先执行过滤器，后面是中央调度器，再后面才是拦截器，再后面是控制器方法。

的卢小码

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC

SpringMVC1 SpringMVC概述1.1 SpringMVC简介 SpringMVC也叫Spring web mvc。是Spring框架的一部分，是在Spring3.0后发布的。1.2 SpringMVC 优点1.基于MVC架构基于MVC架构，功能分工明确。解耦合。2.容易理解，上手快；使用简单。就可以开发一个注解的SpringMVC项目，SpringMVC也是轻量级的，jar很小。不依赖的特定的接口和类。3.作为Spring框架一部分，能够使用Spring的Io
复制链接

扫一扫