SpringMVC
1.回顾MVC
1.什么是MVC
MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。
是将业务逻辑、数据、显示分离的方法来组织代码。
MVC主要作用是降低了视图与业务逻辑间的双向偶合。
MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。
Model**（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或
JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao） 和 服务层
（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。**
View（视图）：负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。
Controller（控制器）：接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型
数据返回给视图，由视图负责展示。 也就是说控制器做了个调度员的工作。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-exB9Ul6G-1629686073466)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210710154733525.png)]
2.Mode1时代
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OcHgUbAX-1629686073468)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210710154816604.png)]
3.Model2时代
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kToAmddE-1629686073470)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210710154859110.png)]
职责分析
Controller**：控制器**
-
取得表单数据
-
调用业务逻辑
-
转向指定的页面
Model**：模型**
-
业务逻辑
-
保存数据的状态
View**：视图**
- 显示页面
1
2
3
4
5Model2这样不仅提高的代码的复用率与项目的扩展性，且大大降低了项目的维护成本。Model 1模式的 实现比较简单，适用于快速开发小规模项目，Model1中JSP页面身兼View和Controller两种角色，将控 制逻辑和表现逻辑混杂在一起，从而导致代码的重用性非常低，增加了应用的扩展性和维护的难度。 Model2消除了Model1的缺点。
4.Servlet回顾
1.新建maven工程
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ufGXBJij-1629686073472)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210710160457668.png)]
2.导入项目公共依赖
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33<dependencies> <!-- junit测试依赖--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency> <!-- springmvc依赖--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.1.9.RELEASE</version> </dependency> <!-- servlet依赖--> <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version> </dependency> <!-- jsp依赖--> <dependency> <groupId>javax.servlet.jsp</groupId> <artifactId>jsp-api</artifactId> <version>2.2</version> </dependency> <!-- servlet中的jstl依赖--> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> <version>1.2</version> </dependency> </dependencies>
3.建立一个Moudle：springmvc-01-servlet ， 添加Web app的支持
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1MeI7Z3K-1629686073474)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210710160902239.png)]
4.导入servlet 和 jsp 的 jar 依赖
1
2
3
4
5
6
7
8
9
10
11
12
13
14<!-- 导入子项目本身的依赖--> <dependencies> <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> </dependencies>
5.编写一个Servlet类，用来处理用户的请求
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23public 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.提交到Service层 // 3.转发或重定向页面 req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req, resp); } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doPost(req, resp); } }
6.编写test.jsp
1
2
3
4
5
6
7
8
9
10
11%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>显示页</title> </head> <body> <%--打印对应的数据--%> ${msg} </body> </html
6.web.xml编写
1
2
3
4
5
6
7
8
9
10
11
12
13<servlet> <!-- 这里的servlet-name随便 但是建议本身的Servlet名称开头字母小写--> <servlet-name>helloServlet</servlet-name> <!-- 全类名的配置--> <servlet-class>com.study.servlet.HelloServlet</servlet-class> </servlet> <servlet-mapping> <!-- 这里的servlet-name和上面的一样--> <servlet-name>helloServlet</servlet-name> <!-- 访问路径 但是建议本身的Servlet名称开头字母小写--> <url-pattern>/helloServlet</url-pattern> </servlet-mapping>
7.配置Tomcat，启动测试
localhost:8080/SpringMVC_01_servlet/helloServlet?method=add
5.MVC框架职责
-
将url映射到java类或java类的方法 .
-
封装用户提交的数据 .
-
处理请求–调用相关的业务处理–封装响应数据 .
-
将响应的数据进行渲染 . jsp / html 等表示层数据 .
6.说明
常见的服务器端MVC框架有：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF；常见
前端MVC框架：vue、angularjs、react、backbone；由MVC演化出了另外一些模式如：MVP、MVVM
等等
2.SpringMVC
1.概念
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2Hu3w7iu-1629686073475)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210710162223442.png)]
2.SpringMVC特点
-
轻量级，简单易学
-
高效 , 基于请求响应的MVC框架
-
与Spring兼容性好，无缝结合
-
约定优于配置
-
功能强大：RESTful、数据验证、格式化、本地化、主题等
-
简洁灵活
1
2
3
4
5
6
7Spring的web框架围绕DispatcherServlet [ 调度Servlet ] 设计。 DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的 用户可以采用基于注解形式进行开发，十分简洁； 正因为SpringMVC好 , 简单 , 便捷 , 易学 , 天生和Spring无缝集成(使用SpringIoC和Aop) , 使用约定优于 配置 . 能够进行简单的junit测试 . 支持Restful风格 .异常处理 , 本地化 , 国际化 , 数据验证 , 类型转换 , 拦 截器 等等......所以我们要学习
3.中心控制器
1
2
3
4
5Spring的web框架围绕DispatcherServlet设计。 DispatcherServlet的作用是将请求分发到不同的处 理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。 Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他 功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NOjwYex7-1629686073476)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210710165150431.png)]
SpringMVC的原理如下图所示：
当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制
器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图
渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vRQGQpqJ-1629686073477)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210710165214378.png)]
4.SpringMVC执行原理
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mK3cnIvF-1629686073478)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210710165251091.png)]
1.简要分析执行流程
1.DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，
DispatcherServlet接收请求并拦截请求。
我们假设请求的url为 : http://localhost:8080/SpringMVC/hello
如上url拆分成三部分：
http://localhost:8080服务器域名
SpringMVC部署在服务器上的web站点
hello表示控制器
通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。
2.HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据
请求url查找Handler。
3.HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器
为：hello。
4.HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
5.HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
6.Handler让具体的Controller执行。
7.Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
8.HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
9.DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
10.视图解析器将解析的逻辑视图名传给DispatcherServlet。
11.DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
12.最终视图呈现给用户。
在这里先听一遍原理，不理解没有关系，我们马上来写一个对应的代码实现大家就明白了，如果不明
白，那就写10遍，没有笨人，只有懒人
5.HelloSpringMVC
1.新建maven项目，导入依赖，添加框架支持
2.配置web.xml(DispatcherServlet)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20<!--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>
3.编写SpringMVC 的 配置文件(springmvc-servlet.xml)
1
2<?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"> </beans>
4.添加 处理映射器与适配器
1
2
3
4
5<!-- 1.添加 处理映射器--> <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/> <!-- 2.添加 处理器适配器--> <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter "/>
5.添加 视图解析器
1
2
3
4
5
6
7
8
9<!-- 3.配置视图解释器--> <!--视图解析器:DispatcherServlet给他的ModelAndView--> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver"> <!--前缀 这里前缀的value是从web层的目录开始算起的--> <property name="prefix" value="/WEB-INF/jsp/"/> <!--后缀 表示以什么样的文件后缀结束--> <property name="suffix" value=".jsp"/> </bean>
6.编写我们要操作业务Controller ，要么实现Controller接口返回对应的vew
1
2
3
4
5
6
7
8
9
10
11public class HelloController implements Controller { public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception { ModelAndView mv = new ModelAndView(); //封装对象，放在ModelAndView中。 Model 前面的参数是变量 后面的是对应的值 mv.addObject("msg","HelloSpringMVC!"); //封装要跳转的视图，放在ModelAndView中 这里的setViewName直接些对应的jsp文件名称就可以啦 mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp return mv; } }
7.将自己的类交给SpringIOC容器，注册bean
1
2
3<!--Handler 这里的id就在地址栏里面访问的id 后面是对应的controller的类 这里的id一般和实现类的setViewName（）中的名称相同--> <bean id="/hello" class="com.study.controller.HelloController"/>
8.编写接受数据的页面（jsp）
1
2
3
4
5
6
7
8
9
10<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>Title</title> </head> <body> ${msg} </body> </html>
9.测试
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z5YE6mTq-1629686073479)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210710195119326.png)]
6.使用注解开发
1.新建maven项目，导入依赖，添加框架支持，添加jar包
2.编写web.xml配置文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18<!--1.注册servlet--> <servlet> <servlet-name>SpringMVC</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet </servlet-class> <!--2.通过初始化参数指定SpringMVC配置文件的位置，进行关联--> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:springmvc-servlet.xml</param-value> </init-param> <!--3. 启动顺序，数字越小，启动越早 --> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>SpringMVC</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping>
3.编写springmvc—servlet.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27<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" xmlns="http://www.springframework.org/schema/beans" 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"> <!-- 1.自动扫描包，让指定包下的注解生效,由IOC容器统一管理 --> <context:component-scan base-package="com.study.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.编写Controller ，使用注解
1
2
3
4
5
6
7
8
9
10
11@Controller //相当于实现了接口 public class HelloController { // http://localhost:8080/springmvc_04_annotation/hello(就是对应的后面的访问名) @RequestMapping("/hello") public String sayHello(Model model) { model.addAttribute("msg", "hello Spring MVC 使用注解开发 "); // 需要返回的对应的jsp页面 Spring会自动寻找对应问价下的jsp文件 return "hello"; } }
5.接受数据jsp页面编写
1
2
3
4
5
6
7
8
9
10<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>Title</title> </head> <body> ${msg} </body> </html>
6.测试
7.Controller接口实现
Controller**(控制器)**
1.控制器复杂提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现。
2.控制器负责解析用户的请求并将其转换为一个模型。
3.在Spring MVC中一个控制器类可以包含多个方法
4.在Spring MVC中，对于Controller的配置方式有很多种
1.新建一个Moudle，springmvc-04-controller ，mvc的配置文件只留下 视图解析器！
2.Controller类的编写，ControllerTest
1
2
3
4
5
6
7
8
9public class ControllerTest implements Controller { public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception { ModelAndView mv = new ModelAndView(); mv.addObject("msg", "Controller简介"); mv.setViewName("test"); return mv; } }
3.编写完毕后，去Spring配置文件中注册请求的bean；name对应请求路径，class对应处理请求的类
1
2
3<!-- 使用Controller配置bean--> <bean id="/test1" class="com.study.controller.ControllerTest"/>
4.编写前端test.jsp，注意在WEB-INF/jsp目录下编写，对应我们的视图解析器
1
2
3
4
5
6
7
8
9
10<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title> 数据接受页面</title> </head> <body> ${msg} </body> </html>
5.配置tomocat运行
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tDUM6grC-1629686073480)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210711193608586.png)]
6.说明
实现接口Controller定义控制器是较老的办法
缺点是：一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller；定义的方式比
较麻烦；
8.使用Controller注解
1.@Controller注解类型用于声明Spring类的实例是一个控制器（在讲IOC时还提到了另外3个注
解）；
Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类，为了保证Spring能找到你的
2.控制器，需要在配置文件中声明组件扫描。
1.在springmvc—servlet.xml添加包结构扫描
1
2
3
4
5
6
7
8
9
10<!-- 1.自动扫描包，让指定包下的注解生效,由IOC容器统一管理 --> <context:component-scan base-package="com.study.controller"/> <!-- 2.让Spring MVC不处理静态资源 --> <mvc:default-servlet-handler/> <!-- 3.支持mvc注解驱动 在spring中一般采用@RequestMapping注解来完成映射关系 要想使@RequestMapping注解生效 必须向上下文中注册DefaultAnnotationHandlerMapping 和一个AnnotationMethodHandlerAdapter实例 这两个实例分别在类级别和方法级别处理。 而annotation-driven配置帮助我们自动完成上述两个实例的注入。 --> <mvc:annotation-driven/>
2.新建实现类（使用注解）
1
2
3
4
5
6
7
8
9
10
11
12//使用Controller注解开发 @Controller public class ControllerTest1 { // 使用RequestMapping来映射访问路径 @RequestMapping("/test") public String index(Model model){ model.addAttribute("msg","这个是使用注解进行开发的RequestMapping"); return "test"; } }
3.运行Toco测试
9.RequestMapping
@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。
用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
为了测试结论更加准确，我们可以加上一个项目名测试 myweb
1.只注解在方法上面
1
2
3
4
5
6@RequestMapping("/test") public String index(Model model){ model.addAttribute("msg","这个是使用注解进行开发的RequestMapping"); return "test"; }
访问路径：http://localhost:8080 / 项目名 / test
2.同时注解类与方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XuRAHMWT-1629686073481)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210711201353184.png)]
访问路径：http://localhost:8080 / 项目名/ admin /h1 , 需要先指定类的路径再指定方法的路径；
10.RestFul 风格
1.概念
Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设
计的软件可以更简洁，更有层次，更易于实现缓存等机制。
2.功能
资源：互联网所有的事物都可以被抽象为资源
资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。
分别对应 添加、 删除、修改、查询。
3.传统方式操作资源 ：
通过不同的参数来实现不同的效果！
方法单一，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.action?id=1 删除,GET或POST
4.使用****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
5.学习测试
1.新建RestFulController类
在Spring MVC中可以使用 @PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量
上
1
2
3
4
5
6
7
8
9
10
11@Controller //使用注解开发 public class RestFulController { @RequestMapping("/commit/{p1}/{p2}")//设置访问的路径{p1}{p2}为参数的格式 public String index(@PathVariable int p1,@PathVariable int p2, Model model){ //这样是@PathVariable设置参数的个数以及参数的类型 int result=p1+p2; model.addAttribute("msg","结果为"+result); return "test"; } }
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T5LTkIAZ-1629686073481)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210711203646850.png)]
2.优点
使路径变得更加简洁；
获得参数更加方便，框架会自动进行类型转换。
通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这
里访问是的路径是/commit/1/a，则路径与方法不匹配，而不会是参数转换失败。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XNkVqhFp-1629686073482)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210711204516514.png)]
3.修改参数类型
1
2
3
4
5
6
7
8
9
10@Controller public class RestFulController { @RequestMapping("/commit/{p1}/{p2}") public String index(@PathVariable int p1, @PathVariable String p2, Model model) { String result = p1 + p2; model.addAttribute("msg", "结果为" + result); return "test"; } }
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kWmEGOva-1629686073483)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210711204722473.png)]
4.使用method属性指定请求类型
用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如GET, POST, HEAD, OPTIONS, PUT,
PATCH, DELETE, TRACE等
我们来测试一下：
1.新增加方法
1
2
3
4
5
6
7
8
9// 修改提交的方式 @RequestMapping(value = "/commit/{p1}/{p2}",method = RequestMethod.POST) public String method(@PathVariable int p1, @PathVariable int p2,Model model){ int result = p1 + p2; model.addAttribute("msg", "结果是"+result); return "test"; } }
2.修改请求方式
1
2@RequestMapping(value = "/commit/{p1}/{p2}",method = RequestMethod.POST)
3.测试
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kpUJaiXW-1629686073484)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210711210430434.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CDYghRqR-1629686073484)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210711210448185.png)]
·
4.总结
Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以
及 PATCH。
所有的地址栏请求默认都会是 HTTP GET 类型的。
方法级别的注解变体有如下几个： 组合注解
1
2
3
4
5
6@GetMapping @PostMapping @PutMapping @DeleteMapping @PatchMapping
@GetMapping 是一个组合注解
它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。
平时使用的会比较多！
5.小黄鸭调试法
场景一：我们都有过向别人（甚至可能向完全不会编程的人）提问及解释编程问题的经历，但是很多时
候就在我们解释的过程中自己却想到了问题的解决方案，然后对方却一脸茫然。
场景二：你的同行跑来问你一个问题，但是当他自己把问题说完，或说到一半的时候就想出答案走了，
留下一脸茫然的你。
其实上面两种场景现象就是所谓的小黄鸭调试法（Rubber Duck Debuging），又称橡皮鸭调试法，它
是我们软件工程中最常使用调试方法之一。
11.结果跳转方式
1.ModelAndView
设置ModelAndView对象 , 根据view的名称 , 和视图解析器跳到指定的页面
页面 : {视图解析器前缀} + viewName +{视图解析器后缀}
1.视图解析器
1
2
3
4
5
6
7<!-- 4. 视图解释器--> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver"> <property name="prefix" value="/WEB-INF/jsp/"/> <property name="suffix" value=".jsp"/> </bean>
2.对应的类
1
2
3
4
5
6
7
8
9
10@Controller public class RestFulController { //Rest风格 @RequestMapping("/commit/{p1}/{p2}") public String index(@PathVariable int p1, @PathVariable String p2, Model model) { String result = p1 + p2; model.addAttribute("msg", "结果为" + result); return "test"; }
2.ServletAPI
通过设置ServletAPI , 不需要视图解析器 .
1.通过HttpServletResponse进行输出
2.通过HttpServletResponse实现重定向
3.通过HttpServletResponse实现转发
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19@Controller public class ModelTest { @RequestMapping("/result/t1") public void test1(HttpServletRequest req, HttpServletResponse resp) throws IOException { resp.getWriter().println("hello Spring By Servlet API"); } @RequestMapping("/result/t2") public void test2(HttpServletRequest req, HttpServletResponse resp) throws IOException { resp.sendRedirect("/springmvc_05_controller/index.jsp"); } @RequestMapping("/result/t3") public void test3(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException { req.setAttribute("msg","result/t3"); req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req, resp); } }
4.测试
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T007CEN2-1629686073485)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210711225751920.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TOgKHcXV-1629686073486)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210711225802375.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1GfhRcee-1629686073488)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210711225817063.png)]
3.使用SpringMVC实现重定向和转发
1.无需视图解释器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23@Controller //这个不需要视图解释器 都会挑转到对应的 public class ResultSpringMVC { @RequestMapping("res/t1") public String test(){ // 转发 return "/index.jsp"; //会访问web下的index.jsp 但是地址栏不会发生改变 } @RequestMapping("res/t2") public String temp(){ //转发二 return "forward:/index.jsp"; //会访问web下的index.jsp 但是地址栏不会发生改变 } @RequestMapping("res/t3") public String test2(){ // 重定向 return "redirect:/index.jsp"; //会访问web下的index.jsp 但是地址栏会发生改变 } }
2.需视图解释器(建议使用)
1
2
3
4
5
6<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver"> <property name="prefix" value="/WEB-INF/jsp/"/> <property name="suffix" value=".jsp"/> </bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17@Controller //这个需要视图解释器 public class ResultSpringMVC2 { // 1.转发 @RequestMapping(value = "/def/t1") public String test1() { //转发 return "test"; return "test"; } // 2.重定向 @RequestMapping(value = "/def/t2") public String test2() { return "redirect:/index.jsp"; } }
12.数据处理
1.处理提交数据
1.提交的域名和处理方法的参数名称一致时
提交域名：http://localhost:8080/springmvc_05_controller/user/u1?name=renboiqng
1
2
3
4
5
6
7@RequestMapping("/user/u1") // 当地址栏输入的参数和处理方法的参数相同时 public String test1(String name){ System.out.println(name); return "test"; }
2.提交的域名和处理方法的参数名称不一致时
提交域名：http://localhost:8080/springmvc_05_controller/user/u2?username=renboiqng
1
2
3
4
5
6
7
8
9@RequestMapping("/user/u2") // 当地址栏输入的参数和处理方法的参数不相同时 // 建议：无论参数名称与方法名称是否相同 都加上@RequestParam（）注解 public String test2(@RequestParam("username") String name){ System.out.println(name); return "test"; } }
3.提交的是一个对象
1
2
3
4
5
6
7
8
9@Data @AllArgsConstructor @NoArgsConstructor public class User { private int id; private String name; private int age; }
提交域名：http://localhost:8080/springmvc_05_controller/user/u3?name=renboqing&age=22&id=21
1
2
3
4
5
6@RequestMapping("/user/u3") public String test3(User user){ System.out.println(user.toString()); return "test"; }
说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。
2.数据显示到前端
1.使用ModelView
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18@Controller public class RestFulController { //Rest风格 @RequestMapping("/commit/{p1}/{p2}") public String index(@PathVariable int p1, @PathVariable String p2, Model model) { String result = p1 + p2; model.addAttribute("msg", "结果为" + result); return "test"; } // 修改提交的方式 @RequestMapping(value = "/commit/{p1}/{p2}",method = RequestMethod.POST) public String method(@PathVariable int p1, @PathVariable int p2,Model model){ int result = p1 + p2; model.addAttribute("msg", "结果是"+result); return "test"; } }
2.使用ModelMap
1
2
3
4
5
6
7
8@RequestMapping("/hello") public String hello(@RequestParam("username") String name,ModelMap model){ //封装要显示到视图中的数据 //相当于req.setAttribute("name",name); model.addAttribute("name",name); System.out.println(name); return "hello"; }
3.使用ModelAndView(不建议使用)
1
2
3
4
5
6
7
8
9public class ControllerTest implements Controller { public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception { ModelAndView mv = new ModelAndView(); mv.addObject("msg", "Controller简介"); mv.setViewName("test"); return mv; } }
4.对比
1
2
3
4Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解； ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性； ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。
当然更多的以后开发考虑的更多的是性能和优化，就不能单单仅限于此的了解。
请使用80%的时间打好扎实的基础，剩下18%的时间研究框架，2%的时间去学点英文，框架的官方文档**
永远是最好的教程。
13.乱码问题
1.表单提交
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15<html> <head> <title>表单页面</title> </head> <body> <%--这里需要注意，这里面需要对应的项目路径 如果直接使用的话 是对应的localhost8080：后面（需要打带上对应的项目名称）--%> <form action="${pageContext.request.contextPath}/e/t" method="post"> <input type="text" name="name"> <input type="submit"> </form> </body> </html>
2.Controller编写
1
2
3
4
5
6
7
8
9public class EncodingController { // 这个方法发 前面是视图，后面是对应的参数 @RequestMapping("/e/t") public String encodingString(Model model,String name){ System.out.println(name); model.addAttribute("msg",name); return "test"; }
3.配置tomocat测试
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zPUhLsC7-1629686073489)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210712143431980.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-89plSEqu-1629686073489)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210712143444474.png)]
4.配置SpringMVC的过滤器(web.xml)
1
2
3
4
5
6
7
8
9
10
11
12
13
14<!-- 4.配置过滤器--> <filter> <filter-name>encoding</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>encoding</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GDCmjy5v-1629686073490)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210712144809569.png)]
5.修改tomcat配置文件
1
2<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" />
6.自定义过滤器
1
2
3
4
5
6
7@Override public void destroy() { }@Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { //处理response的字符编码 HttpServletResponse myResponse=(HttpServletResponse) response; myResponse.setContentType("text/html;charset=UTF-8"); // 转型为与协议相关对象 HttpServletRequest httpServletRequest = (HttpServletRequest) request; // 对request包装增强 HttpServletRequest myrequest = new MyRequest(httpServletRequest); chain.doFilter(myrequest, response); }@Override public void init(FilterConfig filterConfig) throws ServletException { } }//自定义request对象，HttpServletRequest的包装类 class MyRequest extends HttpServletRequestWrapper { private HttpServletRequest request; //是否编码的标记 private boolean hasEncode; //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰 public MyRequest(HttpServletRequest request) { super(request);// super必须写 this.request = request; }public Map getParameterMap() { // 先获得请求方式 String method = request.getMethod(); if (method.equalsIgnoreCase("post")) { // post请求 try {// 处理post乱码 request.setCharacterEncoding("utf-8"); return request.getParameterMap(); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } } else if (method.equalsIgnoreCase("get")) { // get请求 Map<String, String[]> parameterMap = request.getParameterMap(); if (!hasEncode) { // 确保get手动编码逻辑只运行一次 for (String parameterName : parameterMap.keySet()) { String[] values = parameterMap.get(parameterName); if (values != null) { for (int i = 0; i < values.length; i++) { try {// 处理get乱码 values[i] = new String(values[i] .getBytes("ISO-8859-1"), "utf- 8"); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } } } }hasEncode = true; }return parameterMap; }return super.getParameterMap(); }//取一个值 @Override public String getParameter(String name) { Map<String, String[]> parameterMap = getParameterMap(); String[] values = parameterMap.get(name); if (values == null) { return null; }return values[0]; // 取回参数的第一个值 }//取所有值 @Override public String[] getParameterValues(String name) { Map<String, String[]> parameterMap = getParameterMap(); String[] values = parameterMap.get(name); return values; } }
这个也是我在网上找的一些大神写的，一般情况下，SpringMVC默认的乱码处理就已经能够很好的
**解决了！**然后在web.xml中配置这个过滤器即可！****乱码问题，需要平时多注意，在尽可能能设置编码的地方，都设置为统一编码 UTF-8！
14.JSON
1.概念
JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广
泛。
采用完全独立于编程语言的文本格式来存储和表示数据。
简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。
易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率
2.语法格式
在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过 JSON 来表示，例
如字符串、数字、对象、数组等。看看他的要求和语法格式：
1.对象表示为键值对，数据由逗号分隔
2.花括号保存对象
3.方括号保存数组
1
2
3
4{"name": "QinJiang"} {"age": "3"} {"sex": "男"}
很多人搞不清楚 JSON 和 JavaScript 对象的关系，甚至连谁是谁都不清楚。其实，可以这么理解：
JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符
串。
1
2
3
4
5
6
7
8
9<script type="text/javascript"> var user = { name: " 任柏庆", age: 20, sex: "男" }; var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个 字符串 </script>
1.将js对象转化为json对象
1
2
3要实现从JavaScript 对象转换为JSON字符串，使用 JSON.stringify() 方法： var json=JSON.stringify(user);
2.将json对象转为js对象
1
2
3//将json转化为javaScript对象 var obj=JSON.parse(json);
3.测试
1
2
3
4
5
6
7
8
9
10
11<script type="text/javascript"> //编写一个js的对象 var user = {name: "秦疆", age: 3, sex: "男"}; //将js对象转换成json字符串 var str = JSON.stringify(user); console.log(str); //将json字符串转换为js对象 var user2 = JSON.parse(str); console.log(user2.age, user2.name, user2.sex); </script>
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yy6LrXWS-1629686073491)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210712154942081.png)]
3.Controller返回JSON数据
1.新建模块，导入项目依赖，添加web框架支持
2.导入Jackson的项目依赖
1
2
3
4
5
6
7
8<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson- core --> <!-- jackson 的项目依赖--> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.9.8</version> </dependency>
3.配置web.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32<!--1.注册servlet--> <servlet> <servlet-name>SpringMVC</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet </servlet-class> <!--2.通过初始化参数指定SpringMVC配置文件的位置，进行关联--> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:springmvc-servlet.xml</param-value> </init-param> <!--3. 启动顺序，数字越小，启动越早 --> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>SpringMVC</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> <!-- 4.配置过滤器--> <filter> <filter-name>encoding</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>encoding</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
4.配置springmvc-servlet.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27<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" xmlns="http://www.springframework.org/schema/beans" 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"> <!-- 1.自动扫描包，让指定包下的注解生效,由IOC容器统一管理 --> <context:component-scan base-package="com.study.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>
5.实体类
1
2
3
4
5
6
7
8
9
10@NoArgsConstructor @AllArgsConstructor @Data // 使用lombok public class User { private String name; private int age; private String sex; }
6.Controller类
1.直接返回对象
1
2
3
4
5
6
7
8
9
10
11
12
13@Controller public class UserController { // 使用这个注解以后 不会走视图解析器 // 方式一 @ResponseBody @RequestMapping("/j1") public String json1() { User user = new User("大数据", 20, "男"); String s = user.toString(); return s; } }
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LlRR4STc-1629686073492)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210712180322624.png)]
2.使用jackson返回
1
2
3
4
5
6
7
8
9
10@ResponseBody @RequestMapping("/j2") // 使用jackson将Java对象转化为json public String json2() throws JsonProcessingException { ObjectMapper mapper = new ObjectMapper(); User user = new User("大数据", 20, "男"); String str = mapper.writeValueAsString(user); return str; }
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p3JAzlRX-1629686073492)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210712190631328.png)]
3.乱码问题
1.使用@RequestMapping注解开发
1
2@RequestMapping(value = "/j2",produces = "application/json;charset=utf-8")
2.乱码统一解决
在springmvc-servlet.xml配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15<mvc:annotation-driven> <mvc:message-converters register-defaults="true"> <bean class="org.springframework.http.converter.StringHttpMessageConverter"> <constructor-arg value="UTF-8"/> </bean> <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"> <property name="objectMapper"> <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean"> <property name="failOnEmptyBeans" value="false"/> </bean> </property> </bean> </mvc:message-converters> </mvc:annotation-driven>
3.返回json字符串统一解决
1
2
3
4
5
6
7
8
9
10
11
12
13@RestController public class UserController { //produces:指定响应体返回类型和编码 @RequestMapping(value = "/json1") public String json1() throws JsonProcessingException { //创建一个jackson的对象映射器，用来解析数据 ObjectMapper mapper = new ObjectMapper(); //创建一个对象 User user = new User("秦疆1号", 3, "男"); //将我们的对象解析成为json格式 String str = mapper.writeValueAsString(user); //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便 return str; } }
4.输出集合对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19// 返回的值为集合的形式 @RequestMapping("/j3") public String json3() throws JsonProcessingException { //创建一个jackson的对象映射器，用来解析数据 ObjectMapper mapper = new ObjectMapper(); //创建一个对象 User user1 = new User("秦疆1号", 3, "男"); User user2 = new User("秦疆2号", 3, "男"); User user3 = new User("秦疆3号", 3, "男"); User user4 = new User("秦疆4号", 3, "男"); List<User> list = new ArrayList<User>(); list.add(user1); list.add(user2); list.add(user3); list.add(user4); String str = mapper.writeValueAsString(list); return str; }
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ahLw4Jzl-1629686073493)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210712193919925.png)]
5.输出时间对象
1.使用时间戳的方式
1
2
3
4
5
6
7
8
9
10
11// 返回时间类型 @RequestMapping("/j4") public String json4() throws JsonProcessingException { ObjectMapper mapper = new ObjectMapper(); //创建时间一个对象，java.util.Date Date date = new Date(); //将我们的对象解析成为json格式 String str = mapper.writeValueAsString(date); return str; }
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U8fRrUrH-1629686073494)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210712204153774.png)]
2.不使用时间戳
1
2
3
4
5
6
7
8
9
10
11
12
13
14@RequestMapping("/j5") public String json5() throws JsonProcessingException { ObjectMapper mapper = new ObjectMapper(); // 不使用时间戳的方式 mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); //自定义日期格式对象 SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 指定日期的格式 mapper.setDateFormat(df); Date date = new Date(); String str = mapper.writeValueAsString(date); return str; }
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p0ZbpMhk-1629686073494)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210712204935401.png)]
3.封装工具类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23public class JsonUtils { public static String getJson(Object object){ return getJson(object,"yyyy-MM-dd HH:mm:ss"); } public static String getJson(Object object, String dateFormat) { ObjectMapper mapper = new ObjectMapper(); //不使用时间差的方式 mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); //自定义日期格式对象 SimpleDateFormat sdf = new SimpleDateFormat(dateFormat); //指定日期格式 mapper.setDateFormat(sdf); try { return mapper.writeValueAsString(object); } catch (JsonProcessingException e) { e.printStackTrace(); } return null; } }
1
2
3
4
5
6
7
8@RequestMapping("/j4") public String json4() throws JsonProcessingException { Date date = new Date(); // 直接使用工具类 return JsonUtils.getJson(date); }
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ajxe4690-1629686073495)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210712205825181.png)]
6.使用FastJson返回
项目依赖
1
2
3
4
5
6<dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.60</version> </dependency>
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zkv9QyJ8-1629686073496)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20210712212614824.png)]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27public String json6() { //创建一个对象 User user1 = new User("秦疆1号", 3, "男"); User user2 = new User("秦疆2号", 3, "男"); User user3 = new User("秦疆3号", 3, "男"); User user4 = new User("秦疆4号", 3, "男"); List<User> list = new ArrayList<User>(); list.add(user1); list.add(user2); list.add(user3); list.add(user4); System.out.println("*******Java对象 转 JSON字符串*******"); String str1 = JSON.toJSONString(list); System.out.println("JSON.toJSONString(list)==>" + str1); String str2 = JSON.toJSONString(user1); System.out.println("JSON.toJSONString(user1)==>" + str2); System.out.println("n****** JSON字符串 转 Java对象*******"); User jp_user1 = JSON.parseObject(str2, User.class); System.out.println("JSON.parseObject(str2,User.class)==>" + jp_user1); System.out.println("n****** Java对象 转 JSON对象 ******"); JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2); System.out.println("(JSONObject) JSON.toJSON(user2)==>" + jsonObject1.getString("name")); System.out.println("n****** JSON对象 转 Java对象 ******"); User to_java_user = JSON.toJavaObject(jsonObject1, User.class); System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>" + to_java_user); return "";
1
2
3<version>1.2.60</version> </dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31[外链图片转存中...(img-zkv9QyJ8-1629686073496)] `````java public String json6() { //创建一个对象 User user1 = new User("秦疆1号", 3, "男"); User user2 = new User("秦疆2号", 3, "男"); User user3 = new User("秦疆3号", 3, "男"); User user4 = new User("秦疆4号", 3, "男"); List<User> list = new ArrayList<User>(); list.add(user1); list.add(user2); list.add(user3); list.add(user4); System.out.println("*******Java对象 转 JSON字符串*******"); String str1 = JSON.toJSONString(list); System.out.println("JSON.toJSONString(list)==>" + str1); String str2 = JSON.toJSONString(user1); System.out.println("JSON.toJSONString(user1)==>" + str2); System.out.println("n****** JSON字符串 转 Java对象*******"); User jp_user1 = JSON.parseObject(str2, User.class); System.out.println("JSON.parseObject(str2,User.class)==>" + jp_user1); System.out.println("n****** Java对象 转 JSON对象 ******"); JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2); System.out.println("(JSONObject) JSON.toJSON(user2)==>" + jsonObject1.getString("name")); System.out.println("n****** JSON对象 转 Java对象 ******"); User to_java_user = JSON.toJavaObject(jsonObject1, User.class); System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>" + to_java_user); return "";
最后
以上就是斯文信封最近收集整理的关于SpringMVC学习笔记SpringMVC的全部内容，更多相关SpringMVC学习笔记SpringMVC内容请搜索靠谱客的其他文章。
发表评论 取消回复