关于spring-mvc:SpringMVC基础之一简单介绍及使用

32次阅读

共计 21420 个字符，预计需要花费 54 分钟才能阅读完成。

1、什么是 MVC？

​ MVC 是模型 (Model)、视图(View)、控制器(Controller) 的简写，是一种软件设计规范。就是将业务逻辑、数据、显示拆散的办法来组织代码。MVC 次要作用是 升高了视图与业务逻辑间的双向偶合。MVC 不是一种设计模式，MVC 是一种架构模式。当然不同的 MVC 存在差别。

​ Model（模型）：数据模型，提供要展现的数据，因而蕴含数据和行为，能够认为是畛域模型或 JavaBean 组件（蕴含数据和行为），不过当初个别都拆散开来：Value Object（数据 Dao）和 服务层（行为 Service）。也就是模型提供了模型数据查问和模型数据的状态更新等性能，包含数据和业务。

​ View（视图）：负责进行模型的展现，个别就是咱们见到的用户界面，客户想看到的货色。

​ Controller（控制器）：接管用户申请，委托给模型进行解决（状态扭转），处理完毕后把返回的模型数据返回给视图，由视图负责展现。也就是说控制器做了个调度员的工作。

​ 其实在最晚期的时候还有 model1 和 model2 的设计模型
最典型的 MVC 就是 JSP + servlet + javabean 的模式。

代码展现：

HelloServlet.java

package com.mashibing.controller;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class HelloServlet extends HttpServlet {protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {String method = request.getParameter("method");
        if (method.equals("add")){request.getSession().setAttribute("msg","add");
        }else if(method.equals("sub")){request.getSession().setAttribute("msg","sub");
        }
        request.getRequestDispatcher("index.jsp").forward(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {this.doPost(request, response);
    }
}

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>HelloServlet</servlet-name>
        <servlet-class>com.mashibing.controller.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/user</url-pattern>
    </servlet-mapping>
</web-app>

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  ${msg}
  </body>
</html>

输出网址：http://localhost:8080/servlet…

2、SpringMVC

1、SpringMVC 的介绍
Spring Web MVC is the original web framework built on the Servlet API and has been included in the Spring Framework from the very beginning. The formal name,“Spring Web MVC,”comes from the name of its source module (spring-webmvc), but it is more commonly known as“Spring MVC”.
Spring Web MVC 是构建在 Servlet API 上的原始 Web 框架，从一开始就蕴含在 Spring Framework 中。正式名称“Spring Web MVC,”来自其源模块 (spring-webmvc) 的名称，但它通常被称为“Spring MVC”。

​ 简而言之，springMVC 是 Spring 框架的一部分，是基于 java 实现的一个轻量级 web 框架。

​ 学习 SpringMVC 框架最外围的就是 DispatcherServlet 的设计，把握好 DispatcherServlet 是把握 SpringMVC 的外围要害。

2、SpringMVC 的长处

​ 1. 清晰的角色划分：控制器 (controller)、验证器(validator)、命令对象(command obect)、表单对象(form object)、模型对象(model object)、Servlet 散发器(DispatcherServlet)、处理器映射(handler mapping)、试图解析器(view resoler) 等等。每一个角色都能够由一个专门的对象来实现。

​ 2. 弱小而间接的配置形式：将框架类和应用程序类都能作为 JavaBean 配置，反对跨多个 context 的援用，例如，在 web 控制器中对业务对象和验证器 validator)的援用。
​ 3. 可适配、非侵入：能够依据不同的利用场景，抉择何事的控制器子类 (simple 型、command 型、from 型、wizard 型、multi-action 型或者自定义)，而不是一个繁多控制器(比方 Action/ActionForm) 继承。
​ 4. 可重用的业务代码：能够应用现有的业务对象作为命令或表单对象，而不须要去扩大某个特定框架的基类。
​ 5. 可定制的绑定 (binding) 和验证 (validation)：比方将类型不匹配作为利用级的验证谬误，这能够保障谬误的值。再比方本地化的日期和数字绑定等等。在其余某些框架中，你只能应用字符串表单对象，须要手动解析它并转换到业务对象。
​ 6. 可定制的 handler mapping 和 view resolution：Spring 提供从最简略的 URL 映射，到简单的、专用的定制策略。与某些 web MVC 框架强制开发人员应用繁多特定技术相比，Spring 显得更加灵便。
​ 7. 灵便的 model 转换：在 Springweb 框架中，应用基于 Map 的键 / 值对来达到轻易的与各种视图技术集成。
​ 8. 可定制的本地化和主题(theme) 解析：反对在 JSP 中可选择地应用 Spring 标签库、反对 JSTL、反对 Velocity(不须要额定的中间层)等等。
​ 9. 简略而弱小的 JSP 标签库 (Spring Tag Library)：反对包含诸如数据绑定和主题(theme) 之类的许多性能。他提供在标记方面的最大灵活性。
​ 10.JSP 表单标签库：在 Spring2.0 中引入的表单标签库，应用在 JSP 编写表单更加容易。
​ 11.Spring Bean 的生命周期：能够被限度在以后的 HTTp Request 或者 HTTp Session。精确的说，这并非 Spring MVC 框架自身个性，而应归属于 Spring MVC 应用的 WebApplicationContext 容器。

3、SpringMVC 的实现原理

​ springmvc 的 mvc 模式：

SpringMVC 的具体执行流程：

​ 当发动申请时被前置的控制器拦挡到申请，依据申请参数生成代理申请，找到申请对应的理论控制器，控制器解决申请，创立数据模型，拜访数据库，将模型响应给核心控制器，控制器应用模型与视图渲染视图后果，将后果返回给核心控制器，再将后果返回给请求者。

1、DispatcherServlet 示意前置控制器，是整个 SpringMVC 的控制中心。用户发出请求，DispatcherServlet 接管申请并拦挡申请。
2、HandlerMapping 为处理器映射。DispatcherServlet 调用 HandlerMapping,HandlerMapping 依据申请 url 查找 Handler。
3、返回处理器执行链，依据 url 查找控制器，并且将解析后的信息传递给 DispatcherServlet
4、HandlerAdapter 示意处理器适配器，其依照特定的规定去执行 Handler。
5、执行 handler 找到具体的处理器
6、Controller 将具体的执行信息返回给 HandlerAdapter, 如 ModelAndView。
7、HandlerAdapter 将视图逻辑名或模型传递给 DispatcherServlet。
8、DispatcherServlet 调用视图解析器(ViewResolver) 来解析 HandlerAdapter 传递的逻辑视图名。
9、视图解析器将解析的逻辑视图名传给 DispatcherServlet。
10、DispatcherServlet 依据视图解析器解析的视图后果，调用具体的视图，进行试图渲染
11、将响应数据返回给客户端

3、基于 XML 的 Hello_SpringMVC

1、增加 pom 依赖

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
    </dependencies>

2、编写 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">
    <!-- 配置 DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 关联 springmvc 的配置文件 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
    </servlet>
    <!-- 匹配 servlet 的申请，/ 标识匹配所有申请 -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!--/* 和 / 都是拦挡所有申请，/ 会拦挡的申请不蕴含 *.jsp, 而 /* 的范畴更大，还会拦挡 *.jsp 这些申请 -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

3、编写 springmvc 须要的 spring 配置文件，applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 解决映射器 -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>
    <!-- 处理器适配器 -->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>

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

    <bean id="/hello" class="com.mashibing.controller.HelloController"></bean>
</beans>

4、HelloController.java

package com.mashibing.controller;


import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

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

public class HelloController implements Controller {public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        // 创立模型和视图对象
        ModelAndView mv = new ModelAndView();
        // 将须要的值传递到 model 中
        mv.addObject("msg","helloSpringMVC");
        // 设置要跳转的视图，mv.setViewName("hello");
        return mv;
    }
}

5、创立 hello.jsp 页面

<%--
  Created by IntelliJ IDEA.
  User: root
  Date: 2020/3/5
  Time: 20:25
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${msg}
</body>
</html>

6、配置 tomcat，发送申请

http://localhost:8080/hello

4、基于注解的 Hello_SpringMVC

1、增加 pom 依赖

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
    </dependencies>

2、编写 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">
    <!-- 配置 DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--
        关联 springmvc 的配置文件
        -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
    </servlet>
    <!-- 匹配 servlet 的申请，/：标识匹配所有申请，然而不会 jsp 页面
    /*：拦挡所有申请，拦挡 jsp 页面
    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

3、编写 applicationContext.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">

    <!-- 主动扫描包，由 IOC 容器进行管制治理 -->
    <context:component-scan base-package="com.mashibing"></context:component-scan>
    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

4、编写 HelloController.java

package com.mashibing.controller;

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

@Controller
public class HelloController{
    /*
    * @RequestMapping 就是用来标识此办法用来解决什么申请，其中的 / 能够勾销
    * 勾销后默认也是从以后我的项目的根目录开始查找，个别在编写的时候看集体习惯
    * 同时，@RequestMapping 也能够用来加在类上，* */
    @RequestMapping("/hello")
    public String hello(Model model){model.addAttribute("msg","hello,SpringMVC");
        return "hello";
    }
}

5、编写 hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${msg}
</body>
</html>

6、输出申请 http://localhost:8080/hello

5、留神细节

1、springmvc_helloworld 运行流程：

​ 通过上述的代码，咱们可能总结出具体的运行流程：

​ 1、客户端发送申请 http://localhost:8080/hello

​ 2、由 tomcat 承受到对应的申请

​ 3、SpringMVC 的前端控制器 DispatcherServlet 接管到所有的申请

​ 4、查看申请地址和 @RequestMapping 注解的哪个匹配，来找到具体的类的解决办法

​ 5、前端控制器找到指标解决类和办法之后，执行指标办法

​ 6、办法执行实现之后会有一个返回值，SpringMVC 会将这个返回值用视图解析器进行解析拼接成残缺的页面地址

​ 7、DispatcherServlet 拿到页面地址之后，转发到具体的页面

2、springmvc 的配置文件

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">
    <!-- 配置 DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--
        关联 springmvc 的配置文件
        此配置文件的属性能够不增加，然而须要在 WEB-INF 的目录下创立 前端控制器名称 -servlet.xml 文件
        -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>
3、DispatcherServlet 的 url-pattern

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">
    <!-- 配置 DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--
        关联 springmvc 的配置文件
        此配置文件的属性能够不增加，然而须要在 WEB-INF 的目录下创立 前端控制器名称 -servlet.xml 文件
        -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
    </servlet>
    <!-- 匹配 servlet 的申请，/：标识匹配所有申请，然而不会 jsp 页面
    /*：拦挡所有申请，拦挡 jsp 页面

     然而须要留神的是，当配置成 index.html 的时候，会发现申请不到
     起因在于，tomcat 下也有一个 web.xml 文件，所有的我的项目下 web.xml 文件都须要继承此 web.xml
     在服务器的 web.xml 文件中有一个 DefaultServlet 用来解决动态资源，然而 url-pattern 是 /
     而咱们在本人的配置文件中如果增加了 url-pattern=/ 会笼罩父类中的 url-pattern，此时在申请的时候
     DispatcherServlet 会去 controller 中做匹配，找不到则间接报 404
     而在服务器的 web.xml 文件中蕴含了一个 JspServlet 的解决，所以不过拦挡 jsp 申请
    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>
4、@RequestMapping

​ @RequestMapping 用来匹配客户端发送的申请，能够在办法上应用，也能够在类上应用。

​ 办法：示意用来匹配要解决的申请

​ 类上：示意为以后类的所有办法的申请地址增加一个前置门路，拜访的时候必须要增加此门路

package com.mashibing.controller;

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

@Controller
@RequestMapping("/mashibing")
public class HelloController{

    /*
    * @RequestMapping 就是用来标识此办法用来解决什么申请，其中的 / 能够勾销
    * 勾销后默认也是从以后我的项目的根目录开始查找，个别在编写的时候看集体习惯
    * 同时，@RequestMapping 也能够用来加在类上，* */
    @RequestMapping("/hello")
    public String hello(Model model){model.addAttribute("msg","hello,SpringMVC");
        return "hello";
    }
}

​ 留神：在整个我的项目的不同办法上不能蕴含雷同的 @RequestMapping 值

​ 除此以外，@RequestMapping 注解还能够增加很多额定的属性值，用来准确匹配申请

package com.mashibing.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/mashibing")
public class HelloController{

    /*
    * @RequestMapping 就是用来标识此办法用来解决什么申请，其中的 / 能够勾销
    * 勾销后默认也是从以后我的项目的根目录开始查找，个别在编写的时候看集体习惯
    * 同时，@RequestMapping 也能够用来加在类上，* */
    @RequestMapping("/hello")
    public String hello(Model model){model.addAttribute("msg","hello,SpringMVC");
        return "hello";
    }

    /**
     * Request 的其余属性值
     *  value: 要匹配的申请
     *  method: 限度发送申请的形式：POST GET
     *  params: 示意申请要承受的参数, 如果定义了这个属性，那么发送的时候必须要增加参数
     *         params 有几种匹配规定
     *          1、间接写参数的名称，param1,param2
     *              params = {"username"}
     *          2、示意申请不能蕴含的参数，！param1
     *              params = {"!username"}
     *          3、示意申请中须要要蕴含的参数然而能够限度值 param1=values  param1!=value
     *              params = {"username=123","age"}
     *              params = {"username!=123","age"}
     *  headers: 填写申请头信息
     *          chrome：User-Agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36
     *          firefox:User-Agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:73.0) Gecko/20100101 Firefox/73.0
     *
     *  consumers: 只承受内容类型是哪种的申请，相当于指定 Content-Type
     *  produces: 返回的内容类型 Content-Type：text/html;charset=utf-8
     *
     * @return
     */
    @RequestMapping(value = "/hello2",method = RequestMethod.POST)
    public String hello2(){return "hello";}

    @RequestMapping(value = "/hello3",params = {"username!=123","age"})
    public String hello3(String username){System.out.println(username);
        return "hello";
    }

    @RequestMapping(value = "/hello4",headers = {"User-Agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:73.0) Gecko/20100101 Firefox/73.0"})
    public String hello4(){return "hello";}
}

​ @RequestMapping 还蕴含了很多简单的匹配性能，提供了通配符的反对：

package com.mashibing.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/mashibing")
public class HelloController{

    /*
    * @RequestMapping 就是用来标识此办法用来解决什么申请，其中的 / 能够勾销
    * 勾销后默认也是从以后我的项目的根目录开始查找，个别在编写的时候看集体习惯
    * 同时，@RequestMapping 也能够用来加在类上，* */
    @RequestMapping("/hello")
    public String hello(Model model){model.addAttribute("msg","hello,SpringMVC");
        return "hello";
    }

    /**
     * Request 的其余属性值
     *  value: 要匹配的申请
     *  method: 限度发送申请的形式：POST GET
     *  params: 示意申请要承受的参数, 如果定义了这个属性，那么发送的时候必须要增加参数
     *         params 有几种匹配规定
     *          1、间接写参数的名称，param1,param2
     *              params = {"username"}
     *          2、示意申请不能蕴含的参数，！param1
     *              params = {"!username"}
     *          3、示意申请中须要要蕴含的参数然而能够限度值 param1=values  param1!=value
     *              params = {"username=123","age"}
     *              params = {"username!=123","age"}
     *  headers: 填写申请头信息
     *          chrome：User-Agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36
     *          firefox:User-Agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:73.0) Gecko/20100101 Firefox/73.0
     *
     *  consumers: 只承受内容类型是哪种的申请，相当于指定 Content-Type
     *  produces: 返回的内容类型 Content-Type：text/html;charset=utf-8
     *
     * @return
     */
    @RequestMapping(value = "/hello2",method = RequestMethod.POST)
    public String hello2(){return "hello";}

    @RequestMapping(value = "/hello3",params = {"username!=123","age"})
    public String hello3(String username){System.out.println(username);
        return "hello";
    }

    @RequestMapping(value = "/hello4",headers = {"User-Agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:73.0) Gecko/20100101 Firefox/73.0"})
    public String hello4(){return "hello";}

    /**
     * @Request 蕴含三种含糊匹配的形式，别离是：*？：能代替任意一个字符
     *  *: 能代替任意多个字符和一层门路
     *  **：能代替多层门路
     * @return
     */
    @RequestMapping(value = "/**/h*llo?")
    public String hello5(){System.out.println("hello5");
        return "hello";
    }
}

6、@PathVariable

​ 如果须要在申请门路中的参数像作为参数应该怎么应用呢？能够应用 @PathVariable 注解，此注解就是提供了对占位符 URL 的反对，就是将 URL 中占位符参数绑定到控制器解决办法的参数中。

package com.mashibing.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/mashibing")
public class HelloController{@RequestMapping(value = "/pathVariable/{name}")
    public String pathVariable(@PathVariable("name") String name){System.out.println(name);
        return "hello";
    }
}

7、REST

​ REST 即表述性状态传递（英文：Representational State Transfer，简称 REST）是 Roy Fielding 博士在 2000 年他的博士论文中提出来的一种软件架构格调。它是一种针对网络应用的设计和开发方式，能够升高开发的复杂性，进步零碎的可伸缩性。

​ 在三种支流的 Web 服务实现计划中，因为 REST 模式的 Web 服务与简单的 SOAP 和 XML-RPC 比照来讲显著的更加简洁，越来越多的 web 服务开始采纳 REST 格调设计和实现。例如，Amazon.com 提供靠近 REST 格调的 Web 服务进行图书查找；雅虎提供的 Web 服务也是 REST 格调的。

​ REST, 翻译过去叫做体现层状态转化，是目前最风行的一个互联网软件架构，它架构清晰，符合标准，易于了解，扩大不便。

​ 体现层（Representation）：把资源具体出现进去的模式，因而叫做体现层。

​ 资源（Resource）：网络上的一个具体信息，文本，图片，音频，视频都能够称之为资源，如果想要拜访到互联网上的某一个资源，那么就必须要应用一个 URL 来唯一性的获取改资源，也能够这么说，URL 是每一个资源的惟一标识符。

​ 状态转化（State Transfer）：当客户端收回一个申请的时候，就代表客户端跟服务端的一次交互过程，HTTP 是一种无状态协定，即所有的状态都保留在服务器端，因而，客户端如果想要操作服务器，必须通过某些伎俩，让服务器的状态产生转化，而这种转化是建设在体现层的，这就是名字的由来（非人话）

​ 人话：咱们在获取资源的时候就是进行增删改查的操作，如果是原来的架构格调，须要发送四个申请，别离是：

​ 查问：localhost:8080/query?id=1

​ 减少：localhost:8080/insert

​ 删除：localhost:8080/delete?id=1

​ 更新：localhost:8080/update?id=1

​ 依照此形式发送申请的时候比拟麻烦，须要定义多种申请，而在 HTTP 协定中，有不同的发送申请的形式，别离是 GET、POST、PUT、DELETE 等，咱们如果能让不同的申请形式示意不同的申请类型就能够简化咱们的查问

​ GET：获取资源 /book/1

​ POST：新建资源 /book

​ PUT：更新资源 /book/1

​ DELETE：删除资源 /book/1

​ 所有看起来都十分美妙，然而大家须要留神了，咱们在发送申请的时候只能发送 post 或者 get，没有方法发送 put 和 delete 申请，那么应该如何解决呢？上面开始进入代码环节：

RestController.java

package com.mashibing.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Controller
public class RestController {@RequestMapping(value = "/user",method = RequestMethod.POST)
    public String add(){System.out.println("增加");
        return "success";
    }

    @RequestMapping(value = "/user/{id}",method = RequestMethod.DELETE)
    public String delete(@PathVariable("id") Integer id){System.out.println("删除："+id);
        return "success";
    }

    @RequestMapping(value = "/user/{id}",method = RequestMethod.PUT)
    public String update(@PathVariable("id") Integer id){System.out.println("更新："+id);
        return "success";
    }

    @RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
    public String query(@PathVariable("id") Integer id){System.out.println("查问："+id);
        return "success";
    }
}

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">
    <!-- 配置 DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--
        关联 springmvc 的配置文件：此配置文件的属性能够不增加，然而须要在 WEB-INF 的目录下创立 前端控制器名称 -servlet.xml 文件
        -->

        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
    </servlet>
    <!-- 匹配 servlet 的申请，/：标识匹配所有申请，然而不会 jsp 页面
    /*：拦挡所有申请，拦挡 jsp 页面

     然而须要留神的是，当配置成 index.html 的时候，会发现申请不到
     起因在于，tomcat 下也有一个 web.xml 文件，所有的我的项目下 web.xml 文件都须要继承此 web.xml
     在服务器的 web.xml 文件中有一个 DefaultServlet 用来解决动态资源，然而 url-pattern 是 /
     而咱们在本人的配置文件中如果增加了 url-pattern=/ 会笼罩父类中的 url-pattern，此时在申请的时候
     DispatcherServlet 会去 controller 中做匹配，找不到则间接报 404
     而在服务器的 web.xml 文件中蕴含了一个 JspServlet 的解决，所以不过拦挡 jsp 申请
    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <filter>
        <filter-name>hiddenFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>hiddenFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

rest.jsp

<%--
  Created by IntelliJ IDEA.
  User: root
  Date: 2020/3/6
  Time: 23:01
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="/user" method="post">
        <input type="submit" value="减少">
    </form>
    <form action="/user/1" method="post">
        <input name="_method" value="delete" type="hidden">
        <input type="submit" value="删除">
    </form>
    <form action="/user/1" method="post">
        <input name="_method" value="put" type="hidden">
        <input type="submit" value="批改">
    </form>
    <a href="/user/1"> 查问 </a><br/>
</body>
</html>

success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" isErrorPage="true" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
666
</body>
</html>

正文完
java
发表至： java
2021-04-20
 0
关于java:类的-生命周期-加载过程
关于java:框架
关于java:聊聊如何自定义parallelStream的线程池
互联网的寒冬下各大一线互联网公司还在用SpringBoot这是为什么