SpringMVC学习日记总结

程序员文章站 2022-04-22 11:40:01

博主学习SpringMVC时做的笔记。...

SpringMVC

1、回顾MVC

1.1、什么是MVC？

MVC是模型，视图，控制器的简写，是一种软件设计规范
MVC主要作用是降低了视图与业务逻辑间的双向耦合
MVC不是设计模式，是架构模式

1.2、MVC框架要做哪些事情？

将url映射到java类或java类的方法
封装用户提交数据
处理请求，调用相关的业务处理–封装响应数据
将相应的数据进行渲染.jsp/html等表示层数据

1.3、MVC框架

Spring MVC是SpringFramework的一部分，是给予java实现MVC的轻量级Web框架，
官网：https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/web.html

1.4、我们为什么要学习SpringMVC？

Spring MVC的特点
1. 轻量级。简单易学
2. 高效，基于请求响应的MVC框架
3. 与Spring兼容性好，无缝结合
  - Spring是个大杂烩，可以将SpringMVC中所有要用到的bean，注册到Spring中！
4. 约定优于配置
5. 功能强大：RESTful、数据验证、格式化、本地化、主题等
6. 简介灵活

2、步骤

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.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.1</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

导入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.1</version>
</dependency>

新建Moudle，添加web支持
确定导入了SpringMVC的依赖

配置web.xml注册DispatcherServlet（web.xml）

<!--    注册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>contextClass</param-name>
                <param-value>classpath:springmvc-servlet.xml</param-value>
            </init-param>
<!--            启动级别-->
            <load-on-startup>1</load-on-startup>
        </servlet>

<!--    / 匹配所有的请求：(不包括.jsp)-->
<!--    /* 匹配所有的请求: (包括.jsp)-->
        <servlet-mapping>
            <servlet-name>springmvc</servlet-name>
            <url-pattern>/</url-pattern>
        </servlet-mapping>

编写SpringMVC的配置文件，名称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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

添加处理器映射器

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

添加处理器适配器

<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

添加视图解析器

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

编写Conteroller,

public class helloController implements Controller {
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception{
        // ModerLAndView 模型和视图
        ModelAndView mv = new ModelAndView();

        // 封装对象，放在ModelAndView中， Model
        mv.addObject("msg","HelloSpringMVC"!)

        mv.setView("hello");
        return mv;
    }
    public String value() {
        return null;
    }

    public Class<? extends Annotation> annotationType() {
        return null;
    }
}

将自己的类交给Springioc容器，注册bean

<bean id="/hello" class="com.bdqn.controller.helloController"/>

要跳转到的jsp页面

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

3、SpringMVC执行原理

官方图
SpringMVC学习日记总结

详情图
SpringMVC学习日记总结

实线表示MVC框架提供的技术，不需要开发者实现；虚线表示需要开发者实现

简单分析执行流程

DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心，用户发出请求 DispathcherServlet接受请求并拦截请求
- 我们假设请求的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系那个具体的执行信息返回给HandlerAdpter，如ModeriAndView
HandlerAdapter调用视图解析器（ViewResolver）来解析HandlerAdapter传递的逻辑视图名
DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
视图解析器将解析的逻辑视图名传递给DispacthcherServlet。
DispatcherServlet根据视图解析器解析的视图结果，调用具体的试图。
最终视图呈现给用户

执行原理

用户发送请求给前端控制器
前端控制器委托请求给页面控制器(也就是“配置文件”)
页面控制器通过HandlerMapping根据路径查找Handler映射给DispatchServlet

DispatcherServlet通过映射回来的信息让处理器适配器（HandlerAdaper）执行Handler（Handler上有具体的Controller,意思其实是执行Controller）
Controller把执行信息返回给处理器适配器（HandlerAdapter）
处理器适配器（HandlerAdapter）再返回给DispatcherServlet

DispatcherServlet调用视图解析器来解析处理器适配器返回的信息
视图解析器将解析的视图名（前缀和后缀）返回给DispacthcherServlet。
DispactherServlet将根据视图解析器解析出来的视图名将最终视图传递给用户！

4、注解版

新建一个Moudle，添加web支持！

由于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>

配置web.xml

<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <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>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

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

在resource目录下添加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
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">


    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.bdqn.controller"/>
    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler />
    <!--支持mvc注解驱动-->
    <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>

创建Controller

@org.springframework.stereotype.Controller
public class Controller {
    @RequestMapping("/hello")
    public String hello(Model model){
        // 封装数据
        model.addAttribute("massage","Hello,SpringMVCAnnotation!");
        return "hello";     // 会被视图解析器处理
    }
}

@Controller是为了让Spring IOC容器初始化时自动扫描到
@RequestMapping是为了映射请求路径，在类上写就表示父子关系
参数Model 是为了把Action中的数据带到视图中；
return的是视图的名称hello,在视图配置中会给予武装（加上前后缀）

创建视图层

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

配置Tomcat运行

小结

实现步骤
1. 新建web项目
2. 导入相关jar包
3. 编写web.xml，（注册DispatchServlet）
4. 编写springmvc配置文件
5. 创建对应的控制类 Controller
6. 完善前端视图和controller之间的对应
7. 测试运行调试
SpringMVC必须配置的三大件：
- 处理器映射器，处理器适配器，视图解析器
通常只需要手动配置视图解析器，

处理器映射器和处理器适配器，只需要开启注解驱动即可，<mvc:annotation-driven />

5、Controller控制器

提供访问应用程序的行为，定义方法：接口或注解
控制器负责解析用户的请求，并将其转换为一个模型（Model）
一个控制器类可以包含多个方法
Controller的配置有很多种

实现Controller接口（接口只有一个方法）

//实现该接口的类就可以获得控制器的功能
public class HelloController implements Controller {
//    返回ModelAndView
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("massage","Controller1");
        modelAndView.setViewName("hello");
        return modelAndView;
    }

缺点：一个控制器只能写一个方法

使用注解@Controller

@Controller // 代表这个类会被Spring接管 类下所有的方法如果返回值是String 并且有具体的页面可以跳转，就会被视图解析器解析
public class HelloController2 {
//    映射访问路径
    @RequestMapping("/t2")
    public String test1(Model model){
        model.addAttribute("mas","Controller2");
        return "hello";
    }
}

配置类

    <!--    扫描controller包-->
    <context:component-scan base-package="com.bdqn.controller"/>
<!--    过滤静态资源-->
<!--    <mvc:default-servlet-handler/>-->
<!--    注解支持-->
<!--    <mvc:annotation-driven/>-->
<!--    视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
<!--    <bean id="/tt" class="com.bdqn.controller.HelloController"/>-->

6、RestFul风格

6.1 概念

RestFul就是资源定位和资源操作的风格，不是标准也不是协议，只是风格。这个风格可以让软件更简洁，更有层次，更易于实现缓存等机制

6.2 路径

// 原来：http://localhost:8080/add?a=1&b=2
// RestFul:http://localhost:8080/add/a/b

@GetMapping：通过Get地址栏上写入
@PostMapping：通过表单的方式写入
@RequestMapping(value = “/add”,method = RequestMethod.GET)
@RequestMapping(value = “/add”,method = RequestMethod.POST)

6.3 代码

@GetMapping(value = "/{a}/{b}")
public String test3(@PathVariable Integer a,@PathVariable Integer b, Model model){
    Integer c = a + b;
    model.addAttribute("message",c);
    return "admin/text";
}

7、关于转发与重定向

可以脱离视图解析器【非人类】

把视图解析器注释掉

在Controller类中定义转发

return "forward:/WEB-INF/jsp/admin/text.jsp";

在Controller类中定义重定向
```
return "redirect:/index.jsp";
```

8、请求参数与数据回显

8.1 请求参数

参数为变量：
- @RequestParam(“xxx”) 设置别名，表明决心!
参数为对象
- 保证前端数据和对象名的字段名一致，即可赋值到实体类中
- 提交方法：http://localhost:8080/user/t2?id=1&name=Aaron&age=10

8.2 数据回显

第一种：通过ModelAndView

//    返回ModelAndView
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("massage","Controller1");
        modelAndView.setViewName("hello");
        return modelAndView;
    }

第二种：通过Model

@RequestMapping("/{a}/{b}")
public String test1(@PathVariable int a,@PathVariable int b, Model model){
    int c = a + b;
    model.addAttribute("mas",c);
    return "hello";
}

第三种：通过ModelMap
- 与Model功能一样，Model是ModelMap的精简版
对比
1. Model 只有寥寥几个方法只适合储存数据，简化了新手对Model对象的操作和理解
2. ModelMap继承了LinkedMap，除了实现了自身的一些方法，同样的继承了LinkedMap的方法和特性;
3. ModelAndView 可在存储数据的同时，进行设置返回的逻辑视图。进行控制显示的跳转。
鸡汤：请使用80%的时间打好基础，剩下18%的时间研究框架，2%的时间去学点英文，框架的官方文档永远是最好的教程。

9、乱码问题

测试步骤：

在首页编写一个提交的表单

<form action="/e/t1" method="post">
  <input type="text" name="name">
  <input type="submit" value="Go">
</form>

在Controller编写处理类

@RequestMapping("/e/t1")
public String test(String name, Model model) {
    System.out.println(name);
    model.addAttribute("massage",name);
    return "test";
}

测试运行Tomcat

处理方法:

修改tomcat配置文件：设置编码！

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />

修改web.xml文件（需要重新启动Tomcat）

<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>

自定义过滤器【终极】

package com.bdqn.Encoding;
 
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;
 
/**
 * 解决get和post请求 全部乱码的过滤器
 */
public class GenericEncodingFilter implements Filter {
 
    public void destroy() {
    }
 
    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);
    }
 
    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;
    }
 
    // 对需要增强方法 进行覆盖
    @Override
    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乱码过滤器-->
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>com.bdqn.Encoding.GenericEncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

10、JSON

10.1 什么是json

JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，
采用文本格式来存储和表示数据

10.2 语法格式：

JSON键值对:

{"name": "QinJiang"}
{"age": "3"}
{"sex": "男"}

JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。

var obj = {a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串

JSON 和 JavaScript 对象互转

JSON字符串转换为JavaScript 对象,使用 JSON.parse() 方法：

var obj = JSON.parse('{"a": "Hello", "b": "World"}');
//结果是 {a: 'Hello', b: 'World'}

JavaScript 对象转换为JSON字符串，使用 JSON.stringify() 方法：

var json = JSON.stringify({a: 'Hello', b: 'World'});
//结果是 '{"a": "Hello", "b": "World"}'

10.3 代码测试

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Aaron</title>
</head>
<body>
 
<script type="text/javascript">
    //编写一个js的对象
    var user = {
        name:"Aaron",
        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>
 
</body>
</html>

10.4 Jackson使用

为了Controller返回JSON数据
JSON的解析工具

导入依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.11.3</version>
</dependency>

前端控制器（web,xml）

<!--    配置DispatchServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:Springmvc-jsons.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <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>

Spring配置文件

<?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">

    <!--    扫描controller包-->
    <context:component-scan base-package="com.bdqn.controller"/>
    <!--    过滤静态资源-->
    <mvc:default-servlet-handler/>
    <!--    注解支持-->
    <mvc:annotation-driven/>
    <!--    视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

Controller

@Controller
public class jsonController {
    @RequestMapping("/j1")
    @ResponseBody // 不让它走视图解析器
    public String json1() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        User user = new User(1,"陈赛飞",19);
        return mapper.writeValueAsString(user);
    }
}

测试（添加lib）

乱码解析！(解决JSON的乱码问题)

    <!--    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>

json返回时间

原生态java【推荐】

@RequestMapping("/j3")
public String json3() throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    Date date = new Date();
    // 设置格式
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd-HH:mm:ss");
    return mapper.writeValueAsString(simpleDateFormat.format(date));
}

使用ObjectMapper

@RequestMapping("/j4")
public String json4() throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    // 关闭时间戳
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
    // 自定义时间格式
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd-HH:mm:ss");
    // 注入
    mapper.setDateFormat(simpleDateFormat);
    Date date = new Date();

    return mapper.writeValueAsString(simpleDateFormat.format(date));
}

创建json工具类

采用方法重写，传递一个参数（对象或集合）转成json格式，传入两个参数（时间）转成json格式
工具类

public class JsonUtils {

    public static String getJson(Object o) {
        return getJson(o,"yyyy-mm-dd HH:mm:ss");
    }

    public static String getJson(Object o,String dateFormat){
        ObjectMapper mapper = new ObjectMapper();
        // 关闭时间戳
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        // 自定义时间格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateFormat);
        // 注入
        mapper.setDateFormat(simpleDateFormat);
        try {
            return mapper.writeValueAsString(o);
        }catch (Exception ex){
            ex.printStackTrace();
        }
        return null;
    }
}

时间转换json格式时调用时

// 使用ObjectMapper获取时间并返回
    @RequestMapping("/j4")
    public String json4() throws JsonProcessingException {
        Date date = new Date();
        return JsonUtils.getJson(date);
    }
}

对象或集合转换json格式时

@RequestMapping("/j1")
public String json1() throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    User user = new User(1,"Aaron",19);
    return mapper.writeValueAsString(user);
}

10.5 Fastjson使用

fastjson是阿里云开发的一款专门用java开发的包，可以方便json与javaBean对象的转换

fastjson的pom的依赖！

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.60</version>
</dependency>

fastjsoon 三个主要的类
1. 【JSONOnject代表json对象】
  - 内部是用Map接口实现的
2. 【JSONArray代表json对象数据】
  - 内部是由List接口中的方法来完成操作的
3. 【JSON代表JSONObject和JSONArray的转化】

代码测试

导入依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.60</version>
</dependency>

编写代码返回值用JSON.toJSONString(list);

@RequestMapping("/j5")
public String json5() throws JsonProcessingException {
    User user1 = new User(1,"Aaron",19);
    User user2 = new User(2,"Aaron",19);
    User user3 = new User(3,"Aaron",19);
    User user4 = new User(4,"Aaron",19);
    User user5 = new User(5,"Aaron",19);
    List<User> list = new ArrayList<User>();
    list.add(user1);
    list.add(user2);
    list.add(user3);
    list.add(user4);
    list.add(user5);
    String s = JSON.toJSONString(list);
    return s;
}

本文地址：https://blog.csdn.net/ThisAaron/article/details/109275364

相关标签： SSM学习日记 springmvc

上一篇： Spring依赖注入@AutoWired

下一篇： python爬虫爬取验证码并识别