【SpringMVC】---学习笔记
【SpringMVC】
一、SpringMVC简介
1、MVC模型
- Module(模型):Dao、Service
- View(识图):Jsp
- Controller(控制器):Serv
2、什么是SpringMVC
官方文档
https://docs.spring.io/spring-framework/docs/current/reference/html/web.html
- Spring Web MVC 是最初建立在 Servlet API 之上的 Web 框架。
- 从一开始就包含在 Spring Framework 中。
- 正式名称“Spring Web MVC”来自其源模块的名称 (
spring-webmvc
),但通常称为“Spring MVC”。
特点:
- 轻量级,简单易学。
- 高效,基于请求响应的MVC框架。
- 与Spring兼容性好,无缝结合。
- 约定优于配置
3、中心控制器
Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring2.5开始,使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。
SpringMVC框架像许多MVC框架一样,以请求为驱动,围绕一个中心Servlet分派请求及提供其他功能,DispacherServlet是一个实际的Servlet(继承于HttpServlet基类
4、原理
当请求发起时被前置的控制器拦截到请求,根据请求参数生成代理请求,找到请求对应的实际控制器,控住器处理请求,创建数据模型,访问数据库,将模型响应给中心控制器,控制器使用模型与视图渲染结果,将结果返回给中心控制器,再将结果返回给请求者。
二、Hello,SpringMVC
1、新建一个Moudle,添加web的支持!
2、确定导入了SpringMVC的依赖
<!--依赖-->
<dependencies>
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.9</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet/servlet-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.3</version>
<scope>provided</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
3、配置web.xml,注册DispatcherServlet
<!--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>
4、编写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.org/schema/beans/spring-beans.xsd">
</beans>
5、添加处理映射器
<!--添加处理映射器-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
6、添加处理器适配器
<!--添加处理器适配器-->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
7、添加视图解析器
<!--添加视图解析器:DispatcherServlet给他的ModelAndView-->
<bean class="org.springframework.web.servlet.view.InternalResourceView" id="internalResourceView">
<!--前缀-->
<property name="prefix" value="/WEB-INF/jsp/"></property>
<!--后缀-->
<property name="suffix" value=".jsp"/>
</bean>
8、编写我们要操作业务Controller
要么实现Controller接口,要么增加注解;需要返回一个 ModelAndView,装数据,封视图
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
import javax.servlet.http.HttpServlet;
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 {
//ModelAndView模型和视图
ModelAndView mv = new ModelAndView();
//封装对象,放在ModelAndView中。Model
mv.addObject("msg","HelloSpringMVC!");
//封装要跳转的视图,放在ModelAndView中
mv.setViewName("hello");//: /WEB-INF/jsp/hello.jsp
return mv;
}
}
9、将自己的类交给SpringIOC容器,注册bean
<!--Handler-->
<bean id="/hello" class="com.darkerg.controller.HelloController"/>
10、写要跳转的jsp页面,显示ModelandView存放的数据,以及我们的正常页面。
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${msg}
</body>
</html>
三、SpringMVC执行原理
四、SpringMVC使用注解配置
1、配置web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
version="5.0">
<!--配置DispatcherServlet: 这个是SpringMVC的核心,请求分发器,前端控制器-->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--DispatcherServlet要绑定spring的配置文件-->
<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>
2、springmvc-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"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://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.darkerg.controller"/>
<!--让Spring MVC不处理静态资源 .css .js .html .mp3 .mp4-->
<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>
3、创建视图
在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下,这样可以保证视图安全,因为这个目录下的文件,客户端不能直接访问。
4、创建Controller
编写一个控制类:com.darkerg.controller.HelloController,注意编码规范。
package com.darkerg.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class HelloController {
@RequestMapping("/hello")
public String hello(Model model){
//封装数据
model.addAttribute("msg","Hello,SpringMVCAnnotation");
return "hello"; //会被视图解析器处理;
}
}
- @Controller是为了让Spring IOC容器初始化时自动扫描到。
- @RequestMapping是为了映射请求路径,这里因为类与方法上都有映射所以访问时候应该是/HelloController/hello;
- 方法中声明Model类型的参数是为了把Action中的数据带到视图中。
- 方法返回的结果是视图的名称hello,加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp
5、创建视图层
hello.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${msg}
</body>
</html>
6、总结
使用SpringMVC必须配置的三大件:
处理器映射器,处理器适配器,视图解析器
通常,我们只需要手动配置视图解析器,而处理器映射器和处理器适配器只需要开启注解驱动即可,而省去了大段的xml配置。
五、Controller解析
1、控制器Controller
- 控制器复杂提供访问应用程序的行为,通常通过接口定义或者注解定义两字符方法实现。
- 控制器负责解析用户的请求并将其转换为一个模型。
- 在SpringMVC中,一个控制器类可以包含多个方法。
- 在SpringMVC中,对于Controller的配置方式有很多种。
2、使用接口配置控制器
public class HelloController implements Controller {
@Override
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;
}
}
2、使用注解@Contrller配置控制器
@Controller//代表这个类会被Spring接管,被这个注解的类中的所有方法,如果返回值是String,并且具有具体页面可以跳转,那么就会被视图解析器解析。
public class HelloController {
@RequestMapping("/hello")//配置映射地址
public String hello(Model model){
//封装数据
model.addAttribute("msg","Hello,SpringMVCAnnotation");
return "hello"; //会被视图解析器处理;/WEB-INF/jsp/hello.jsp
}
}
可以实现视图的复用!!只是里面的数据不一样了!
RequestMapping()也可以加在类上面,和方法上面形成父子的关系。
六、RestFul风格
1、概念
Restful就是一个资源定位及资源操作的风格。不是标准也不是协议,只是一种风格。基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制,
2、功能
- 资源:互联网所有的事物都可以被抽象为资源
- 资源操作:使用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.action?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
3、学习测试
新建一个类RestFulController
在SpringMVC中可以使用@PathVariable注解,让方法参数的值对应绑定到一个URI模板变量上。
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class RestFulController {
//原来的:http://localhost:8080/add?a=1&b=2
//RestFul:http://localhost:8080/add/a/b
//eg:http://localhost:8080/add/1/2
@RequestMapping("/add/{a}/{b}")
public String test1(@PathVariable int a,@PathVariable int b, Model model){
int res = a+b;
model.addAttribute("msg","结果为:"+res);
return "test";
}
}
还可以限定请求的方式
@RequestMapping(value = "/add/{a}/{b}",method = RequestMethod.DELETE)
也可以通过下面的方式来实现:
- @GetMapping
- @PostMapping
- @PutMapping
- @DeleteMapping
- @PatchMapping
七、转发和重定向
1、ServletAPI实现
通过设置Servlet API,不需要视图解析器。
- 通过HttpServletResponse进行输出
- 通过HttpServletResponse实现重定向
- 通过HttpServletResponse实现转发
@Controller
public class ModelTest1 {
@RequestMapping("/m1/t1")
public String test(HttpServletRequest req,HttpServletRequest resp){
HttpSession session = req.getSession();
System.out.println(session.getId());
return "test";
}
}
2、通过SpringMVC来实现转发和重定向-无需视图解析器
测试前,需要将视图解析器注释掉。
@Controller
public class ResultSpringMVC {
@RequestMapping("/rsm/t1")
public String test1(){
//转发
return "/index.jsp";
}
@RequestMapping("/rsm/t2")
public String test2(){
//转发二
return "forward:/index.jsp";
}
@RequestMapping("/rsm/t3")
public String test3(){
//重定向
return "redirect:/index.jsp";
}
}
3、通过SpringMVC来实现转发和重定向-有视图解析器
重定向,不需要视图解析器,本质就是重新请求一个新地方,所以注意路径问题。
可以重定向到另外一个请求实现。
@Controller
public class ResultSpringMVC {
@RequestMapping("/rsm/t1")
public String test1(){
//转发
//默认情况下为转发
return "test";
}
@RequestMapping("/rsm/t2")
public String test3(){
//重定向
return "redirect:/index.jsp";
//return "redirect:hello.do;"//hello.do为另一个请求/
}
}
八、SpringMVC数据处理
1、处理提交数据
1、提交的域名称和处理方法的参数名一致
提交数据:
http://localhost:8080/hello?name=darkerg
处理方法:
@RequestMapping("/hello")
public String hello(String name){
System.out.println(name);
return "hello";
}
后台输出:darkerg
2、提交的域名称和处理方法的参数名不一致
提交数据
http://localhost:8080/hello?username=darkerg
处理方法:
//@RequestParam("username"):username提交的域的名称
@RequestMapping("/hello")
public String hello(@RequestParam("username") String name){
System.out.println(name);
return "hello";
}
3、提交的是一个对象
要求提交的表单域和对象的属性名一致,参数使用对象即可。
实体类
public class User{
private int id;
private String name;
private int age;
//构造
//get/set
//toString()
}
提交数据
http://localhost:8080/mvc04/user?name=darkerg&id=1&age=18
处理方法:
@RequestMapping("/user")
public String user(User user){
System.out.println(user);
return "hello";
}
后台输出:User{id=1,name='darkerg',age=15}
说明:如果使用对象的话,前端传递的参数名和对象必须一致,否则就是null。
2、数据显示到前端
第一种:通过ModelAndView
我们前面一直都是如此,就不过多解释。
public class ControllerTest1 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;
}
}
第二种:通过ModelMap
ModelMap
@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";
}
第三种:通过Model
Model
@RequestMapping("/add/{a}/{b}")
public String test1(@PathVariable int a,@PathVariable int b, Model model){
int res = a+b;
model.addAttribute("msg","结果为:"+res);
return "test";
}
使用区别
Model 只有寥寥几个方法,只适用于存储数据,简化了新手对于Model对象的操作和理解。
ModelMap 继承了LinkedMap,除了实现了自身的一些方法,同样的继承LinkedMap的方法和特性。
ModelAndView 可以在存储数据的同时,可以进行设置返回的逻辑视图,进行控制展示层的跳转。
更多的是以后开发中考虑的性能和优化
3、解决乱码问题
测试步骤:
在首页编写一个提交的表单
<form action="/e/t" method"post">
<input type='text' name="name">
<input type="submit">
</form>
后台编写对应的处理类
@Controller
public class EncodingController {
@RequestMapping("/e/t")
public String test(Model model,String name){
model.addAttribute("msg",name);//获取表单提交的值
return "test";//跳转到test页面显示输入的值
}
}
测试后,可能会出现乱码。
/ 和/的区别*
解决问题---过滤器
import javax.servlet.*;
import java.io.IOException;
public class EncodingFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
servletRequest.setCharacterEncoding("utf-8");
servletResponse.setCharacterEncoding("utf-8");
filterChain.doFilter(servletRequest,servletResponse);
}
@Override
public void destroy() {
}
}
配置web.xml
<filter>
<filter-name>encoding</filter-name>
<filter-class>com.darkerg.filter.EncodingFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
使用SpringMVC的乱码过滤器
在web.xml中配置
<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>
Tomcat编码的配置
修改tomcat配置文件:设置编码!
tomcat/conf/server.xml
<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />
使用大神的自定义过滤器
九、JSON
JSON的引入
前后端分离:
-
后端部署后端,提供接口,提供数据:写一个方法,前端可以远程的调用。
-
Json:
-
前端独立部署,负责渲染后端的数据
1、什么是JSON
- JSON(JavaScript Object Notation,JS对象标记)是一种轻量级的数据交换格式,目前使用特别广泛。
- 采用完全独立与编程语言的文本格式来存储和表示数据。
- 简洁和清晰的层次结构使得JSON成为理想的数据交换语言。
- 易于人阅读和编写,同时也易于机器解析和生成,并有效地提升网络传输效率。
在JavaScript语言中,一切都是对象。因此,任何JavaScript支持的类型都可以通过JSON来表示,例如字符串、数字、对象、数组等。
JSON学习:
https://www.runoob.com/json/json-tutorial.html
2、JackSon的使用
- Jackson应该是目前比较好的Json解析工具了
- 当然工具不止这一个,比如还有阿里巴巴的fastjson等等。
- 我们这里是用Jackson,使用它需要导入它的jar包;
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.12.4</version>
</dependency>
- 配置SpringMVC需要的配置
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
version="5.0">
<!--配置DispatcherServlet: 这个是SpringMVC的核心,请求分发器,前端控制器-->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--DispatcherServlet要绑定spring的配置文件-->
<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>
<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>
</web-app>
- 编写一个实体类
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private String name;
private int age;
private String sex;
}
- 编写控制器UserController
import com.darkerg.pojo.User;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
//此处也可以写RestController,这样就都不走视图解析器了。直接返回字符串,就不需要下面的@RespinseBody了
public class UserController {
//解决乱码问题
@RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")
@ResponseBody//只要加了ResponseBody,这个方法就不会走视图解析器。会直接返回一个字符串
public String json1() throws JsonProcessingException {
//jackson,ObjectMapper
ObjectMapper mapper = new ObjectMapper();
//创建一个对象
User user = new User("darkerg",3,"男");
//这个方法可以把这个对象转化为一个字符串
String str = mapper.writeValueAsString(user);
return str;
}
}
乱码问题的另外一种解决方案------SpirngMVC配置统一解决
<!--解决json 乱码配置-->
<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、返回多个对象的情况
@RequestMapping(value = "/j2")
public String json2() throws JsonProcessingException {
//jackson,ObjectMapper
ObjectMapper mapper = new ObjectMapper();
List<User> userList = new ArrayList<>();
//创建一个对象
User user1 = new User("darkerg1",3,"男");
User user2 = new User("darkerg2",3,"男");
User user3 = new User("darkerg3",3,"男");
User user4 = new User("darkerg4",3,"男");
userList.add(user1);
userList.add(user2);
userList.add(user3);
userList.add(user4);
String str = mapper.writeValueAsString(userList);
return str;
}
4、封装JsonUtils工具类
mport com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.text.SimpleDateFormat;
public 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);
try {
return mapper.writeValueAsString(object);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return null;
}
}
测试一:修改上面多个对象返回的情况
@RequestMapping(value = "/j2")
public String json2() throws JsonProcessingException {
//jackson,ObjectMapper
ObjectMapper mapper = new ObjectMapper();
List<User> userList = new ArrayList<>();
//创建一个对象
User user1 = new User("darkerg1",3,"男");
User user2 = new User("darkerg2",3,"男");
User user3 = new User("darkerg3",3,"男");
User user4 = new User("darkerg4",3,"男");
userList.add(user1);
userList.add(user2);
userList.add(user3);
userList.add(user4);
return JsonUtils.getJson(userList);
}
测试二:添加日期
@RequestMapping("/j3")
public String json3(){
Date date = new Date();
return JsonUtils.getJson(date,"yyyy-MM-dd HH:mm:ss");
}
5、FastJson
<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.76</version>
</dependency>
@RequestMapping(value = "/j4")
public String json4() throws JsonProcessingException {
//jackson,ObjectMapper
ObjectMapper mapper = new ObjectMapper();
List<User> userList = new ArrayList<>();
//创建一个对象
User user1 = new User("darkerg1",3,"男");
User user2 = new User("darkerg2",3,"男");
User user3 = new User("darkerg3",3,"男");
User user4 = new User("darkerg4",3,"男");
userList.add(user1);
userList.add(user2);
userList.add(user3);
userList.add(user4);
String str = JSON.toJSONString(userList);
return str;
}