SpringMVC详细学习

SpringMVC概念

SpringMVC说明

Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的Spring MVC框架或集成其他MVC开发框架

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。

SpringMVC执行流程

准备条件

1）下载maven对象，解压到任意盘

2）电脑配置mvc（同java）
1、顶部的用户：
path：%MAVEN_HOME%\bin

2、系统变量：
增加变量名：MAVEN_HOME
增加变量值：D:\maven_\apache-maven-3.6.3（解压位置）
path：%MAVEN_HOME%\bin

3、修改D:\maven_\apache-maven-3.6.3\conf配置文件settings
第159行增加：

//目的是下载的快
	<mirror>
		<id>nexus-aliyun</id>
		<mirrorOf>*</mirrorOf>
		<name>Nexus aliyun</name>
		<url>http://maven.aliyun.com/nexus/content/groups/public</url>
	</mirror>

4、在settings文件中修改仓库地址（49行）：

<localRepository>D:/maven_/repo</localRepository>

5、创建maven对象，配置tomcat

6、创建两个包名分别为java和resources，右键分别修改为Source Root
和Resources Root

7、pom.xml引入依赖

 <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>


    <!--SpringMVC依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.6.RELEASE</version>
    </dependency>
    <!--servlet依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
    </plugin>
    </plugins>
  </build>

请求接收流程

1）在index.jsp增加some.do的超链接请求

    <h3>第一个MVC的数据</h3>

    <a href="some.do">发起some.do的请求</a>

2）配置web.xml文件

 <!--声明注册springmvc的核心对象DispatcherServlet
    需要在tomcat服务器启动后，创建DispatchServlet对象的实例。
    创建过程中会同时创建SpringMVC容器对象，读取springmvc配置文件，并创建对象，当用户发请求就可以直接使用对象。
    servlet的初始化会执行Init()方法。DispatcherServlet在init()中{
    //创建容器，读取配置文件
    WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
    //把容器对象放入到ServletContext中
    getServletContext().setAttribute(key,ctx);
    }
    -->
    <servlet>
        <servlet-name>springmvc</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>

        <!--表示启动即创建对象，越小优先级越高-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!--有两种方式设置url
        1.使用扩展名方式，语法是*.xxxx  常用的方式*.do  *.action  *.mvc等
        2.使用斜杠"/"
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

3）在resources下创建springmvc.xml和上面的classpath对应并增加注解扫描用于创建对象

 <!--开启注解扫描-->
    <context:component-scan base-package="com.springmvc"></context:component-scan>

4）创建MyController类，增加注解，通过RequestMapping创建请求对应的方法

package com.springmvc.controller;

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

//控制器类,创建处理器对象，放入到容器中，叫后端控制器，可以处理请求
@Controller
public class MyController {

    //处理用户提交的请求，springmvc是使用方法来处理

    /*通过方法来执行some.do的请求
    @RequsetMapping：请求映射，作用是把一个请求地址和方法绑定在一起
    一个请求指定一个方法处理
    属性：1.value是一个string，表示请求的url地址，不可重复，推荐地址以“/”开头
    位置：在方法上面，常用。
         在类上面
    @RequsetMapping修饰的方法叫处理器方法或控制器方法，可以处理请求，类似Servlet中的doGet，doPost

    返回值：ModelAndView表示本次请求的处理结果
    Model：数据，请求处理完成后，要显示给用户的数据
    View：视图，比如jsp
     */

    @RequestMapping(value = "/some.do")
    public ModelAndView doSome()
    {
    //处理some.do的请求
        ModelAndView mv = new ModelAndView();
        //添加数据，框架在请求的最后把数据放入request作用域。
        //request.setAttribute("msg","欢迎使用springmvc开发");
        mv.addObject("msg","欢迎使用springmvc开发");
        mv.addObject("fun","执行的是dosome方法");

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

        //返回mv
        return mv;
    }
}

5）创建上述setViewName返回的show.jsp页面并增加响应代码

<h3>show.jsp从request作用域来获取数据</h3><br/>
<h3>msg数据：${msg}</h3><br/>
<h3>fun数据：${fun}</h3><br/>

6）效果展示：


参考流程说明:

SpringMVC源码理解

问题：用户直接访问show.jsp可以访问但没有数据。
解决方案：把show.jsp放入WEB-INF用户不可访问，资源受到保护，创建任意名称文件夹将show.jsp放进去

 mv.setViewName("WEB-INF/view//show.jsp");

为避免重复操作，需要在springmvx.xml配置视图解析器，帮助开发人员设置视图文件的路径

<!--    视图解析器对象-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--        前缀-->
        <property name="prefix" value="/WEB-INF/view/"/>
<!--        后缀:表示扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>

框架会使用视图解析器来进行自动连接识别：

mv.setViewName("show");

在控制器对象中创建多个方法

    @RequestMapping(value = {"/other.do","/second.do"})
    public ModelAndView doOther()
    {
        //处理some.do的请求
        ModelAndView mv = new ModelAndView();
        //添加数据，框架在请求的最后把数据放入request作用域。
        //request.setAttribute("msg","欢迎使用springmvc开发");
        mv.addObject("msg","==欢迎使用springmvc开发==");
        mv.addObject("fun","执行的是doother方法");

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

        //返回mv
        return mv;
    }

@RequestMapping(value = {"/other.do","/second.do"})中表示不同路径调用一个方法。

SpringMVC注解式开发

@RequestMapping定义请求规则

1、@RequestMapping放在类上面
作用：可以提取value中相同的模块，如下test模块：
而且修改很方便

package com.springmvc.controller;

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

//拿出test公共部分
@Controller
@RequestMapping(value = "/test")
public class MyController {

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

2、@RequestMapping的method的两个参数get和post

package com.springmvc.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
@RequestMapping(value = "/user")
public class MyController {

    /**
     *@RequestMapping:请求映射
     * 属性：method，表示请求的方式。
     * get：值为RequestMethod.GET
     * post:值为RequestMethod.POST
     */


    @RequestMapping(value = {"/some.do","/someone.do"} ,method = RequestMethod.GET)
    public ModelAndView doSome()
    {
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc开发");
        mv.addObject("fun","执行的是dosome方法");
        mv.setViewName("show");
        return mv;
    }
    @RequestMapping(value = {"/other.do","/second.do"},method = RequestMethod.POST)
    public ModelAndView doOther()
    {
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","==欢迎使用springmvc开发==");
        mv.addObject("fun","执行的是doother方法");
        mv.setViewName("other");
        return mv;
    }

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

index.jsp要设置post需要表单形式：

    <a href="user/some.do">发起some.do的get请求</a><br/>
    <form action="/user/other.do" method="post">
        <input type="submit" value="post请求other.do">
    </form>

    <a href="user/and.do">and.do的请求,无method方式</a>

注意：如果方式搞错了，会报错405

处理器方法的参数

逐个参数接收

1、浏览器接收后端的数据
位置：放在方法的形参部分
值包括:

public ModelAndView doSome(HttpServletResponse response, HttpServletRequest request,
                               HttpSession session)
    {
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc开发");
        mv.addObject("fun","执行的是dosome方法");
        mv.setViewName("show");
        return mv;
    }

2、接收用户提交的数据
1）创建首页表单

<form action="receiveproperty.do" method="post">
        姓名：<input type="text" name="name"><br/>
        年龄：<input type="text" name="age"><br/>
        <input type="submit" value="提交参数">
    </form>

2）增加对应方法，传递从页面获取的参数值（即形参值）

    @RequestMapping(value ="/receiveproperty.do")
    public ModelAndView doSome(String name, int age)
    {
        ModelAndView mv = new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",age);
        mv.setViewName("show");
        return mv;
    }

3）在返回的show.jsp页面获取参数值

<h3>show.jsp从request作用域来获取数据</h3><br/>
<h3>myname数据：${myname}</h3><br/>
<h3>myage数据：${myage}</h3><br/>

4）效果

问题：如果年龄为空浏览器会报错400，可以把形参age类型改为包装型Integer

意思内容小结：

请求参数中文乱码问题

问题1：这里有一个中文乱码问题需解决，post提交方式会产生乱码（get方式正常）。
解决方法：在字符过滤器中设置字符编码，过滤器可以自定义，也可以用框架中提供的过滤器CharacterEncodingFilter

//在web.xml声明过滤器，解决post请求乱码的问题
    <!--声明过滤器，解决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>
        <!--强制请求对象（HttpServletRequset）使用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的两个属性：
value：请求中的参数名称
required：是一个boolean类型，默认为true。表示请求中必须包含此参数。
1）如果index页面的表单参数和控制器里的形参名称不同会报错500


解决方法：
增加注解@RequestParam(“请求参数值”)

  @RequestMapping(value ="/receive.do")
    public ModelAndView doreceive(@RequestParam("rname")String name, @RequestParam("rage")int age)
    {
        ModelAndView mv = new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",age);
        mv.setViewName("show");
        return mv;
    }

2）如果直接将获取参数后的URL复制到其他地方浏览没有经过post提交数据，没有传递参数自然会报错
解决方式（增加required参数为false可以传递空值）：

 @RequestMapping(value ="/receive.do")
    public ModelAndView doreceive(@RequestParam(value = "rname",required=false)String name,
                                  @RequestParam(value = "rage",required=false)Integer age)
    {
        ModelAndView mv = new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",age);
        mv.setViewName("show");
        return mv;
    }

利用对象接收参数（一次性接收多个）

处理器方法形参是java对象， 这个对象的属性名称和请求的参数名一致。
框架会创建形参的java对象，给属性赋值。请求中的参数是name，框架会调用setName()。
对象形参可以有多个
1）创建储存数据的对象

package com.springmvc.vo;

//保留参数值的普通类
public class Student {

    //请求明和参数名称一样
    private String name;
    private Integer age;

    public Student() {
        System.out.println("Student无参构造方法");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("setname"+name);
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        System.out.println("setage"+age);
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2）在控制器中调用对象即可

 @RequestMapping(value ="/receiveobject.do")
    public ModelAndView doreceive(Student myStudent)
    {
        ModelAndView mv = new ModelAndView();
        mv.addObject("myname",myStudent.getName());
        mv.addObject("myage",myStudent.getAge());
        mv.addObject("mystudent",myStudent);
        mv.setViewName("show");
        return mv;
    }

3）视图中显示数据

<h3>mystudent数据：${mystudent}</h3><br/>

处理器方法的返回值

返回值-ModelAndView

需要视图和数据时使用

返回值-String

这部分是视图部分（如a页面调转到b页面）
1）处理器方法返回String，表示逻辑视图名称，需要配置视图解析器

<!--    视图解析器对象-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--        前缀-->
        <property name="prefix" value="/WEB-INF/view/"/>
<!--        后缀:表示扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>

2）show：逻辑视图名称，项目中配置的视图解析器 。框架对视图进行forward转发操作

    @RequestMapping(value = "/returnString.do")
    public String doSome(String name, Integer age) {

        return "show";
    }

如果想即返回String又植入数据，添加HttpServletRequest，把数据添加到request作用域上

    @RequestMapping(value = "/returnString.do")
    public String doSome(HttpServletRequest request,String name, Integer age) {
        request.setAttribute("myname",name);
        request.setAttribute("myage",age);
        return "show";
    }

处理方法返回String表示完整视图路径，此时不能配置视图解析器 【需要将springmvc.xml的视图解析器给注释掉】

@RequestMapping(value = "/returnString2.do")
public String doReturnView2(HttpServletRequest request,String name, Integer age) {
    request.setAttribute("myname",name);
    request.setAttribute("myage",age);
    return "/WEB-INF/view/show.jsp";
}

返回值-void（了解）

void不能表示数据也不能表示视图。在处理ajax，可以用void返回值。可以通过HttpServletRespouse应答对象输出数据，响应ajax请求
ajax请求服务器返回的就是数据，和视图无关

1）下载jquery放到WEB-INF目录下的js目录

打开：https://code.jquery.com/jquery-3.5.1.min.js
Ctrl+S

2)在pom中引入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>

3）首页做ajax提交

 <title>异步测试</title>
    <script type="text/javascript" src="js/jquery-3.5.1.min.js"></script>
    <script type="text/javascript">
        $(function () {
            $("button").click(function () {
                // alert("button click");
                $.ajax({
                    url:"returnVoidAjax.do",
                    data:{
                        name:"张三",
                        age:20
                    },
                    type:"post",
                    dataType:"json",
                    success:function (resp) {
                        alert(resp);
                        //会把字符串转为json对象，可用此对象获取name和age如resp.name;resp.age
                    }
                })
            })
        })
    </script>
</head>

4）处理ajax，使用json做数据的格式，我们通过Student来储存从前端获取的数据

   @RequestMapping(value = "/returnVoidAjax.do")
    public void doReturnVoidAjax(HttpServletResponse response,String name, Integer age) throws IOException {
        //处理ajax，使用json做数据的格式
        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，json数据：代码有重复
1.java对象转为json
2.通过HttpServletResponse输出json对象
可交给框架使用，就用到对象Object

返回值-对象Object

框架中做返回对象，响应ajax
可返回的对象包括：String/Integer/Map/List/Student等等都是对象。对象有属性，属性就是数据。所以返回Object表示数据，和视图无关。
可以使用对象表示的数据，响应ajax的请求。
格式：现在总ajax，主要使用json数据格式。实现步骤：
1、加入处理json的工具库的依赖，springmvc默认使用jackson。
2、在springmvc配置文件中加入标签mvc:annotation-drive注解驱动。
理解为做这个：

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

3、在处理器方法的上面加入@ResponseBody注解

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

4、原理


@ResponseBody注解原理：


案例；
第一步：POM中引入依赖，增加框架注解

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

    <!--开启SpringMVC框架注解的支持-->
    <mvc:annotation-driven/>

第二步：index.jsp中实现ajax方式提交数据

<%--
  Created by IntelliJ IDEA.
  User: haojie
  Date: 2020/8/25
  Time: 7:25
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>异步测试</title>
    <script type="text/javascript" src="js/jquery-3.5.1.min.js"></script>
    <script type="text/javascript">
        $(function () {
            $("button").click(function(){
                // alert("button click");
                $.ajax({
                    // url:"returnVoidAjax.do",
                    url:"returnStudentJson.do",
                    data:{
                        name:"张三",
                        age:20
                    },
                    type:"post",
                    dataType:"json",
                    success:function (resp) {
                        // alert(resp.name+"   "+resp.age);
                        alert(resp.name+"  "+resp.age);
                    }
                })
            })
        })
    </script>
</head>
<body>
    <h3>返回值String测试</h3>


    <form action="returnString.do" method="post">
        姓名：<input type="text" name="name"><br/>
        年龄：<input type="text" name="age"><br/>
        <input type="submit" value="提交参数">
    </form>
    <br/>

    <form action="returnString2.do" method="post">
        姓名：<input type="text" name="name"><br/>
        年龄：<input type="text" name="age"><br/>
        <input type="submit" value="提交参数">
    </form>

    <br/>
    <button id="btn">发起ajax请求</button>

</body>
</html>

第三步：在类上增加注解 @ResponseBody

    @RequestMapping(value = "/returnStudentJson.do")
    @ResponseBody
    public Student  doStudentAjax(String name, Integer age)  {
        //调用service获取请求数据，Student对象表示结果数据
        Student student=new Student();
        student.setAge(32);
        student.setName("张三");
        return student;//会被框架转为json
    }

步骤说明：
方法返回Student，通过框架转为json，响应ajax请求
@ResponseBody作用：把处理器方法返回的对象，转为json后，通过HttpServletResponse输出给浏览器。位置：在方法的定义上方，无先后关系。
返回对象框架的处理流程：
1、框架会把返回Student的类型，调用框架中ArrayList中每个类的canWrite方法，以检查哪个HttpMessageConverter接口的实现类能处理Student类型的数据
2、框架会调用实现类的write（），MappingJackson2HttpMessageConverter的write（）方法把张三的对象Student转为Json，调用Jackson中的ObjectMapper实现转为json
contentType:application/json;charset=utf-8
3、框架会调用 @ResponseBody把2的结果数据输出到浏览器，ajax请求完成。

返回值List

1、控制器方法

    @RequestMapping(value = "/returnStudentJsonArray.do")
    @ResponseBody
    public List<Student> doStudentJsonObectArray(String name, Integer age)  {
        //调用service获取请求数据，Student对象表示结果数据
        List<Student> list=new ArrayList<>();
        Student student=new Student();
        student.setAge(32);
        student.setName("张三");
        list.add(student);
        student=new Student();
        student.setAge(20);
        student.setName("李四");
        list.add(student);
        return list;//会被框架转为json
    }

2、在首页处理数据

<head>
    <title>异步测试</title>
    <script type="text/javascript" src="js/jquery-3.5.1.min.js"></script>
    <script type="text/javascript">
        $(function () {
            $("button").click(function(){
                // alert("button click");
                $.ajax({
                    // url:"returnVoidAjax.do",
                    url:"returnStudentJsonArray.do",
                    data:{
                        name:"张三",
                        age:20
                    },
                    type:"post",
                    dataType:"json",
                    success:function (resp) {
                        // alert(resp.name+"   "+resp.age);

                        $.each(resp,function (i,n) {
                            alert(n.name+" "+n.age)
                        })
                    }
                })
            })
        })
    </script>
</head>

返回值String数据

这里的String表示的是数据而不是试图。
区分方法：
如果方法上有@RespouseBody
问题1：注意（如果返回文本数据，就无须转为Json）：

问题2：乱码
默认告诉浏览器Content-Type: text/plain;charset=ISO-8859-1
解决方法：给RequestMapping增加一个属性produces="text/plain;charset=utf-8（静态资源乱码也需要加个这个属性）

    @RequestMapping(value = "/returnStringData.do",produces="text/plain;charset=utf-8")
    @ResponseBody
    public String doStringData(String name,Integer age)
    {
        return "Hello SpringMVC,用String返回数据";
    }

解读 <url-pattern/ >

用第二种方式/

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!--有两种方式设置url
        1.使用扩展名方式，语法是*.xxxx  常用的方式*.do  *.action  *.mvc等
        2.使用斜杠"/"
        -->
        <url-pattern>/</url-pattern>

 2.使用斜杠"/",它会替代tomcat中的default。
        导致所有的静态资源都给DispatcherServlet处理，默认情况不处理，没有控制器能处理
        静态资源的访问。所以静态资源（html，js，图片，css）都是404.
        动态资源somo.do可访问，因为程序中有MyController控制器对象。
        -->
        <url-pattern>/</url-pattern>

修改斜杠如何访问静态资源:

<!--    第一种处理静态资源的方式
        原理：会创建控制器对象，类似MyController-->
    <mvc:default-servlet-handler/>

<!--    第二种处理静态资源的方式
        原理：会创建控制器对象，类似MyController-->
    <mvc:resources mapping="/iamges/**" location="/iamges/"/>
    <mvc:resources mapping="/html/**" location="/html/"/>
    <mvc:resources mapping="/js/**" location="/js/"/>
//第二种方法简化方式
//创建static文件夹
//然后直接饮用static
 <mvc:resources mapping="/static/**" location="/static/"/>

地址：
地址加/ 默认路径就是项目名称
地址不加/ 需要加项目名称，会出现各种问题
1、如果项目名称较多可以用如下方式解决

2、如果项目重复

动态获取路径方法：

BasePath只对当前页面有效