关于spring:SSMSpringMVC

16次阅读

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

1.1、什么是 MVC

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

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

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

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

1.2、Model1 时代

在 web 晚期的开发中，通常采纳的都是 Model1。
Model1 中，次要分为两层，视图层和模型层。JSP 实质就是一个 Servlet Model1 长处：架构简略，比拟适宜小型我的项目开发；Model1 毛病：JSP 职责不繁多，职责过重，不便于保护；

1.3、Model2 时代

Model2 把一个我的项目分成三局部，包含视图、管制、模型。

用户发申请
Servlet 接管申请数据，并调用对应的业务逻辑办法
业务处理完毕，返回更新后的数据给 servlet
servlet 转向到 JSP，由 JSP 来渲染页面
响应给前端更新后的页面

职责剖析：

Controller：控制器

获得表单数据
调用业务逻辑
转向指定的页面

Model：模型

业务逻辑
保留数据的状态

View：视图

显示页面

Model2 这样不仅进步的代码的复用率与我的项目的扩展性，且大大降低了我的项目的保护老本。Model 1 模式的实现比较简单，实用于疾速开发小规模我的项目，Model1 中 JSP 页面身兼 View 和 Controller 两种角色，将控制逻辑和体现逻辑混淆在一起，从而导致代码的重用性非常低，减少了利用的扩展性和保护的难度。Model2 打消了 Model1 的毛病。

1.4、回顾 Servlet

新建一个 Maven 工程当作父工程！pom 依赖！

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.9.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.2</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
</dependencies>

建设一个 Moudle：springmvc-01-servlet，增加 Web app 的反对！
导入 servlet 和 jsp 的 jar 依赖

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.2</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.9.RELEASE</version>
</dependency>

编写一个 Servlet 类，用来解决用户的申请

public class HelloServlet extends HttpServlet {

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 获得参数
String method = req.getParameter(“method”);
if (method.equals(“add”)){
req.getSession().setAttribute(“msg”,” 执行了 add 办法 ”);
}
if (method.equals(“delete”)){
req.getSession().setAttribute(“msg”,” 执行了 delete 办法 ”);
}
// 业务逻辑
// 视图跳转
req.getRequestDispatcher(“/WEB-INF/jsp/hello.jsp”).forward(req,resp);
}

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}

编写 Hello.jsp，在 WEB-INF 目录下新建一个 jsp 的文件夹，新建 hello.jsp，在 webapp 目录建设 form.sp hello.jsp

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

form.jsp

<%@ page contentType=”text/html;charset=UTF-8″ language=”java” %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action=”/hello” method=”get”>
<input type=”text” name=”method”/>
<input type=”submit”/>
</form>
</body>
</html>

在 web.xml 中注册 Servlet

<?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/j…d”
version=”4.0″>
<servlet>
<servlet-name>HelloServlet</servlet-name>
<servlet-class>com.zhang.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloServlet</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>

</web-app>

配置 Tomcat，并启动测试

localhost:8080/user?method=add
localhost:8080/user?method=delete
MVC 框架要做哪些事件

将 url 映射到 java 类或 java 类的办法 .
封装用户提交的数据 .
解决申请 – 调用相干的业务解决 – 封装响应数据 .
将响应的数据进行渲染 . jsp / html 等表示层数据 .

阐明：常见的服务器端 MVC 框架有：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF；常见前端 MVC 框架：vue、angularjs、react、backbone；由 MVC 演化出了另外一些模式如：MVP、MVVM 等等 ……

2.1、概述

Spring MVC 是 Spring Framework 的一部分，是基于 Java 实现 MVC 的轻量级 Web 框架。查看官网文档：https://docs.spring.io/spring-framework/docs/4.3.24.RELEASE/spring-framework-reference/ 咱们为什么要学习 SpringMVC 呢?

Spring MVC 的特点：

轻量级，简略易学
高效 , 基于申请响应的 MVC 框架
与 Spring 兼容性好，无缝联合
约定优于配置
功能强大：RESTful、数据验证、格式化、本地化、主题等
简洁灵便

Spring 的 web 框架围绕 DispatcherServlet [调度 Servlet] 设计。DispatcherServlet 的作用是将申请散发到不同的处理器。从 Spring 2.5 开始，应用 Java 5 或者以上版本的用户能够采纳基于注解模式进行开发，非常简洁；正因为 SpringMVC 好 , 简略 , 便捷 , 易学 , 天生和 Spring 无缝集成(应用 SpringIoC 和 Aop) , 应用约定优于配置 . 可能进行简略的 junit 测试 . 反对 Restful 格调 . 异样解决 , 本地化 , 国际化 , 数据验证 , 类型转换 , 拦截器等等 …… 所以咱们要学习 . 最重要的一点还是用的人多 , 应用的公司多

2.2、核心控制器

Spring 的 web 框架围绕 DispatcherServlet 设计。DispatcherServlet 的作用是将申请散发到不同的处理器。从 Spring 2.5 开始，应用 Java 5 或者以上版本的用户能够采纳基于注解的 controller 申明形式。

Spring MVC 框架像许多其余 MVC 框架一样, 以申请为驱动 , 围绕一个核心 Servlet 分派申请及提供其余性能，DispatcherServlet 是一个理论的 Servlet (它继承自 HttpServlet 基类)。 SpringMVC 的原理如下图所示： 当发动申请时被前置的控制器拦挡到申请，依据申请参数生成代理申请，找到申请对应的理论控制器，控制器解决申请，创立数据模型，拜访数据库，将模型响应给核心控制器，控制器应用模型与视图渲染视图后果，将后果返回给核心控制器，再将后果返回给请求者。 SpringMVC 执行原理：

图为 SpringMVC 的一个较完整的流程图，实线示意 SpringMVC 框架提供的技术，不须要开发者实现，虚线示意须要开发者实现。简要剖析执行流程：

DispatcherServlet 示意前置控制器，是整个 SpringMVC 的控制中心。用户发出请求，DispatcherServlet 接管申请并拦挡申请。咱们假如申请的 url 为 : http://localhost:8080/SpringMVC/hello 如上 url 拆分成三局部： http://localhost:8080 服务器域名 SpringMVC 部署在服务器上的 web 站点 hello 示意控制器通过剖析，如上 url 示意为：申请位于服务器 localhost:8080 上的 SpringMVC 站点的 hello 控制器。
HandlerMapping 为处理器映射。DispatcherServlet 调用 HandlerMapping,HandlerMapping 依据申请 url 查找 Handler。
HandlerExecution 示意具体的 Handler, 其次要作用是依据 url 查找控制器，如上 url 被查找控制器为：hello。
HandlerExecution 将解析后的信息传递给 DispatcherServlet, 如解析控制器映射等。
HandlerAdapter 示意处理器适配器，其依照特定的规定去执行 Handler。
Handler 让具体的 Controller 执行。
Controller 将具体的执行信息返回给 HandlerAdapter, 如 ModelAndView。
HandlerAdapter 将视图逻辑名或模型传递给 DispatcherServlet。
DispatcherServlet 调用视图解析器 (ViewResolver) 来解析 HandlerAdapter 传递的逻辑视图名。
视图解析器将解析的逻辑视图名传给 DispatcherServlet。
DispatcherServlet 依据视图解析器解析的视图后果，调用具体的视图。
最终视图出现给用户。在这里先听一遍原理，不了解没有关系，咱们马上来写一个对应的代码实现大家就明确了，如果不明确，那就写 10 遍，没有笨人，只有懒人！

3.1、配置版

新建一个 Moudle，springmvc-02-hello，增加 web 的反对！
确定导入了 SpringMVC 的依赖！
配置 web.xml，注册 DispatcherServlet

<?xml version=”1.0″ encoding=”UTF-8″?>
<web-app xmlns=”http://xmlns.jcp.org/xml/ns/javaee”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/j…d”
version=”4.0″>
<!–1. 注册 DispatcherServlet–>
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!– 关联一个 springmvc 的配置文件:【servlet-name】-servlet.xml–>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc-servlet.xml</param-value>
</init-param>
<!– 启动级别 -1–>
<load-on-startup>1</load-on-startup>
</servlet>
<!–/ 匹配所有的申请；（不包含.jsp）–>
<!–/* 匹配所有的申请；（包含.jsp）–>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

</web-app>

编写 SpringMVC 的配置文件！名称：springmvc-servlet.xml：[servletname]-servlet.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.or…d”>

</beans>

. 增加解决映射器

增加处理器适配器

增加视图解析器

<!– 视图解析器:DispatcherServlet 给他的 ModelAndView
1. 获取了 ModelAndView 中的数据
2. 解析 ModelAndView 中的视图名字
3. 拼接名字，找到对应的视图
4. 将数据渲染到视图上啊 –>
<bean
class=”org.springframework.web.servlet.view.InternalResourceViewResolver”
id=”InternalResourceViewResolver”>
<!– 前缀 –>
<property name=”prefix” value=”/WEB-INF/jsp/”/>
<!– 后缀 –>
<property name=”suffix” value=”.jsp”/>
</bean>

编写咱们要操作业务 Controller，要么实现 Controller 接口，要么减少注解；须要返回一个 ModelAndView，装数据，封视图；

package com.zhang.servlet.controller;

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

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

// 留神：这里咱们先导入 Controller 接口
public class HelloController implements Controller {
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
//ModelAndView 模型和视图
ModelAndView mv = new ModelAndView();
// 封装对象，放在 ModelAndView 中。Model
mv.addObject(“msg”,”HelloSpringMVC!”);
// 封装要跳转的视图，放在 ModelAndView 中
mv.setViewName(“hello”); //: /WEB-INF/jsp/hello.jsp
return mv;
}
}

将本人的类交给 SpringIOC 容器，注册 bean

<!–Handler–>
<bean id=”/hello” class=”com.zhang.controller.HelloController”/>

写要跳转的 jsp 页面，显示 ModelandView 寄存的数据，以及咱们的失常页面；

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

配置 Tomcat 启动测试！可能遇到的问题：拜访呈现 404，排查步骤：
查看控制台输入，看一下是不是短少了什么 jar 包。
如果 jar 包存在，显示无奈输入，就在 IDEA 的我的项目公布中，增加 lib 依赖！
重启 Tomcat 即可解决！小结：看这个预计大部分人都能了解其中的原理了，然而咱们理论开发才不会这么写，不然就疯了，还学这个玩意干嘛！咱们来看个注解版实现，这才是 SpringMVC 的精华，到底有如许简略，看这个图就晓得了。

3.2、注解版

新建一个 Moudle，springmvc-03-hello-annotation。增加 web 反对！建设包构造 com.kuang.controller
因为 Maven 可能存在资源过滤的问题，咱们将配置欠缺

<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>*/.properties</include>
<include>*/.xml</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>*/.properties</include>
<include>*/.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>

在 pom.xml 文件引入相干的依赖：次要有 Spring 框架外围库、Spring MVC、servlet , JSTL 等。咱们在父依赖中曾经引入了！
配置 web.xml 留神点：留神 web.xml 版本问题，要最新版！注册 DispatcherServlet 关联 SpringMVC 的配置文件启动级别为 1 映射门路为 /【不要用 /*，会 404】

<?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/j…d”
version=”4.0″>
<!–1. 注册 servlet–>
<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:springmvc-servlet.xml</param-value>
</init-param>
<!– 启动程序，数字越小，启动越早 –>
<load-on-startup>1</load-on-startup>
</servlet>
<!– 所有申请都会被 springmvc 拦挡 –>
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>

/ 和 / 的区别： < url-pattern > / </ url-pattern > 不会匹配到.jsp，只针对咱们编写的申请；即：.jsp 不会进入 spring 的 DispatcherServlet 类。< url-pattern > / </ url-pattern > 会匹配 *.jsp，会呈现返回 jsp 视图时再次进入 spring 的 DispatcherServlet 类，导致找不到对应的 controller 所以报 404 错。

增加 Spring MVC 配置文件

让 IOC 的注解失效
动态资源过滤：HTML . JS . CSS . 图片，视频 …..
MVC 的注解驱动
配置视图解析器在 resource 目录下增加 springmvc-servlet.xml 配置文件，配置的模式与 Spring 容器配置根本相似，为了反对基于注解的 IOC，设置了主动扫描包的性能，具体配置信息如下：

<?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.or…
http://www.springframework.or…
https://www.springframework.o…
http://www.springframework.or…
https://www.springframework.o…d”>
<!– 主动扫描包，让指定包下的注解失效, 由 IOC 容器对立治理 –>
<context:component-scan base-package=”com.zhang.controller”/>
<!– 让 Spring MVC 不解决动态资源 –>
<mvc:default-servlet-handler />
<!–
反对 mvc 注解驱动
在 spring 中个别采纳 @RequestMapping 注解来实现映射关系
要想使 @RequestMapping 注解失效
必须向上下文中注册 DefaultAnnotationHandlerMapping
和一个 AnnotationMethodHandlerAdapter 实例
这两个实例别离在类级别和办法级别解决。
而 annotation-driven 配置帮忙咱们主动实现上述两个实例的注入。
–>
<mvc:annotation-driven />
<!– 视图解析器 –>
<bean
class=”org.springframework.web.servlet.view.InternalResourceViewResolver
“
id=”internalResourceViewResolver”>
<!– 前缀 –>
<property name=”prefix” value=”/WEB-INF/jsp/” />
<!– 后缀 –>
<property name=”suffix” value=”.jsp” />
</bean>
</beans>

在视图解析器中咱们把所有的视图都寄存在 /WEB-INF/ 目录下，这样能够保障视图平安，因为这个目录下的文件，客户端不能间接拜访。

创立 Controller 编写一个 Java 管制类：com.kuang.controller.HelloController , 留神编码标准

package com.zhang.controller;

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

@Controller
@RequestMapping(“/HelloController”)
public class HelloController {
// 实在拜访地址 : 我的项目名 /HelloController/hello
@RequestMapping(“/hello”)
public String sayHello(Model model){
// 向模型中增加属性 msg 与值，能够在 JSP 页面中取出并渲染
model.addAttribute(“msg”,”hello,SpringMVC”);
//web-inf/jsp/hello.jsp
return “hello”;
}
}

@Controller 是为了让 Spring IOC 容器初始化时主动扫描到；
@RequestMapping 是为了映射申请门路，这里因为类与办法上都有映射所以拜访时应该是 /HelloController/hello；
办法中申明 Model 类型的参数是为了把 Action 中的数据带到视图中；
办法返回的后果是视图的名称 hello，加上配置文件中的前后缀变成 WEB-INF/jsp/hello.jsp

创立视图层在 WEB-INF/ jsp 目录中创立 hello.jsp，视图能够间接取出并展现从 Controller 带回的信息; 能够通过 EL 示意取出 Model 中寄存的值，或者对象；
配置 Tomcat 运行配置 Tomcat，开启服务器，拜访对应的申请门路！

3.3、小结

实现步骤其实十分的简略：

新建一个 web 我的项目
导入相干 jar 包
编写 web.xml , 注册 DispatcherServlet
编写 springmvc 配置文件
接下来就是去创立对应的管制类 , controller
最初欠缺前端视图和 controller 之间的对应
测试运行调试. 应用 springMVC 必须配置的三大件：处理器映射器、处理器适配器、视图解析器 通常，咱们只须要手动配置视图解析器，而处理器映射器和处理器适配器只须要开启注解驱动即可，而省去了大段的 xml 配置。

4.1、应用注解 @Controller

@Controller 注解类型用于申明 Spring 类的实例是一个控制器（在讲 IOC 时还提到了另外 3 个注解）；
Spring 能够应用扫描机制来找到应用程序中所有基于注解的控制器类，为了保障 Spring 能找到你的控制器，须要在配置文件中申明组件扫描。

<!– 主动扫描指定的包，上面所有注解类交给 IOC 容器治理 –>
<context:component-scan base-package=”com.kuang.controller”/>

能够发现，咱们的两个申请都能够指向一个视图，然而页面后果的后果是不一样的，从这里能够看出视图是被复用的，而控制器与视图之间是弱偶合关系。

4.2、RequestMapping

@RequestMapping

@RequestMapping 注解用于映射 url 到控制器类或一个特定的处理程序办法。可用于类或办法上。
用于类上，示意类中的所有响应申请的办法都是以该地址作为父门路。
为了测试论断更加精确，咱们能够加上一个我的项目名测试 myweb
只注解在办法下面

@Controller
public class TestController {
@RequestMapping(“/h1”)
public String test(){
return “test”;
}
}

拜访门路：http://localhost:8080 / 我的项目名 / h1

同时注解类与办法

@Controller
@RequestMapping(“/admin”)
public class TestController {
@RequestMapping(“/h1”)
public String test(){
return “test”;
}
}

拜访门路：http://localhost:8080 / 我的项目名 / admin /h1 , 须要先指定类的门路再指定办法的门路；

4.3、RestFul 格调

概念 Restful 就是一个资源定位及资源操作的格调。不是规范也不是协定，只是一种格调。基于这个格调设计的软件能够更简洁，更有档次，更易于实现缓存等机制。 性能资源： 互联网所有的事物都能够被形象为资源资源操作：应用 POST、DELETE、PUT、GET，应用不同办法对资源进行操作。别离对应增加、删除、批改、查问。传统形式操作资源： 通过不同的参数来实现不同的成果！办法繁多，post 和 get http://127.0.0.1/item/queryItem.action?id=1 查问,GET http://127.0.0.1/item/saveItem.action 新增,POST http://127.0.0.1/item/updateItem.action 更新,POST http://127.0.0.1/item/deleteItem.acti on?id=1 删除,GET 或 POST 应用 RESTful 操作资源： 能够通过不同的申请形式来实现不同的成果！如下：申请地址一样，然而性能能够不同！http://127.0.0.1/item/1 查问,GET http://127.0.0.1/item 新增,POST http://127.0.0.1/item 更新,PUT http://127.0.0.1/item/1 删除,DELETE

原来形式：RestfulController

@Controller
public class RestfulController {
@RequestMapping(“/add”)
public String test(int a, int b, Model model){
int res=a+b;
model.addAttribute(“msg”,” 后果为：”+res);
return “hello”;
}
}

Restful 格调：RestfulController

@Controller
public class RestfulController {
@RequestMapping(“/add/{a}/{b}”)
public String test(@PathVariable int a,@PathVariable int b, Model model){
int res=a+b;
model.addAttribute(“msg”,” 后果为：”+res);
return “hello”;
}
}

设置不同的申请形式实现 url 的复用：

@Controller
public class RestfulController {
@PostMapping(“/add/{a}/{b}”)
public String test(@PathVariable int a,@PathVariable int b, Model model){
int res=a+b;
model.addAttribute(“msg”,” 后果为：”+res);
return “hello”;
}
@GetMapping(“/add/{a}/{b}”)
public String test1(@PathVariable int a,@PathVariable int b, Model model){
int res=a+b;
model.addAttribute(“msg”,” 后果为：”+res);
return “hello”;
}
}

小结： Spring MVC 的 @RequestMapping 注解可能解决 HTTP 申请的办法, 比方 GET, PUT, POST, DELETE 以及 PATCH。所有的地址栏申请默认都会是 HTTP GET 类型的。 办法级别的注解变体有如下几个：组合注解

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

@GetMapping 是一个组合注解它所表演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。平时应用的会

正文完

java

发表至： java

2021-03-15

0

关于java:Java21的新特性

关于java:25-合并两个排序的链表双指针递归

关于java:Java-16中的67个新功能

关于java:为什么MySQL不推荐使用uuid或者雪花id作为主键

关于architecture:聊聊Ports-and-Adapters-architecture