1- 三层架构和MVC
1.1 三层架构
#1.企业项目架构中,有两种常见的架构形式:
1.1.C/S架构,即客户端/服务器
1.2.B/S架构,即浏览器/服务器
#2.目前在J2EE项目中,几乎都基于B/S架构
#3.在B/S架构中,系统标准的三层结构包括:
表现层(web):与请求和响应相关
业务层(service):与业务需求相关
持久层(dao):与操作访问数据库相关
![](https://guardwhy.oss-cn-beijing.aliyuncs.com/img/javaSE/se1/20-javase.png)
1.2 MVC模型
#1.MVC是一种表现层的设计模型。它的全名是Model(模型)-View(视图)-Control(控制器):
Model(模型):模型指的是数据模型,与封装数据相关的都是模型。比如pojo、vo
View(视图):视图指的是展示数据,与页面相关的都是视图。比如html、jsp
Control(控制器):控制器指的是用户交互,接收用户请求,响应用户。比如servlet
#2. 作用
MVC主要作用是降低了视图与业务逻辑间的双向偶合,MVC不是一种设计模式.
MVC是一种架构模式。当然不同的MVC存在差异。
最典型的MVC就是JSP + servlet + javabean的模式。
1.3 创建Servlet工程
1.3.1 项目目录
1.3.2 父工程相关依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.guardwhy</groupId>
<artifactId>springMVC</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<modules>
<module>01_servlet</module>
</modules>
<!-- 集中定义依赖版本号 -->
<properties>
<!--spring版本-->
<spring.version>5.2.9.RELEASE</spring.version>
</properties>
<!--引入依赖-->
<dependencies>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<!--JSP-->
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.2</version>
</dependency>
<!--servlet-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
<!--jsp-jstl-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!--测试依赖-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
</project>
1.3.3 子工程依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>springMVC</artifactId>
<groupId>cn.guardwhy</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>01_servlet</artifactId>
</project>
1.3.4 Servlet类
package cn.guardwhy.servlet;
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 {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 1. 取得参数
String method = req.getParameter("method");
if(method.equals("add")){
req.getSession().setAttribute("msg", "执行了add方法");
}
if(method.equals("delete")){
req.getSession().setAttribute("msg","执行了delete方法");
}
// 2.视图跳转
req.getRequestDispatcher("/WEB-INF/jsp/hello.jsp").forward(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
1.3.5 编写Hello.jsp文件
在WEB-INF目录下新建一个jsp的文件夹,新建hello.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>guardwhy</title>
</head>
<body>
${msg}
</body>
</html>
1.3.6 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-->
<servlet-name>HelloServlet</servlet-name>
<servlet-class>cn.guardwhy.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloServlet</servlet-name>
<url-pattern>/user</url-pattern>
</servlet-mapping>
</web-app>
2- spring MVC
2.1 概述
Spring MVC是 Spring体系的轻量级Web MVC框架。
Spring MVC的核心Controller控制器,用于处理请求,产生响应。
Spring MVC基于Spring IOC容器运行,所有对象都被IOC管理。
![](https://guardwhy.oss-cn-beijing.aliyuncs.com/img/javaEE/SpringMVC/Test1/2-springmvc.png)
2.2 在三层架构中的位置
2.3 springmvc优点
序号 | 优点 | 描述 |
---|---|---|
1 | 清晰的角色划分 | 前端控制器( DispatcherServlet) 、处理器映射器( HandlerMapping) 、处理器适配器( HandlerAdapter)、 视图解析器( ViewResolver)、 后端控制器( Controller) |
2 | 与Spring 框架无缝集成 | 这是其它web框架不具备的 |
3 | 可扩展性好 | 可以很容易扩展,虽然几乎不需要 |
4 | 单元测试方便 | 利用 Spring 提供的 Mock 对象能够非常简单的进行 Web 层单元测试 |
5. | 功能强大 | RESTful、数据验证、格式化、本地化、主题等 |
6 | jsp标签库 | 强大的 JSP 标签库,使 JSP 编写更容易 |
2.4 spring MVC 和Struts2比较
# 共同点:
它们都是表现层框架,都是基于 MVC 模型编写的。
它们的底层都离不开原始 ServletAPI。
它们处理请求的机制都是一个核心控制器。
# 区别:
Spring MVC 的入口是 Servlet, 而 Struts2是Filter。
Spring MVC 是基于方法设计的,而 Struts2 是基于类,Struts2 每次执行都会创建一个动作类。所以Spring MVC 会稍微比Struts2快些。
Spring MVC 使用更加简洁,同时还支持 JSR303, 处理 ajax 的请求更方便。
Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些,但执行效率并没有比JSTL提升,尤其是 struts2 的表单标签,远没有html 执行效率高。
3- Spring MVC 执行原理
3.1 前端控制器
Spring的web框架围绕**DispatcherServlet**设计。 DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始,使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。
Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能,DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。
3.2 SpringMVC的原理
当发起请求时被前置的控制器拦截到请求,根据请求参数生成代理请求,找到请求对应的实际控制
器,控制器处理请求,创建数据模型,访问数据库,将模型响应给中心控制器,控制器使用模型与视图
渲染视图结果,将结果返回给中心控制器,再将结果返回给请求者。
3.3 SpringMVC执行原理
实线表示SpringMVC框架提供的技术,不需要开发者实现,虚线表示需要开发者实现。
3.4 执行流程
1、DispatcherServlet表示前置控制器,是整个SpringMVC的控制中心。用户发出请求,DispatcherServlet接收请求并拦截请求。
假设请求的url为 : http://localhost:8080/SpringMVC/success
如上url拆分成三部分:http://localhost:8080服务器域名,SpringMVC部署在服务器上的web站点。success表示控制器.
通过分析,如上url表示为:请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。
2、HandlerMapping为处理器映射。
DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。
3、HandlerExecutionChain表示具体的Handler(处理器)
其主要作用是根据url查找控制器,如上url被查找控制器为:success。
4、HandlerExecutionChain将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
5、HandlerAdapter表示处理器适配器,其按照特定的规则去执行Handler。
6、Handler让具体的Controller执行。
7、Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
8、HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
9、DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
10、视图解析器将解析的逻辑视图名传给DispatcherServlet。
11、DispatcherServlet根据视图解析器解析的视图结果,调用具体的视图。
12、最终视图呈现给用户。
4- 入门案例
4.1 项目目录(原理版)
![](https://guardwhy.oss-cn-beijing.aliyuncs.com/img/javaEE/SpringMVC/Test1/6-springMVC.png)
4.1.1 相关依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>SpringMVC</artifactId>
<groupId>cn.guardwhy</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>01_springMVC_servlet</artifactId>
</project>
4.1.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">
<!--1.注册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:springmvc.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>
4.1.3 操作业务Controller
package cn.guardwhy.controller;
/**
* springMVC入门原理案例: 需要返回一个ModelAndView,装数据,封视图
*/
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 {
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
//1. 创建ModelAndView模型和视图
ModelAndView mv = new ModelAndView();
//2. 封装对象,放在ModelAndView中。
mv.addObject("msg","HelloSpringMVC!");
//3.封装要跳转的视图,放在ModelAndView中.
mv.setViewName("success"); // /WEB-INF/jsp/success.jsp
return mv;
}
}
4.1.4 编写SpringMVC的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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 class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
<!--视图解析器:DispatcherServlet给他的ModelAndView
1、获取ModelAndView的数据
2.解析ModelAndView的视图名字
3、拼接视图名字,找到对应的视图 /WEB-INF/jsp/success.jsp
4.将数据渲染到这个视图上。
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
<!--前缀-->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!--后缀-->
<property name="suffix" value=".jsp"/>
</bean>
<!--注册bean,将类提交给springIOC容器来管理-->
<bean id="/success" class="cn.guardwhy.controller.HelloController"/>
</beans>
4.1.5 跳转的jsp页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>guardwhy</title>
</head>
<body>
${msg}
</body>
</html>
4.1.6 执行结果
4.1.7 出现错误
访问出现404,项目模块中缺少相关依赖
4.2 项目目录(注解版)
![](https://guardwhy.oss-cn-beijing.aliyuncs.com/img/javaEE/SpringMVC/Test1/13-springMVC.png)
4.2.1 添加父工程相关依赖
<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>
4.2.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">
<!--1.注册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:springmvc.xml</param-value>
</init-param>
<!--启动级别-1-->
<load-on-startup>1</load-on-startup>
</servlet>
<!--所有的请求都会被springmvc拦截-->
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
4.2.3 操作业务Controller
- @Controller是为了让Spring IOC容器初始化时自动扫描到。
- @RequestMapping是为了映射请求路径,这里因为类与方法上都有映射所以访问时应该是/HelloController/success。
- 方法中声明Model类型的参数是为了把Action中的数据带到视图中。
- 方法返回的结果是视图的名称hello,加上配置文件中的前后缀变成WEB-INF/jsp/success.jsp。
package cn.guardwhy.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* springMVC入门原理案例(注解版本)
*/
@Controller
@RequestMapping("/HelloController")
public class HelloController {
//真实访问地址 : 项目名/HelloController/success
@RequestMapping("/success")
public String sayHello(Model model){
// 1.向模型中添加属性,可以在页面中取出渲染
model.addAttribute("msg", "hello, SpringMVC");
//2. web-inf/jsp/success.jsp
return "success";
}
}
4.2.4 SpringMVC的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!--1.自动扫描包,让指定包下的注解生效,由IOC容器统一管理-->
<context:component-scan base-package="cn.guardwhy.controller"/>
<!--2.让Spring MVC处理静态资源-->
<mvc:default-servlet-handler/>
<!--3.支持mvc注解驱动
在spring中一般采用@RequestMapping注解来完成映射关系,要想使@RequestMapping注解生效必须向上下文中注册DefaultAnnotationHandlerMapping
和一个AnnotationMethodHandlerAdapter实例这两个实例分别在类级别和方法级别处理。
而annotation-driven配置帮助我们自动完成上述两个实例的注入。
-->
<mvc:annotation-driven/>
<!--4.视图解析器 -->
<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.2.5 创建视图层
在WEB-INF/ jsp目录中创建hello.jsp,视图可以直接取出并展示从Controller带回的信息。可以通过EL表示取出Model中存放的值,或者对象。
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>springMVC</title>
</head>
<body>
${msg}
</body>
</html>
4.2.6 执行结果
4.3 控制器Controller
- 控制器复杂提供访问应用程序的行为,通常通过接口定义或注解定义两种方法实现。
- 控制器负责解析用户的请求并将其转换为一个模型。
- 在Spring MVC中一个控制器类可以包含多个方法,在Spring MVC中,对于Controller的配置方式有很多种
4.3.1 项目目录
4.3.2 操作业务Controller
package cn.guardwhy.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 TestController1 implements Controller {
@Override
public ModelAndView handleRequest(HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse) throws Exception {
// 1.返回一个模型视图对象
ModelAndView mv = new ModelAndView();
// 2.封装对象,放在ModelAndView中。
mv.addObject("msg", "TestController1");
// 3. 封装跳转的视图
mv.setViewName("test");
return mv;
}
}
4.3.3 SpringMVC的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--注册bean,将类提交给springIOC容器来管理-->
<bean id="/test1" class="cn.guardwhy.controller.TestController1"/>
<!--4.视图解析器 -->
<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.3.4 创建视图层
在WEB-INF/ jsp目录中创建hello.jsp,视图可以直接取出并展示从Controller带回的信息。可以通过EL表示取出Model中存放的值,或者对象。
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>guardwhy</title>
</head>
<body>
${msg}
</body>
</html>
4.3.5 执行结果
4.3.6 注意
- 实现接口Controller定义控制器是较老的办法。
- 缺点是:一个控制器中只有一个方法,如果要多个方法则需要定义多个Controller。定义的方式比较麻烦。
4.4 使用注解@Controller
4.4.1 操作业务Controller
package cn.guardwhy.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* 注解形式
*/
@Controller
public class TestController2 {
// 映射访问路径
@RequestMapping("/test2")
public String Test(Model model){
// 自动实例化一个Model对象用于向视图中传值
model.addAttribute("msg", "ControllerTest2");
return "test";
}
}
4.4.2 SpringMVC的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!-- 自动扫描指定的包,下面所有注解类交给IOC容器管理 -->
<context:component-scan base-package="cn.guardwhy.controller"/>
<!--4.视图解析器 -->
<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.4.3 执行结果
4.5 RequestMapping
4.5.1 @RequestMapping
@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径。为了测试结论更加准确
4.5.2 注解在方法上
package cn.guardwhy.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class TestController3 {
@RequestMapping("/test3")
public String Test3(Model model){
// 自动实例化一个Model对象用于向视图中传值
model.addAttribute("msg", "ControllerTest3");
return "test";
}
}
4.5.3 同时注解类与方法
package cn.guardwhy.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping("/guardwhy")
public class TestController3 {
@RequestMapping("/test3")
public String Test3(Model model){
// 自动实例化一个Model对象用于向视图中传值
model.addAttribute("msg", "ControllerTest3");
return "test";
}
}
4.6 RestFul风格
4.6.1 项目目录
4.6.2 概念
Restful就是一个资源定位及资源操作的风格。不是标准也不是协议,只是一种风格。基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制。
4.6.3 作用
资源:互联网所有的事物都可以被抽象为资源
资源操作:使用POST、DELETE、PUT、GET,使用不同方法对资源进行操作。分别对应 添加、 删除、修改、查询。
4.6.4 控制器(Controller)
package cn.guardwhy.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
/**
* RestFul风格入门案例
*/
@Controller
public class RestFulController {
// 1.访问映射路径
@RequestMapping(value = "/commit/{a}/{b}", method = RequestMethod.GET)
public String test1(@PathVariable int a, @PathVariable String b, Model model){
// 返回结果集
String res = a + b;
model.addAttribute("msg", "结果返回值1:" + res);
return "success";
}
// post方法
@PostMapping("/commit/{a}/{b}")
public String test2(@PathVariable int a, @PathVariable String b, Model model){
// 返回结果集
String res = a + b;
model.addAttribute("msg", "结果返回值2:" + res);
return "success";
}
}
4.6.5 视图层
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>post提交</title>
</head>
<body>
<form action="commit/1/6" method="post">
<input type="submit" value="提交">
</form>
</body>
</html>
4.6.6 执行结果
![](https://guardwhy.oss-cn-beijing.aliyuncs.com/img/javaEE/SpringMVC/Test2/2-springMVC.png)
4.6.7 总结
Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE。
所有的地址栏请求默认都会是 HTTP GET 类型的。
组合注解:
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping