SpringMVC

概述

SpringMVC————界面层，接受用户请求，显示处理结果
Spring——————业务层，处理业务逻辑，Spring创建Service，Dao，工具类对象
MyBatis——————持久层，访问数据库。

是基于Spring的一个模块，专门做web开发。可以理解为Servlet的升级，web开发底层都是Servlet。
SpringMVC能够创建对象，放入容器中（SpringMVC容器），SpringMVC容器中放的是控制器对象。
我们需要做的是 使用@Controller创建控制器对象，把对象放入到SpringMVC容器中，把创建的对象作为控制器使用。
这个控制器对象能够接受用户请求，显示处理结果，当作是一个Servlet使用。
使用@Controller注解创建的是一个普通的类对象，不是Servlet，但是SpringNVC赋予了控制器对象一些额外的功能。

web开发底层是Servlet，SpringMVC中有一个对象是Servlet：DispatcherServlet（中央调度器）
DispatcherServlet：负责去接受用户的所有请求，用户把请求给了DispatherServlet，之后DispatherServlet把请求转发给我们的Controller对象，最后Controller对象处理请求。

index.jsp-------DispatcherServlet（Servlet）转发，分派 -------Controller对象(可以多个)（@Controller注解创建的对象）

第一个程序

第一个SpringMVC项目：
需求：用户在页面发起请求，请求交给SpringMVC的控制器
并显示请求处理结果（在页面显示欢迎语句）
实现步骤：
1、web maven工程
2、加入依赖:spring-mvc（会把Spring依赖加入到项目）、jsp、servlet
3、在web.xml文件中注册SpringMVC框架的核心对象DispatcherServlet
1）DispatcherServlet是中央调度器，是一个servlet，它的父类是HttpServlet
2）DispatcherServlet也叫前端控制器（front controller）
3）DispatcherServlet负责接受前端用户提交的请求，调用其他控制器对象，并发请求的处理结果显示给用户
4、创建发起请求的页面index.jsp
5、创建控制器类
1）在类的上面加入@Controller注解，创建对象，并放入SpringMVC容器中
2）在类的方法上加入@RequestMapping注解
6、创建结果jsp
7、创建SpringMVC的配置文件（resources目录下）
1）声明组件扫描器，指定@Controller注解所在的包名
2）声明视图解析器。帮助处理视图

运行流程

1、发起请求some.do
2、tomcat(通过web.xml–url-pattern知道*.do的请求给DispatcherServlet)
3、DidspatcherServlet(根据springmvc.xml配置知道some.do----doSome())
4、DispatcherServlet把some.do转发给MyController.doSome()方法
5、框架执行doSome()把得到的ModelAndView进行处理，转发到show.jsp

上述过程简化：
some.do----DidspatcherServlet----MyController

代码

依赖

    <!--SpringMVC依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!--Servlet依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
    </dependency>
  </dependencies>

中央调度器的配置
ch01-helloMVC\src\main\webapp\WEB-INF\web.xml

<?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在他的创建过程中，会同时创建SpringMVC容器对象
        会读取SpringMVC的配置文件，把这个配置文件的对象都创建好，当用户发起请求时
        就可以直接使用对象了

        SpringMVC创建容器对象时，读取的配置文件默认时/WEB-info/<servlet-name>-servlet.xml
        (例如/WEB-info/springmvc1-servlet.xml)

    -->
    <servlet>
        <servlet-name>springmvc1</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启动后创建对象的顺序。它的值是整数，数值越小创建越早

        -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>springmvc1</servlet-name>
        <!--使用框架的时候，url-pattern可以使用两种值
            1、使用扩展名，语法：*.xxx，xxx时自定义的扩展名。常用的方法*.do,*.action
                表示以.do 结尾的请求都交给这个中央调度器来处理
                http:localhost:8080/springmvc/some.do
                http:localhost:8080/springmvc/other.do
            2、使用“/”
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

SpringMVC配置文件

<?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.daihan.controller"/>
</beans>

Controller类

package com.daihan.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

/**
 * @Controller 创建处理器（控制器对象）对象放在SpringMVC容器中
 * 位置：在类上面
 *
 * 类比 Spring中讲解的@Service，@Component
 *
 * 能处理请求的都是控制器，MyController能处理请求，叫做后端控制器
 */
@Controller
public class MyController {
    /*
        处理用户请求的请求，SpringMVC中是使用方法来处理的
        方法是自定义的，可以有多种返回值，多种参数
     */

    /**
     * 准备使用doSome方法处理some.do请求
     * @RequestMapping 请求映射，作用是把一个请求和一个方法绑定
     *                  一个请求指定一个方法处理
     *      属性：1、value 是一个String，表示请求的URL地址的。value值唯一，使用时推荐“/”开头
     *      使用位置：方法上面 or 类上卖弄
     *
     * 说明：使用@RequestMapping修饰的方法叫做处理器方法或者控制器方法。
     *      使用@RequestMapping修饰的方法是可以处理请求的，类似Servlet中的doGet
     *
     * 返回值：ModelAndView，表示本次处理的结果
     *      Model:数据，请求处理完成后，要显示给用户的数据
     *      View：视图，比如JSP等
     */
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(){
        //处理some.do请求，初步先相当于service调用完成
        ModelAndView mv =new ModelAndView();

        //添加数据，框架在请求的最后把数据放入到request作用域
        //request.setAttribute("msg","欢迎使用SpringMVC");
        mv.addObject("msg","欢迎使用SpringMVC");
        mv.addObject("fun","执行的doSome方法");

        //指定视图，指定视图的完整路径
        //框架对试图执行的forward操作，request.getRequestDispatcher("/show.jsp").forward(..);
        mv.setViewName("/show.jsp");

        return mv;
    }
}

页面1 index

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<p>first SpringMVC  Project</p>
<p><a href="some.do">send request</a> send request2</p>
</body>
</html>

页面2

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>show.jsp</h3><br/>
    <h3>msg:${msg}</h3><br/>
    <h3>fun:${fun}</h3><br/>
</body>
</html>

配置视图解析器

注：在WEB-INF下的JSP用户是不能直接访问的。由此可以避免用户直接访问到页面。
springmvc配置文件

<?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.daihan.controller"/>

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

控制器类：

package com.daihan.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
/
@Controller
public class MyController {
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(){
        //处理some.do请求，初步先相当于service调用完成
        ModelAndView mv =new ModelAndView();

        //添加数据，框架在请求的最后把数据放入到request作用域
        //request.setAttribute("msg","欢迎使用SpringMVC");
        mv.addObject("msg","欢迎使用SpringMVC");
        mv.addObject("fun","执行的doSome方法");

        //指定视图，指定视图的完整路径
        //框架对试图执行的forward操作，request.getRequestDispatcher("/show.jsp").forward(..);
        //文件在webapp目录下时
        //mv.setViewName("show.jsp");
        //文件放入/WEB-INF/view后：
        //mv.setViewName("/WEB-INF/view/show.jsp");
        //加入视图解析器后，框架会使用视图解析器的前缀和后缀
        mv.setViewName("show");
        
        return mv;
    }
}

注解开发@RequestMapping

Controller类 改：

package com.daihan.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * @RequestMapping :
 *      value:表示所有请求地址公共的部分
 *      位置：放在类上
 */
@Controller
@RequestMapping(value = "/test")
public class MyController {
    /**
     * RequestMapping：请求映射
     *      属性 method：表示请求的方式，它的值是RequestMethod类枚举值
     *              表示get方式，RequestMethod.GET
     *              表示post方式，RequestMethod.POST
     *
     */

    //@RequestMapping(value = {"/test/some.do","/first.do"})
    //指定/some.do使用get请求方式
    @RequestMapping(value = "/some.do",method = RequestMethod.GET)
    public ModelAndView doSome(){
        //处理some.do请求，初步先相当于service调用完成
        ModelAndView mv =new ModelAndView();

        mv.addObject("msg","欢迎使用SpringMVC");
        mv.addObject("fun","执行的doSome方法");

        mv.setViewName("show");

        return mv;
    }

    //@RequestMapping(value = {"/test/other.do","/second.do"})
    @RequestMapping(value = "/other.do",method = RequestMethod.POST)
    public ModelAndView doOther(){
        //处理some.do请求，初步先相当于service调用完成
        ModelAndView mv =new ModelAndView();

        mv.addObject("msg","欢迎使用SpringMVC");
        mv.addObject("fun","执行的doOther方法");

        mv.setViewName("show");

        return mv;
    }

    //不指定请求方式，没有限制
    //使用参数
    @RequestMapping(value = "/second.do")
    public ModelAndView doFirst(HttpServletRequest request, HttpServletResponse  response,
                                HttpSession session){
        //处理some.do请求，初步先相当于service调用完成
        ModelAndView mv =new ModelAndView();

        mv.addObject("msg","欢迎使用SpringMVC"+request.getParameter("name"));
        mv.addObject("fun","执行的doOther方法");

        mv.setViewName("show");

        return mv;
    }
}

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<p>first SpringMVC  Project</p>
<p><a href="test/some.do">发起some.do请求</a> </p>
<br/>
<form action="test/other.do" method="post">
    <input type="submit" value="post请求">
</form>
</body>
</html>

show.jsp同上

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"
       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.daihan.controller"/>

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

接受参数

掌握如何传参，如何返回结果，url-pattern，配置静态资源

逐个接受参数

index.jsp传到服务器的参数名，和Controller中方法的形参名一致
index

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<p>提交参数给Controller</p>
<br/>
<form action="receiveproperty.do" method="post">
    name:<input type="text" name="name"/><br/>
    age:<input type="text" name="age"/><br/>
    <input type="submit" value="post请求">
</form>
</body>
</html>

Controller类

package com.daihan.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class MyController {

    /**
     * 逐个接受请求的参数：
     * 要求：处理器方法的形参名和请求中的参数名一致。（同名赋值，和参数顺序无关）
     *
     * post方式有乱码问题，过滤器中设置编码方式
     */
    @RequestMapping(value = "/receiveproperty.do",method = RequestMethod.POST)
    public ModelAndView doSome(String name,int age){
        //处理some.do请求，初步先相当于service调用完成
        ModelAndView mv =new ModelAndView();

        mv.addObject("name",name);
        mv.addObject("age",age);

        mv.setViewName("show");

        return mv;
    }
}

解决post请求方式中文乱码

在web.xml文件中加入

    <!--注册声明过滤器，解决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>

@RequestParam注解

当前端传入的参数名和处理器中的形参名不同时，处理器接受不到参数。
@RequestParam注解：用于解决这个问题
属性：
1、value：请求中的参数名。位置：处理器形参定义前
2、required：boolean类型，默认时true，true表示请求中必须包含此参数。false表示可以不要此参数

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<p>提交参数给Controller</p>
<br/>
<form action="receiveproperty.do" method="post">
    name:<input type="text" name="rname"/><br/>
    age:<input type="text" name="rage"/><br/>
    <input type="submit" value="post请求">
</form>
</body>
</html>

Controller类

@Controller
public class MyController {
	
    @RequestMapping(value = "/receiveproperty.do",method = RequestMethod.POST)
    public ModelAndView doSome(@RequestParam(value="rname",required=true) String name,
                               @RequestParam("rage",required=true) int age){
        //处理some.do请求，初步先相当于service调用完成
        ModelAndView mv =new ModelAndView();

        mv.addObject("name",name);
        mv.addObject("age",age);

        mv.setViewName("show");

        return mv;
    }
}

对象接受参数

适合接受多个参数。将处理器方法的参数定义为一个对象，只要保证请求参数名于这个对象的属性同名即可。
处理器方法形参是Java对象，框架会创建形参的Java对象，给属性赋值。请求中的参数是name，框架会调用setName()

处理器方法返回值

ModelAndView

若处理器方法处理完成之后，需要跳转到其他资源，且有要在跳转资源间传递数据，此时处理器返回ModelAndView比较好。
若处理器方法处理完成之后，只需进行跳转或传递数据中的一种，则ModelAndView就会有多余。

String（视图）

处理器方法返回的字符串可以指定逻辑视图名，通过视图解析器可以将其转换为物理视图地址。
相当于ModelAndView的View部分，做一个视图的跳转。
String可以是逻辑名称，也可以完成视图路径

Controller类

@Controller
public class MyController {

    /**
     * 处理器方法返回String，表示逻辑视图名称，需要配置视图解析器InternalResourceViewResolver
     *
     */
    @RequestMapping(value = "/returnString.do",method = RequestMethod.POST)
    public String doReturnView(HttpServletRequest request,String name, int age){
        //需要手动添加数据到request作用域
        request.setAttribute("name",name);
        request.setAttribute("age",age);

        //show是逻辑视图名称，项目中配置了视图解析器
        //框架对视图执行forward转发操作
        return "show";
    }
}

SpringMVC配置文件必须配置视图解析器

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

注：当String返回完整视图路径的时候，不能配置视图路径解析器！

void（了解一二）

处理AJAX异步响应。
pom.xml再加入依赖

    <!--jackson依赖，处理JSON-->
    <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>
  </dependencies>

index,jsp

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

Controller类方法

    //处理器方法返回void，响应ajax请求
    @RequestMapping(value = "/returnVoid-ajax.do",method = RequestMethod.POST)
    public void doReturnVoidAjax(HttpServletResponse response,String name, int age) throws IOException {
        //处理ajax，使用json数据格式
        //假设service调用完成，
        Student student=new Student();
        student.setName(name);
        student.setAge(age);

        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();
    }

问题：手工实现ajax，无论什么类型，都会使用Java对象转json，通过HttpServletResponse输出输出数据这两步，代码重复。

Object

处理方法可以返回Object对象，但这个对象不是作为逻辑视图出现的，而是直接在页面显示的数据出现的。返回对象需要使用@ResponseBody注解，将转换后的JSON数据放入响应体中。

现在做AJAX，主要使用的JSON数据格式。
实现步骤：
1、添加依赖：jackson
2、java对象转json，SpringMVC配置文件加<mvc:annotation-driven/>注解驱动
3、在处理器方法上加@ResponseBody

原理：
springMVC处理方法返回Object，可以转为JSON输出到浏览器，响应AJAX内部原理：
1、<mvc:annotation-driven/>注解驱动
注解驱动实现java对象到json，xml，text，二进制文件等的格式转换
2、在处理器方法上加@ResponseBody
实现通过HttpServletResponse输出输出数据，响应AJAX请求。

返回对象 框架的处理流程
1、框架会把返回值Student这个类型，调用框架中的ArrayList<HttpMessageConverter>中的每个类的canWriter()方法，检查哪个HttpMessageConverter接口实现类能处理Student类型的数据
2、框架调用此实现类的write()方法，把student对象转换为JSON
3、框架调用 @ResponseBody把结果输出到浏览器，ajax请求处理完成。

pom.xml再加入依赖

    <!--jackson依赖，处理JSON-->
    <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>
  </dependencies>

index.jsp

<%--
  Created by IntelliJ IDEA.
  User: 代涵
  Date: 2021/5/23
  Time: 10:25
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script type="text/javascript" src="js/jquery-3.6.0.js"></script>
    <script type="text/javascript">
        $(function (){
            $("button").click(function (){
                //alert("button");
                $.ajax({
                    //url:"returnVoid-ajax.do",
                    url:"returnStudent.do",
                    data:{
                        name:"zhangsan",
                        age:20
                    },
                    type:"post",
                    dataType:"json",
                    success:function (resp){
                        //resp从服务器端返回json格式的字符串
                        //jQuery会把字符串转为json对象，赋值给resp形参
                        alert(resp.name+":"+resp.age);
                    }
                })
            })
        })
    </script>
</head>
<body>
    <br/>
    <br/>
    <button id="btn">发起ajax请求</button>
</body>
</html>

Controller类方法

    /**
     * 处理器方法返回Student，通过框架转为JSON响应AJAX请求
     */
    //加@ResponseBody，实现通过HttpServletResponse输出输出数据，响应AJAX请求。
    @ResponseBody
    @RequestMapping(value = "/returnStudent.do",method = RequestMethod.POST)
    public Student doReturnSTudentAjax(String name, int age) {
        //调用service，获取结果数据，Student对象就表示结果数据
        Student student = new Student();
        student.setName("lisi");
        student.setAge(20);
        return student;//会被框架转为JSON

    }

返回值List是JSONArray

当返回值需要返回多个对象的时候，使用集合。处理方式和返回值是Object是一致的。
index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script type="text/javascript" src="js/jquery-3.6.0.js"></script>
    <script type="text/javascript">
        $(function (){
            $("button").click(function (){
                //alert("button");
                $.ajax({
                    url:"returnStudentArray.do",
                    data:{
                        name:"zhangsan",
                        age:20
                    },
                    type:"post",
                    dataType:"json",
                    success:function (resp){
                        //resp代表JSON数组
                        $.each(resp,function(i,n){
                            alert(n.name+":"+n.age);
                        })
                    }
                })
            })
        })
    </script>
</head>
<body>
    <br/>
    <br/>
    <button id="btn">发起ajax请求</button>
</body>
</html>

Controller类方法

    /**
     * 处理器方法返回List<Student>
     */
    @ResponseBody
    @RequestMapping(value = "/returnStudentArray.do",method = RequestMethod.POST)
    public List<Student> doReturnSTudentAjaxArray(String name, int age) {
        List<Student> students=new ArrayList<>();
        //调用service，获取结果数据，Student对象就表示结果数据
        Student student = new Student();
        student.setName("lisi");
        student.setAge(20);
        students.add(student);

        Student student2 = new Student();
        student2.setName("zhangsan");
        student2.setAge(22);
        students.add(student2);

        return students;//会被框架转为JSON
    }

String（字符串对象，代表数据）

Controller类方法

    /**
     * 处理器方法返回String，String表示数据
     * 有@ResponseBody就表示String代表的是数据
     * 默认使用"text/plain;charset=ISO-8859-1"作为contentType，导致中文有乱码
     * 解决方案，给RequestMapping增加属性produces，使用这个属性指定contentType
     */
    @ResponseBody
    @RequestMapping(value = "/returnStringData.do",produces="text/plain;charset=utf-8")
    public String doStringData(String name,Integer age){
        return "hello SpringMVC 返回对象表示数据";
    }

index.jsp
需改：dataType:“text”,

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script type="text/javascript" src="js/jquery-3.6.0.js"></script>
    <script type="text/javascript">
        $(function (){
            $("button").click(function (){
                //alert("button");
                $.ajax({
                    //url:"returnStudentArray.do",
                    url:"returnStringData.do",
                    data:{
                        name:"zhangsan",
                        age:20
                    },
                    type:"post",
                    //dataType:"json",
                    dataType:"text",
                    success:function (resp){
                        alert("文本数据"+resp);
                    }
                })
            })
        })
    </script>
</head>
<body>
    <br/>
    <br/>
    <button id="btn">发起ajax请求</button>
</body>
</html>

访问静态资源的问题

访问http://localhost:8080/ch05_url_pattern/index.jsp，是由Tomcat处理的，jsp会转为servlet
http://localhost:8080/ch05_url_pattern/js/jquery-3.6.0.js，是由
以.do结尾的是由DispatcherServlet处理的（SpringMVC框架处理）

Tomcat本身能处理静态资源的访问，例如 html，jsp，图片等。
Tomcat的web.xml文件有一个Servler，名称使default，在服务器启动时创建。
作用是：处理静态资源，处理未映射到其他Servlet的请求。
default这个Servlet的servlet-mapping的url-pattern是“/”，表示静态资源和未映射的请求都给这个servlet处理

当自己的项目url-pattern中使用“/”的时候，他会替代tomcat的default，对于不同类型资源有不同影响：
静态资源：导致所有静态资源都给中央调度器处理，默认情况下DispatcherServlet没有处理静态资源的能力
没有控制器对象能处理静态资源的访问，静态资源（html，js，css，图片）都是404
动态资源：例如some.do这种就可以访问的，因为程序中有Controller控制器对象，能处理some.do请求

项目url-pattern中使用“/”的时候，some.do可以写成some了

web.xml

<?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">
    <servlet>
        <servlet-name>springmvc1</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>springmvc1</servlet-name>
       	 	<!--使用框架的时候，url-pattern可以使用两种值
		         1、使用扩展名，语法：*.xxx，xxx时自定义的扩展名。常用的方法*.do,*.action
		             表示以.do 结尾的请求都交给这个中央调度器来处理
		             http:localhost:8080/springmvc/some.do
		             http:localhost:8080/springmvc/other.do
		         2、使用“/”，当自己的项目中使用“/”的时候，他会替代tomcat的default
	      	-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>


    <!--注册声明过滤器，解决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>
</web-app>

SpringMVC配置文件

<?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">

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

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

    <!--注解驱动
        mvc:default-servlet-handler和@RequestMapping注解有冲突，
        需要mvc:annotation-driven来解决
    -->
    <mvc:annotation-driven/>

    <!--
    在SpringMVC的配置文件中加入<mvc:default-servlet-handler>
    原理：加入这个标签之后，框架会创建控制器对象DefaultServletHttpRequestHandler（类似我i们自己创建的MyController类）
    DefaultServletHttpRequestHandler这个类的对象可以把接受的请求转发给tomcat的default这个servlet
    -->
    <mvc:default-servlet-handler/>
</beans>

第一种处理静态资源的方式

在SpringMVC的配置文件中加入<mvc:default-servlet-handler>
原理：加入这个标签之后，框架会创建控制器对象DefaultServletHttpRequestHandler（类似我i们自己创建的MyController类）
DefaultServletHttpRequestHandler这个类的对象可以把接受的请求转发给tomcat的default这个servlet
SpringMVC配置文件中：
需要注解驱动
mvc:default-servlet-handler和@RequestMapping注解有冲突，
需要mvc:annotation-driven来解决
SpringMVC配置文件，增加

    <!--注解驱动
        mvc:default-servlet-handler和@RequestMapping注解有冲突，
        需要mvc:annotation-driven来解决
    -->
    <mvc:annotation-driven/>

    <!--
    在SpringMVC的配置文件中加入<mvc:default-servlet-handler>
    原理：加入这个标签之后，框架会创建控制器对象DefaultServletHttpRequestHandler（类似我i们自己创建的MyController类）
    DefaultServletHttpRequestHandler这个类的对象可以把接受的请求转发给tomcat的default这个servlet
    -->
    <mvc:default-servlet-handler/>

第二种处理静态资源的方式（主要|掌握）

Spring定义了专门用来处理镜台资源文件的处理器ResourceHttpRequestHandler。并且添加了<mvc:resources/>标签，用于解决静态资源无法访问的问题。需要在SpringMVC配置文件中添加如下形式

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

location表示静态资源所在目录（在webapp目录下）。目录不要使用/WEB-INF/及其子目录
mapping表示对该资源的请求（以/images/开始的请求，如images/beauty.jpg等），也就是url，使用通配符**

mvc:resources 和@RequestMapping注解有冲突，
需要mvc:annotation-driven来解决

一条配置处理所有静态资源

在webapp目录下，新建目录static，将静态资源都放进去。就可以只用一个语句指定静态资源。

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

注

绝对路径和相对路径

jsp页面中的路径问题，是否使用“/”
在jsp，html中使用的地址，都是在前端页面中的地址，都是相对地址。

绝对地址：带有协议名称的地址，
相对地址：没有协议开头的地址，例如test/some.do,/test/some.do 不能独立使用，必须有一个参考地址，两者结合才能指定资源。

参考地址：
1、当地址没有“/”开头时，例如text/some.do，当点击这个链接时，访问的是当前页面的地址+链接地址。
例如：
访问：http://localhost:8080/ch06_path_war_exploded/index.jsp
路径：http://localhost:8080/ch06_path_war_exploded/
资源：index.jsp
点击到 test/some.do 时，就是 路径+text/some.do ，即http://localhost:8080/ch06_path_war_exploded/test/some.do。但此时路径就变为了http://localhost:8080/ch06_path_war_exploded/text/，此时如果再发起请求，就是加在新路径之后了，例如再次访问text/some.do，就会出问题。（http://localhost:8080/ch06_path_war_exploded/test/test/some.do）
解决方法：
1）使用${pageContext.request.contextPath}，每个都要加，比较繁琐
2）加入base标签，是html语言中的标签。表示当前页面访问地址的基地址。页面中所有没有“/”开头的地址，都是以base标签中的地址为参考地址。使用base中的地址+test/some.do

动态获取路径

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

指定base标签

<head>
	<base href="<%=basePath%>"
	<title>title</title>
</head>

2、当地址有“/”开头时
访问：http://localhost:8080/ch06_path_war_exploded/index.jsp
路径：http://localhost:8080/ch06_path_war_exploded/
资源：index.jsp
点击到 /text/some.do 时，地址就是 http://localhost:8080/text/some.do（服务器ip地址+端口号），无法访问，缺项目地址
解决方法一，在地址前加上项目地址，但不够灵活。
解决方法二，使用${pageContext.request.contextPath}，
访问的时候写<a href="${pageContext.request.contextPath}/user/some.do"> 发起请求