SpringMVC上

SpringMVC介绍

MVC模型

MVC全称Model View Controller，是一种设计创建Web应用程序的模式。这三个单词分别代表Web应用程序的三个部分：

• Model（模型）：指数据模型。用于存储数据以及处理用户请求的业务逻辑。在Web应用中，JavaBean对象，业务模型等都属于Model。
• View（视图）：用于展示模型中的数据的，一般为jsp或html文件。
• Controller（控制器）：是应用程序中处理用户交互的部分。接受视图提出的请求，将数据交给模型处理，并将处理后的结果交
  给视图显示。

SpringMVC

SpringMVC是一个基于MVC模式的轻量级Web框架，是Spring框架的一个模块，和Spring可以直接整合使用，使用的版本是
Spring6，所以JDK需要17以上。SpringMVC代替了Servlet技术，它通过一套注解，让一个简单的Java类成为处理请求的控制器，而
无须实现任何接口。

SpringMVC入门案例

• 使用maven创建web项目，补齐包结构。
  

• 引入相关依赖以及插件

<dependencies>
        <!--        spring核心依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.11</version>
        </dependency>
        <!--        SpringMVC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>6.0.11</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>6.0.11</version>
        </dependency>
        <!--        Servlet-->
        <dependency>
            <groupId>jakarta.servlet</groupId>
            <artifactId>jakarta.servlet-api</artifactId>
            <version>6.0.0</version>
<!--            <scope>provided</scope>-->
        </dependency>
        <!--        JSP-->
        <dependency>
            <groupId>jakarta.servlet.jsp</groupId>
            <artifactId>jakarta.servlet.jsp-api</artifactId>
            <version>3.0.0</version>
<!--            <scope>provided</scope>-->
        </dependency>
        <!--        Annotation-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.19</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>


    </dependencies>
 <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.3.1</version>
            </plugin>
        </plugins>
    </build>

• 在web.xml中配置前端控制器DispatcherServlet。

<display-name>Archetype Created web Application</display-name>
<!--    SpringMVC前端控制器，本质是一个Servlet，接收所有请求，在容器启动时就会加载-->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

• 编写SpringMVC核心配置文件springmvc.xml，该文件和Spring
  配置文件写法一样。

<!--    扫描包-->
<context:component-scan base-package="com.winter"></context:component-scan>
<!--    开启SpringMVC注解的支持-->
    <mvc:annotation-driven />

• 编写控制器

package com.winter.controller;

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

@Controller
public class MyController {
//该方法的访问路径是/c1/hello1
    @RequestMapping("/c1/hello1")
    public void helloMVC(){
        System.out.println("hello SpringMVC!");
    }
}

• 配置tomcat10启动项目，访问 http://localhost:8080/c1/hello1
  

SpringMVC执行流程

SpringMVC的组件

• DispatcherServlet：前端控制器，接受所有请求，调用其他组件。
• HandlerMapping：处理器映射器，根据配置找到方法的执行链。
• HandlerAdapter：处理器适配器，根据方法类型找到对应的处理器。
• ViewResolver：视图解析器，找到指定视图。

组件的工作流程

• 客户端将请求发送给前端控制器。
• 前端控制器将请求发送给处理器映射器，处理器映射器根据路径找到方法的执行链，返回给前端控制器。
• 前端控制器将方法的执行链发送给处理器适配器，处理器适配器根据方法类型找到对应的处理器。
• 处理器执行方法，将结果返回给前端控制器。
• 前端控制器将结果发送给视图解析器，视图解析器找到视图文件位置。
• 视图渲染数据并将结果显示到客户端。

SpringMVC封装参数_简单数据类型

在Servlet中我们通过 request.getParameter(name) 获取请求参数。该方式存在两个问题：

• 请求参数较多时会出现代码冗余。
• 与容器紧耦合。

SpringMVC支持参数注入的方式用于获取请求数据，即将请求参数直接封装到方法的参数当中。用法如下：

• 编写控制器方法

    @RequestMapping("/c1/param1")
    public void helloMVC(String username,int age){
        System.out.println(username);
        System.out.println(age);
    }

• 访问该方法时，请求参数名和方法参数名相同，即可完成自动封装。

http://localhost:8080/c1/param1?username=xyy&age=10

SpringMVC封装参数_简单对象

SpringMVC支持将参数直接封装为对象，写法如下：

• 编写实体类

public class Student {
    private int id;
    private String name;
    private String gender;
    //省略getter()/setter()/toString()方法
}

• 编写控制器方法

    //封装为简单对象类型参数
    @RequestMapping("/c1/param2")
    public void objParam(Student student){
        System.out.println(student);
    }

• 访问该方法时，请求参数名和对象参数的属性名相同，即可完成自动封装。

http://localhost:8080/c1/param2?id=1&name=myy&sex=female

SpringMVC封装参数_关联对象

SpringMVC还可以将请求参数封装为关联对象，即对象的属性也是一个对象。写法如下：

• 编写实体类

在这里插入代码片

• 编写控制器方法

//获取关联对象类型参数
    @RequestMapping("/c1/param3")
    public void objParam2(Student student){
        System.out.println(student);
    }

• 访问该方法时，请求参数名和方法参数的属性名相同，即可完成自动封装。

http://localhost:8080/c1/param3?id=1&name=xyy&sex=femal
e&address.info=grass&address.postcode=030000

也可以使用表单发送带有参数的请求：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="/c1/param3" method="post">
    id:<input name="id">
    姓名:<input name="name">
    性别:<input name="address.info">
    邮编:<input name="address.postcode">
    <input type="submit">
</form>
</body>
</html>

SpringMVC封装参数_List集合

SpringMVC支持将请求参数封装为List或Map集合，写法如下：

封装为简单数据类型集合

• 编写控制器方法

//封装为简单数据类型集合，参数前必须添加@RequestParam注解
    @RequestMapping("/c1/param4")
    public void listParam(@RequestParam List<String> user){
        System.out.println(user);
    }

也可以封装为简单数据类型数组：

//也可以封装为简单数据类型数组
    @RequestMapping("/c1/param5")
    public void listParam2(@RequestParam String[] users){
        System.out.println(users[0]);
        System.out.println(users[1]);
    }

• 请求的参数写法

http://localhost:8080/c1/param4?user=myy&user=xyy

封装为对象类型集合

SpringMVC不支持将请求参数封装为对象类型的List集合，但可以封装到有List属性的对象中。

• 编写实体类

public class AddressList {
    private List<Address> address;

• 编写控制器方法

@RequestMapping("/c1/param6")
    public void listParam3(AddressList addressList){
        System.out.println(addressList);
    }

• 请求的参数写法

/*新版Tomcat中，URL中的方括号必须编码， [ 使用 %5B 代替， ]使用 %5D 代替，所以URL的路径写法如下：*/
http://localhost:8080/c1/param6?address%5B0%5D.info=hn&address%5B0%5D.postcode=422000&address%5B1%5D.info=cs&address%5B1%5D.postcode=12332

SpringMVC封装参数_Map集合

同样，SpringMVC要想把参数封装到Map集合中，需要封装到有Map属性的对象中。

• 编写实体类

public class AddressMap {
    private Map<String,Address> address;
    // 省略getter/setter/tostring

• 编写控制器方法

  @RequestMapping("/c1/param7")
    public void mapParam3(AddressMap addressMap){
        System.out.println(addressMap.getAddress());
    }

• 请求的参数写法

http://localhost:8080/c1/param6?address%5B0%5D.info=hn&address%5B0%5D.postcode=422000&address%5B1%5D.info=cs&address%5B1%5D.postcode=12332

SpringMVC封装参数_参数类型转换器

前端传来的参数全部为字符串类型，SpringMVC使用自带的转换器将字符串参数转为需要的类型。如：

 //获取简单数据类型
    @RequestMapping("/c1/param1")
    public void simpleParam(String username,int age){
        System.out.println(username);
        System.out.println(age);
    }

但在某些情况下，无法将字符串转为需要的类型，如：

@RequestMapping("/c1/param8")
public void date(Date date){
  System.out.println(date);
}

由于日期数据有很多种格式，SpringMVC默认只能转换 2050/1/1 这样的日期格式。但假如前端传来的参数格式为 2025-01-01 时，
SpringMVC就无法解析参数。此时需要自定义参数类型转换器。

• 定义类型转换器类，实现Converter接口

public class DateConverter implements Converter<String, Date> {
    /**
     * 转换方法
     * @param source 转换前的数据
     * @return 转换后的数据
     */
    @Override
    public Date convert(String source) {
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");
        Date date=null;
        try {
            date=simpleDateFormat.parse(source);
        }catch (Exception e){
            e.printStackTrace();
        }
        return date;
    }
}

• 注册类型转换器对象

<!--    配置转换器工厂-->
    <bean id="dataConverter" class="org.springframework.context.support.ConversionServiceFactoryBean">
<!--        转换器集合-->
        <property name="converters">
            <set>
<!--                自定义转换器-->
                <bean class="com.winter.converter.DateConverter"></bean>
            </set>
        </property>
    </bean>
<!--    使用转换器工厂-->
    <mvc:annotation-driven conversion-service="dataConverter"></mvc:annotation-driven>

• 此时再访问http://localhost:8080/c1/param9?date=2025-01-01时，SpringMVC即可将请求参数封装为Date类型的参数。

SpringMVC封装参数_编码过滤器

在传递参数时，tomcat10以上不会出现中文乱码，tomcat8以上能处理get请求的中文乱码，但不能处理post请求的中文乱码。

• 编写jsp表单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>编码过滤器</title>
</head>
<body>
<form action="/c1/code" method="post">
      姓名:<input name="name">
    <input type="submit">
</form>
</body>
</html>

• 编写控制器方法

 @RequestMapping("/c1/code")
    public void code(String username){
        System.out.println(username);
    }

• SpringMVC提供了处理中文乱码的过滤器，在web.xml中配置该过滤器即可解决中文乱码问题：

  <!--SpringMVC中提供的字符编码过滤器,放在所有过滤器的最上方-->
    <filter>
        <filter-name>encFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

SpringMVC封装参数_Servlet原生对象

SpringMVC的方法中已经封装好了Servlet原生对象，在方法参数中定义 HttpServletRequest、 HttpServletResponse、 HttpSession等类型的参数即可直接在方法中使用。

//使用sevlet原生对象
    @RequestMapping("/c1/param9")
    public void servletParam(HttpServletRequest request, HttpServletResponse response, HttpSession session){
        //原生对象获取参数
        System.out.println(request.getParameter("name"));
        System.out.println(response.getCharacterEncoding());
        System.out.println(session.getId());
    }

访问路径为：http://localhost:8080/c1/param9?name=xy

一般情况下，在SpringMVC中都有对Servlet原生对象的方法的替代，推荐使用SpringMVC的方式代替Servlet原生对象。

SpringMVC处理响应_视图解析器

SpringMVC默认情况下会在控制器执行完成后跳转到视图页面，视图解析器能找到相应的视图，之前的404异常就是由于没有配置视图解析器导致找不到视图。

在SpringMVC中提供了13个视图解析器，用于支持不同的视图技术。InternalResourceViewResolver是SpringMVC的默认视图解析器，用来解析JSP视图。

<!--视图解析器-->
    <bean id="viewReslover" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--    视图前缀-->
    <property name="prefix" value="/"></property>
<!--    视图后缀-->
    <property name="suffix" value=".jsp"></property>
</bean>

SpringMVC处理响应_返回值为void

可以通过控制器方法的返回值设置跳转的视图，控制器方法支持的返回值类型为 void、 String、 ModelAndView

前缀+方法路径名+后缀 的jsp页面

• 编写控制器方法

   //路径是helloMVC，方法执行完后会跳转到/helloMVC.jsp
    @RequestMapping("/helloMVC")
    public void helloMVC(){
        System.out.println("hello SpringMVC!");
    }

• 编写helloMVC.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>MVC</title>
</head>
<body>
<h1>欢迎来到SpringMVC</h1>
</body>
</html>

SpringMVC处理响应_返回值为String

跳转到名字是 前缀+返回值+后缀 的jsp页面

编写控制器方法

//返回值是String
    @RequestMapping("/c2/hello")
    public String helloMVC1(){
        System.out.println("hello SpringMVC");
       return "helloMVC";
    }

SpringMVC处理响应_返回值为ModelAndView

ModelAndView是SpringMVC提供的对象，该对象可以向request域设置数据并指定跳转的页面。该对象中包含Model对象和View对象。

• Model：向request域中设置数据。
• View：指定跳转的页面。

编写控制器方法

 //返回值为ModelAndView
    @RequestMapping("/c2/hello2")
    public ModelAndView hello(){
        System.out.println("返回值类型为ModelAndView");
        //创建ModelAndView对象
        ModelAndView modelAndView=new ModelAndView();
        //获取Model对象，本质是一个Map
        Map<String,Object> model1=modelAndView.getModel();
        //使用Model对象向request域设置数据
        model1.put("name","熊大");
        //使用View对象设置跳转的路径,该值需要与jsp名字对应上
        modelAndView.setViewName("ModelAndView");
        return modelAndView;
    }

编写jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>ModelAndView</title>
</head>
<body>
  <h1>您好！${requestScope.name}</h1>
</body>
</html>

修改web.xml命名空间，让jsp页面默认支持el表达式

<?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_3_1.xsd"
         version="3.1">
 </web-app>

SpringMVC处理响应_向request域设置数据

当控制器返回值为ModelAndView时我们可以向request域设置数据，还有以下方法可以向request域设置数据：

使用原生的HttpServletRequest

 @RequestMapping("/c2/hello3")
    public String setRequestModel(HttpServletRequest request){
        request.setAttribute("name","熊出没");
        return "ModelAndView";
    }

使用Model、ModelMap

SpringMVC提供了Model接口和ModelMap类，控制器方法添加这两个类型的参数，使用该参数设置数据，该数据就会存到request域中。

   @RequestMapping("/c2/hello4")
    public String setRequestModel2(Model model, ModelMap modelMap){
       //model.addAttribute("name","蹦蹦");
        modelMap.addAttribute("name","涂涂");
        return "ModelAndView";
    }

使用Map集合

Model接口底层就是一个Map集合，给控制器方法设置Map类型的参数，向Map中添加键值对，数据也会存到request域中。

@RequestMapping("/c2/hello5")
    public String setRequestModel3(Map map){
        map.put("name","肥波");
        return "ModelAndView";
    }

SpringMVC处理响应_向session域设置数据

Session作用域表示在当前会话中有效。可以在控制器方法的参数中使用HttpSession对象来向session域设置数据。

• 编写控制器方法

 @RequestMapping("/c2/hello6")
    public String setSessionModel(HttpSession session){
        session.setAttribute("address","狗熊岭");
        return "ModelAndView";
    }

• 编写jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>ModelAndView</title>
</head>
<body>
  <h1>您好！${requestScope.name}</h1>
  <h1>地址是${sessionScope.address}</h1>
</body>
</html>

SpringMVC处理响应_向context域设置数据

context作用域表示在整个应用范围都有效。在SpringMVC中对context作用域传值，可以使用ServletContext对象来实现。但是该对象不能直接注入到方法参数中，需要通过HttpSession对象获取。

编写控制器方法

@RequestMapping("/c2/hello7")
    public String setContextModel(HttpSession httpSession){
        ServletContext servletContext=httpSession.getServletContext();
        servletContext.setAttribute("age",10);
        return "ModelAndView";
    }

编写jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>ModelAndView</title>
</head>
<body>
  <h1>您好！${requestScope.name}</h1>
  <h1>地址是${sessionScope.address}</h1>
<h1>年纪是${applicationScope.age}</h1>
</body>
</html>

SpringMVC处理响应_请求转发&重定向

之前的案例，发现request域中的值可以传到jsp页面中，也就是通过视图解析器跳转到视图的底层请求转发。

如果我们跳转时不想使用视图解析器，可以使用原生HttpServletRequest进行请求转发或HttpServletResponse进行重定向：

 @RequestMapping("/c2/hello8")
    public void myForward1(HttpServletRequest request,HttpServletResponse response)throws
            Exception{
        request.setAttribute("name","光头强");
        //请求转发
       // request.getRequestDispatcher("/c2/hello9").forward(request,response);
        //原生重定向
        response.sendRedirect("/c2/hello9");
    }

@RequestMapping("/c2/hello9")
    public void myForward2(HttpServletRequest request){
        System.out.println("hello");
        System.out.println(request.getAttribute("name"));
    }

 //SpringMVC提供了一种更简单的请求转发和重定向的方法
    @RequestMapping("/c2/hello10")
    public String myForward(HttpServletRequest request){
        request.setAttribute("name","赵琳");
        //请求转发
        return "forward:/c2/hello9";
        //重定向
        //return "redirect:/c2/hello9";
    }

SpringMVC注解_@Controller、@RequestMapping

@Controller

作用：标记控制器，将控制器交给Spring容器管理。
位置：类上方

@RequestMapping

作用：给控制器方法设置请求路径
位置：方法或类上方。用于类上，表示类中的所有控制器方法都是以该地址作为父路径。
属性：

• value/path:请求路径
• method:指定请求方式
• params:规定必须发送的请求参数
• headers:规定请求必须包含的请求头

@Controller
@RequestMapping("/c3")
public class MyController3 {

    /**
     * 访问路径：/c2/hello2
     * 支持post和get请求
     * 请求必须带有username参数
     * 请求必须带有User-agent请求头
     * @param username
     * @return
     */
    @RequestMapping(path = "/hello1",
    method = {RequestMethod.POST,
    RequestMethod.GET},
    params = {"username"},
    headers = {"User-agent"})
    public String annotation1(String username){
        System.out.println(username);
        return "index";
    }
}

SpringMVC注解_@RequestParam

作用： 在控制器方法中封装请求参数
位置：方法参数前
属性：

• value/name：指定请求参数名称
• defaultValue： 为参数设置默认值
• required：设置是否是必须要传入的参数

 //定义请求的参数名为name，默认值是BearComeOn,不是必须的参数
    
    @RequestMapping("/a2")
    public String annotation2(@RequestParam(name = "name",defaultValue = "BearComeOn", 
            required = false) String name){
        System.out.println(name);
        return "index";
    }
        

请求URL的写法：http://localhost:8080/c3/a2?name=xy

SpringMVC注解_@RequestHeader、@CookieValue

@RequestHeader

作用：将请求头数据封装到控制器方法参数中
位置：方法参数前

@CookieValue

作用：将Cookie数据封装到控制器方法参数中
位置：方法参数前

//获取User-Agent请求头
// 获取JSESSIONID的Cookie值
  @RequestMapping("/annotation3")
    public String annotation3(@RequestHeader("User-Agent") String userAgent,
        @CookieValue("JSESSIONID") String jSessionId){
        System.out.println(userAgent);
        System.out.println(jSessionId);
        return "index";
    }

SpringMVC注解_@SessionAttributes

作用：将Model模型中的数据存到session域中
位置：类上方

@Controller
@RequestMapping("/c4")
//将模型中的name数据保存到session中
@SessionAttributes("name")
public class MyController1 {
 @RequestMapping("/t1")
    public String t1(Model model){
     //model中保存name数据
     model.addAttribute("name","熊出没");
     return "ModelAndView";
 }

 @RequestMapping("/t2")
    public String t2(HttpSession session){
     //从session中获取name数据
     Object name=session.getAttribute("name");
     System.out.println(name);
     return "ModelAndView";
 }

}

SpringMVC注解_@ModelAttribute

作用1：设置指定方法在控制器其他方法前执行

位置：方法上方

@Controller
@RequestMapping("/c5")
public class MyController2 {
    @ModelAttribute
    public void before(){
        System.out.println("前置方法");
    }
    @RequestMapping("/t1")
    public String t1(){
        System.out.println("t1");
        return "ModelAndView";
    }
}

作用2：从Model模型中获取数据给参数赋值

位置：方法上方

@Controller
@RequestMapping("/c6")
public class MyController4 {
    //前置方法向Model中设置数据
    @ModelAttribute
    public void before(Model model){
        model.addAttribute("name","喜羊羊");
    }
    //该参数不是从请求中获取，而是从Model中获取
    @RequestMapping("/t1")
    public String t1(@ModelAttribute("name") String name)
    {
        System.out.println(name);
        return "ModelAndView";
    }
}

SpringMVC注解_RESTful风格支持

RESTful风格是一种URL路径的设计风格。在RESTful风格的URL路径中，网络上的任意数据都可以看成一个资源，它可以是一段文本、一张图片，也可以是一个Java对象。而每个资源都会占据一个网络路径，无论对该资源进行增删改查，访问的路径是一致的。

传统URL:

• 查找id为1的学生：
  http://localhost:8080/student/findById?id=30
• 删除id为1的学生：
  http://localhost:8080/student/deleteById?id=30

RESTful风格URL：

• 查找id为30的学生：
  http://localhost:8080/student/30
• 删除id为30的学生：
  http://localhost:8080/student/30

如何区分对该资源是哪一种操作？通过请求方式不同，判断进行的是什么操作。

之前我们学过两种请求方式，GET请求和POST请求，而访问RESTful风格的URL一共有四种请求方式：

• GET请求：查询操作
• POST请求：新增操作
• DELETE请求：删除操作
• PUT请求：修改操作

RESTful风格URL：

• 查找id为30的学生：
  http://localhost:8080/student/30 GET方式请求
• 删除id为30的学生：
  http://localhost:8080/student/30 DELETE方式请求

RESTful风格的优点:结构清晰、符合标准、易于理解、扩展方便。

SpringMVC注解_Postman使用

默认情况下浏览器是无法发送DELETE请求和PUT请求的，我们可以使用Postman工具发送这些请求。

• 双击安装包安装Postman

• 点击new-collection创建请求集合
  

• 添加请求
  

• 保存请求到集合，以后可以随时发送该请求
  

SpringMVC注解_@PathVariable

作用：在RESTful风格的URL中获取占位符的值
位置：方法参数前
属性：
value：获取哪个占位符的值作为参数值，如果占位符和参数名相同，可以省略该属性。

@Controller
@RequestMapping("/student")
//模拟学生的增删改查控制器
public class MyController5 {
    //路径中的/{id}表示占位符,最后会封装到方法的参数中使用
    //删除学生
    @RequestMapping(value = "/{id}",method = RequestMethod.DELETE)
    public String deleteStudent(@PathVariable("id") int id){
        System.out.println("删除id为"+id+"的学生");
        return "ModelAndView";
    }
    //如果占位符和参数名相同，可以省略@PathVariable中的value属性
    //根据id查询学生
    @RequestMapping(value="/{id}",method = RequestMethod.GET)
    public String findStudentById(@PathVariable int id){
        System.out.println("查找id为"+id+"的学生");
        return "ModelAndView";
    }
    //新增学生
    @RequestMapping(value = "/{id}",method = RequestMethod.POST)
    public String addStudent(@PathVariable int id, Student student){
        System.out.println("新增id为"+id+"的学生");
        System.out.println(student);
        return "ModelAndView";
    }
    //修改学生
    @RequestMapping(value = "/{id}",method = RequestMethod.PUT)
        public String updateStudent(@PathVariable int id,Student student){
             System.out.println("修改id为"+id+"的学生");
             System.out.println(student);
             return "ModelAndView";
        }
    }

访问方式：

• 新增学生：POST localhost:8080/student/100?name=dog&sex=female
• 修改学生：PUT localhost:8080/student/100?name=dog1&sex=女1
• 删除学生：DELETE localhost:8080/student/100
• 查询学生：GET localhost:8080/student/100

SpringMVC注解_@PostMapping、@GetMapping、@PutMapping、@DeleteMapping

作用：简化设置请求方式的@RequestMapping写法
位置：方法上方

@Controller
@RequestMapping("/student1")
public class StudentController {
    //删除学生
    @DeleteMapping("/{id}")
    public String deleteStudent(@PathVariable("id") int id){
        System.out.println("删除id为"+id+"的学生");
        return "ModelAndView";
    }
    //根据id查询学生
    @GetMapping("/{id}")
    public String findStudentById(@PathVariable int id){
        System.out.println(id);
        System.out.println("根据id查询学生");
        return "ModelAndView";
    }
    //新增学生
    @PostMapping("/{id}")
    public String addStudent(@PathVariable int id, Student student){
        System.out.println(id);
        System.out.println(student);
        System.out.println("新增学生");
        return "ModelAndView";
    }
    //修改学生
    @PutMapping("/{id}")
    public String updateStudent(@PathVariable int id,Student student){
        System.out.println(id);
        System.out.println(student);
        System.out.println("修改学生");
        return "ModelAndView";
    }
}

SpringMVC注解_HiddenHttpMethodFilter

由于浏览器的表单只支持 GET与 POST请求，不支持 DELETE、 PUT请求。所以SpringMVC提供了一个过滤器，可以将浏览器的 POST请求改为指定的请求方式，发送给控制器的方法。
用法如下：

1. 在web.xml中配置过滤器

<!--    请求方式过滤器-->
    <filter>
        <filter-name>httpMethodFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>httpMethodFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

2. 编写控制器方法

@Controller
@RequestMapping("/c7")
public class MyController6 {
    @DeleteMapping("/delete")
    public String testDelete(){
        System.out.println("删除方法");
        return "Delete";
    }
    @PutMapping("/put")
    public String testPut(){
        System.out.println("修改方法");
        return "Delete";
    }
}

3. 在jsp中编写表单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>DELETE、PUT提交</title>
</head>
<body>
<%--删除--%>
<%--提交DELETE、PUT请求，表单提交方式为post--%>
<%--表单中有一个隐藏域，name值为_method,value值为提交方式--%>
<form action="/c7/delete">
    <input type="hidden" name="_method" value="DELETE">
    <input type="submit" value="删除">
</form>
<hr/>
<%--修改--%>
<form action="/c7/put" method="post">
    <input type="hidden" name="_method" value="PUT">
    <input type="submit" value="修改">
</form>
</body>
</html>

SpringMVC注解_@ResponseBody

作用：方法返回的对象转换为JSON格式，并将JSON数据直接写入到输出流中，使用此注解后不会再经过视图解析器。使用该注解可以处理Ajax请求。
位置：方法上方或方法返回值前

• 编写jsp页面，发送ajax请求

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>ajax请求</title>
    <script src="/js/jquery-2.1.1.min.js"></script>
    <script>
        $(function (){
            $("#btn").click(function () {
                var name=$("#name").val();
                var gender=$("#gender").val();
                $.get("/c8/addStudent",{"name":name,"gender":gender},function (data) {
                    console.log(data);
                });
            });
        });
    </script>
</head>
<body>
姓名：<input id="name"/><br/>
性别：<input id="gender"/><br/>
<input type="button" value="提交" id="btn"/>
</body>
</html>

• 由于jsp页面中引入jQuery的js文件，而SpringMVC会拦截所有资源，造成jquery.js失效，需要在SpringMVC核心配置文件中放行静态资源。

 <mvc:default-servlet-handler />

• 编写结果实体类，该实体类会封装一个请求的结果

//请求结果对象
public class Result {
    private boolean flag;//请求是否成功
    private String message;//请求提示信息
    //省略getter/setter/构造方法
 }

• 编写控制器

@Controller
@RequestMapping("/c8")
public class MyController8 {
    @GetMapping("/addStudent")
    @ResponseBody
    public Result addStudent(String name,String gender) {
        System.out.println(name + ":" + gender);
        Result result = new Result(true, "添加学生成功");
         return result;
    }
}

• SpringMVC会将Result对象转为JSON格式写入输出流，而SpringMVC默认使用的JSON转换器是jackson，需要在pom中添加jackson依赖。

<!--    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>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.0</version>
        </dependency>

SpringMVC注解_@RestController

如果一个控制器类下的所有控制器方法都返回JSON格式数据且不进行跳转，可以使用@RestController代替@Controller，此时每个方法上的@ResponseBody都可以省略。

@RestController
@RequestMapping("/c8")
public class MyController8 {
    @GetMapping("/addStudent")
    public Result addStudent(String name,String gender) {
        //输出接收到的参数，模拟添加学生
        System.out.println(name + ":" + gender);
        //返回结果
        Result result = new Result(true, "添加学生成功");
         return result;
    }
}

SpringMVC注解_静态资源映射

当在DispatcherServlet的 < url-pattern>中配置拦截 “/” 时，除了jsp文件不会拦截以外，其他所有的请求都会经过前端控制器进行匹配。此时静态资源例如css、js、jpg等就会被前端控制器拦截，导致不能访问，出现404问题。想要正常映射静态资源共有三种方案：

• 配置静态资源筛查器

在SpringMVC的配置文件中配置< mvc:default-servlet-handler />后，会在Spring容器中创建一个资源检查器，它对进入DispatcherServlet的URL进行筛查，如果不是静态资源，才由DispatcherServlet处理。

修改SpringMVC核心配置文件：

 <mvc:default-servlet-handler />

• 配置静态资源映射器

SpringMVC模块提供了静态资源映射器组件，通过 < mvc:resources>标签配置静态资源映射器，配置后的路径不会由DispatcherServlet处理。
修改SpringMVC核心配置文件：

<!--    配置静态资源映射器-->
<!--    mapping:配置请求的URL Location：资源路径-->
    <mvc:resources mapping="/img/" location="/img/"/>
    <mvc:resources mapping="/js/" location="/js/"/>

• 配置默认Servlet处理静态资源

在web.xml可以配置默认Servlet处理静态资源，该Servlet由tomcat提供，它会直接访问静态资源不进行其他操作。这样就避免了使用DispatcherServlet对静态资源的拦截：
修改web.xml:

    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.jpg</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.css</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.js</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.png</url-pattern>
    </servlet-mapping>

接口名字不可以重复

SpringMVC注解_@RequestBody

作用：将请求中JSON格式的参数转为JAVA对象位置：写在方法参数前

• AJAX请求发送JSON格式的参数

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>ajax请求</title>
    <script src="/js/jquery-2.1.1.min.js"></script>
    <script>
        $(function () {
            $("#btn").click(function () {
                var name=$("#name").val();
                var gender=$("#gender").val();
                var param=JSON.stringify({"name":name,
                "gender":gender});
                $.ajax({
                    url:"/c8/addStudent2",
                    contentType:"application/json",
                    type:"post",
                    data:param,
                    success:function (data) {
                        console.log(data);
                    }
                })
            })


        })
    </script>
</head>
<body>
姓名：<input id="name"><br/>
性别：<input id="gender"> <br/>
<input type="button" value="提交" id="btn">
</body>
</html>

• 编写控制器

    @PostMapping("/addStudent2")
    @ResponseBody
    public Result addStudent2(@RequestBody Student student){
        System.out.println(student);
        //返回添加结果
        Result result=new Result(true,"添加学生成功");
        return result;
    }

SpringMVC文件上传_原生方式上传

上传是Web工程中很常见的功能，SpringMVC框架简化了文件上传的代码，我们首先使用JAVAEE原生方式上传文件：

• 编写上传表单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>文件上传</h3>
<%--上传表单的提交方式必须是post--%>
<%--enctype属性是multipart/fprm-data，意思是不对表单数据进行编码--%>
<form action="/c8/fileUpload" method="post" enctype="multipart/form-data">
<%--    文件上传控件，类型是file，必须要有name属性--%>
    选择文件：<input type="file" name="upload"/>
    <input type="submit" value="上传"/>
</form>
</body>
</html>

• 接收请求体数据：

@RequestMapping("/fileUpload")
    public String upload(HttpServletRequest request) throws Exception{
        //获取输入流
        ServletInputStream is=request.getInputStream();
        //从输入流获取请求体数据
        int i=0;
        while ((i=is.read())!=-1){
            System.out.println((char) i);
        }
        return "upload";
    }

接下来需要分析请求体中的文件项，并将数据写入磁盘，此时需要借助文件上传工具

• 引入文件上传依赖：

   <!--文件上传-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-fileupload2-jakarta</artifactId>
            <version>2.0.0-M1</version>
        </dependency>

• 编写控制器接收上传请求，控制器进行三步操作：
• 创建文件夹，存放上传文件。
• 分析请求体，找到上传文件数据。
• 将文件数据写入文件夹。

 @RequestMapping("/c8/fileUpload1")
    public String upload1(HttpServletRequest request) throws Exception{
        //创建文件夹，存放上传文件
        //1.设置上传文件路径
        String realPath="D:\\springmvc\\mvc_demo1\\upload";
        //2.判断该目录是否存在，如果不存在，创建该目录
        File file=new File(realPath);
        if(!file.exists()){
            file.mkdirs();
        }
        //分析请求体，找到上传文件数据
        //1.创建磁盘文件工厂
        DiskFileItemFactory factory=DiskFileItemFactory.builder().get();
        //2.创建上传数据分析器对象
        JakartaServletDiskFileUpload upload=new JakartaServletDiskFileUpload(factory);
        //3.利用分析器对象解析请求体，返回所有数据项
        List<DiskFileItem> fileItems=upload.parseRequest(request);
        //4.遍历所有数据，找到文件项(非表单项)
        for(FileItem fileItem:fileItems){
            if(!fileItem.isFormField()){
                //将文件数据写入文件夹
                //获取文件名
                String name=fileItem.getName();
                //将文件写入磁盘
                fileItem.write(Paths.get(realPath,name));
                //删除内存中的临时文件
                fileItem.delete();
            }
        }
        return "upload";
    }

需要访问页面即upload.jsp。

SpringMVC文件上传_SpringMVC方式上传

SpringMVC使用框架提供的文件解析器对象，可以直接将请求体中的文件数据转为MultipartFile对象，从而省略原生上传中分析请求体的步骤。

• 在SpringMVC核心配置文件配置文件解析器

<!--        文件解析器对象-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.support.StandardServletMultipartResolver">
    </bean>

• 在web.xml中进行上传配置

<servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
        <multipart-config>
<!--            支持一次上传文件的总容量。单位：字节100M=100*1024*1024 -->
            <max-file-size>104857600</max-file-size>
<!--            支持一次请求上传文件的总容量-->
            <max-request-size>418018841</max-request-size>
<!--            文件最小容量-->
            <file-size-threshold>0</file-size-threshold>
        </multipart-config>
    </servlet>

• 创建JSP表单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="/c8/fileUpload2" method="post" enctype="multipart/form-data">
    <input type="file" name="file"/>
    <input type="submit" value="上传"/>
</form>
</body>
</html>

• 编写控制器接收上传请求

//MultipartFile参数名必须和JSP文件空间的name属性一致
    @RequestMapping("/fileUpload2")
    public String upload2(MultipartFile file,HttpServletRequest request) throws IOException{
        //创建文件夹，存放上传文件
        String realPath="E:\\springmvc\\mvc_demo1\\upload";
        File dir=new File(realPath);
        if(!dir.exists()){
            dir.mkdirs();
        }
        //将上传的数据写到文件夹的文件中
        //1.拿到上传的文件名
        String filename=file.getOriginalFilename();
        filename= UUID.randomUUID()+"_"+filename;
        //2.创建空文件
        File newFile=new File(dir,filename);
        //3.将数据写入空文件中
        file.transferTo(newFile);
        return "upload1";
    }

SpringMVC文件上传_上传多文件

SpringMVC支持一次性上传多个文件，写法如下：

• 创建JSP表单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="/c8/fileUpload3" method="post" enctype="multipart/form-data">
    用户名：<input name="username"/>
    文件1：<input type="file" name="files"/>
    文件2：<input type="file" name="files"/>
    <input type="submit" value="上传"/>
</form>
</body>
</html>

• 编写控制器接收上传请求

   //处理多文件上传，参数类型为MultipartFile数组，参数名和JSP文件控件的name属性一致
    @RequestMapping("/fileUpload3")
    public String upload3(MultipartFile files[],String username,HttpServletRequest request)throws Exception{
        System.out.println(username);
        //设置上传文件保存的文件夹
        String realPath="E:\\Springmvc\\mvc\\upload";
        File dir=new File(realPath);
        if(!dir.exists()){
            dir.mkdirs();
        }
        //遍历数组，将上传文件保存到文件夹
        for(MultipartFile file:files){
            String filename=file.getOriginalFilename();
            filename=UUID.randomUUID()+"_"+filename;
            File  newFile=new File(dir,filename);
            file.transferTo(newFile);
        }
        return "multifile";
    }

SpringMVC文件上传_异步上传

之前的上传方案，在上传成功后都会跳转页面。而在实际开发中，很多情况下上传后不进行跳转，而是进行页面的局部刷新，比如：上传头像成功后将头像显示在网页中。这时候就需要使用异步文件上传。

• 编写JSP页面，引入jQuery和jQuery表单上传工具jquery.form.js

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="/js/jquery-2.1.1.min.js"></script>
    <script src="/js/jquery.form.js"></script>
</head>
<body>
<h3>文件上传</h3>
<form id="ajaxForm" enctype="multipart/form-data">
    <input type="file" name="file"/>
<%--    按钮类型不能是submit,否则会刷新页面--%>
    <input type="button" value="上传头像" id="btn"/>
</form>
<%--上传头像后展示的位置--%>
<img src="/" width="100" id="img">
<script>
    $(function () {
        $("#btn").click(function () {
            $("#ajaxForm").ajaxSubmit({
                url:"/fileUpload4",
                type:"post",
                success:function (data) {
                    $("#img").attr("src",data);
                }
            })
        })
    })
</script>
</body>
</html>

• 编写控制器接收异步上传请求

 @RequestMapping("/fileUpload4")
    @ResponseBody
    public String upload4(MultipartFile file,HttpServletRequest request) throws Exception{
        //创建文件夹，存放上传文件
        String realPath=request.getServletContext().getRealPath("/upload");
        File dir=new File(realPath);
        if(!dir.exists()){
            dir.mkdirs();
        }
        //将上传的数据写到文件夹的文件中
        String filename=file.getOriginalFilename();
        filename=UUID.randomUUID()+"_"+filename;
        File newFile=new File(dir,filename);
        file.transferTo(newFile);
        //返回文件的路径
        return "/upload/"+filename;
    }

SpringMVC文件上传_跨服务器上传

由于文件占据磁盘空间较大，在实际开发中往往会将文件上传到其他服务器中，此时需要使用跨服务器上传文件。

• 解压tomcat作为图片服务器，在tomcat的webapps下创建upload目录作为文件上传目录。
• 修改tomcat的 conf/web.xml文件，支持跨服上传。

<servlet>  
  <init-param>    
    <param-name>readonly</param-name>   
    <param-value>false</param-value>  
  </init-param>
</servlet>

• 修改tomcat的 conf/server.xml文件，修改tomcat端口，修改完开启tomcat服务器

<Connector port="8081" protocol="HTTP/1.1"        connectionTimeout="20000" redirectPort="8443" />

• 编写JSP上传表单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>上传</title>
    <script src="/js/jquery-2.1.1.min.js"></script>
    <script src="/js/jquery.form.js"></script>
  </head>
  <body>
    <h3>文件上传</h3>
    <form id="ajaxForm" enctype="multipart/form-data" >
      <input type="file" name="file"/>
      <input type="button" value="上传头像" id="btn"/>
    </form>
    <img src="/" width="100" id="img">
    <script>
      $(function () {
        $("#btn").click(function () {
          $("#ajaxForm").ajaxSubmit({
            url:"/fileUpload5",
            type:"post",
            success:function (data) {
              $("#img").attr("src",data);
             }
           })
         })
       })
    </script>
  </body>
</html>

• 添加跨服上传依赖

<!-- 跨服上传 -->
<dependency>
  <groupId>com.sun.jersey</groupId>
  <artifactId>jersey-core</artifactId>
  <version>1.18.1</version>
</dependency>
<dependency>
  <groupId>com.sun.jersey</groupId>
  <artifactId>jersey-client</artifactId>
  <version>1.18.1</version>
</dependency>

• 创建控制器方法，该方法在接受到上传请求后将文件保存到其他服务器上。

@RequestMapping("/fileUpload5")
@ResponseBody
public String upload4(MultipartFile file) throws Exception {
  // 设置跨服上传的服务器路径
  String path = "http://localhost:8081/upload/";
  // 获取上传的文件名
  String filename = file.getOriginalFilename();
  filename = UUID.randomUUID()+"_"+filename;


  // 跨服上传：
  // 1.创建客户端对象
  Client client = Client.create();
  // 2.使用客户端对象连接图片服务器
  WebResource resource = client.resource(path + filename);
  //3.传输数据
  resource.put(file.getBytes());


  return path+filename;
}