SpringMVC

最新推荐文章于 2024-10-06 20:16:20 发布

QQ星小天才

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量85

点赞数

分类专栏： SprinMVC 文章标签： java spring mvc

本文链接：https://blog.csdn.net/weixin_46051467/article/details/121034430

版权

SprinMVC 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

这篇博客详细介绍了SpringMVC的基本配置，包括传统XML配置和注解配置方式。讲解了结果跳转的三种方式，即ModelAndView、ServletAPI和SpringMVC内置方法，并提供了示例代码。此外，还涵盖了数据处理的接收和返回，以及处理乱码问题的解决方案。最后，讨论了Jackson和fastJson在JSON序列化和反序列化中的应用。

摘要由CSDN通过智能技术生成

SpringMVC笔记

SpringMVC笔记

SpringMVC笔记

1、第一个SpringMVC

1.1 配置版

导包

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.9.RELEASE</version>
</dependency>

<!-- 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.jsp.jstl/jstl-api -->
<dependency>
    <groupId>javax.servlet.jsp.jstl</groupId>
    <artifactId>jstl-api</artifactId>
    <version>1.2</version>
</dependency>

<!--标签库-->
<!-- https://mvnrepository.com/artifact/taglibs/standard -->
<dependency>
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>
</dependency>

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.26</version>
</dependency>

新建Moudle，添加web支持
SpringMVC依赖

配置web.xml，注册DispatcherServlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/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的配置文件:【servlet-name】-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-1-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--/ 匹配所有的请求；（不包括.jsp）-->
    <!--/* 匹配所有的请求；（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

编写SpringMVC配置文件springmvc-servlet.xml

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

添加处理器映射器

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

添加处理器适配器

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

添加视图解析器

<!--视图解析器:DispatcherServlet给他的ModelAndView-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
    <!--前缀-->
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <!--后缀-->
    <property name="suffix" value=".jsp"/>
</bean>

编写业务Controller层，实现Controller接口

package com.wang.controller;

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

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

//注意：这里我们先导入Controller接口
public class HelloController implements Controller {

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

        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg","HelloSpringMVC1!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }
    
}

跳转jsp页面

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

在springmvc-servlet.xml中添加映射

    <!--Controller-->
    <bean id="/hello" class="com.wang.controller.HelloController"/>

可能遇到的问题：访问出现404，排查步骤：

查看控制台输出，看一下是不是缺少了什么jar包。
如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖！（与classes同级目录）
重启Tomcat 即可解决！

1.2 注解版

**第一步:新建一个Moudle , 添加web支持！**建立包结构 com.wang.controller

第二步:由于Maven可能存在资源过滤的问题，我们将配置完善

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

第三步:在pom.xml文件引入相关的依赖：
主要有Spring框架核心库、Spring MVC、servlet , JSTL等。我们在父依赖中已经引入了！

第四步:配置web.xml

注意点：

注意web.xml版本问题，要最新版！
注册DispatcherServlet
关联SpringMVC的配置文件
启动级别为1

映射路径为 / 【不要用/*，会404】

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!--1.注册servlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!-- 启动顺序，数字越小，启动越早 -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--所有请求都会被springmvc拦截 -->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

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

第五步:添加Spring MVC配置文件

让IOC的注解生效
静态资源过滤：HTML . JS . CSS . 图片，视频 …
MVC的注解驱动
配置视图解析器

在resource目录下添加springmvc-servlet.xml配置文件，配置的形式与Spring容器配置基本类似，为了支持基于注解的IOC，设置了自动扫描包的功能，具体配置信息如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.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.kuang.controller"/>
    <!-- 让Spring MVC不处理静态资源 过滤掉一些静态资源，如.css  .js  .html .mp3-->
    <mvc:default-servlet-handler />
    <!--
    支持mvc注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系
        要想使@RequestMapping注解生效
        必须向上下文中注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
     -->
    <mvc:annotation-driven />

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

</beans>

在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。

第六步:创建Controller

编写一个Java控制类： com.wang.controller.HelloController , 注意编码规范

package com.wang.controller;

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

@Controller
@RequestMapping("/HelloController")//多添加一级访问
public class HelloController {

    //真实访问地址 : 项目名/HelloController/hello
    @RequestMapping("/hello")//请求路径
    public String sayHello(Model model) {
        //向模型中添加属性msg与值，可以在JSP页面中取出并渲染
        model.addAttribute("msg", "hello,SpringMVC");
        //会被视图解析器处理，web-inf/jsp/hello.jsp
        return "hello";
    }
}

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

第七步:创建视图层

在WEB-INF/ jsp目录中创建hello.jsp ，视图可以直接取出并展示从Controller带回的信息；

可以通过EL表示取出Model中存放的值，或者对象；

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

第八步:配置Tomcat运行

配置Tomcat ，开启服务器，访问对应的请求路径！

2、SpringMVC：结果跳转三种方式(转发、重定向)

2.1 ModelAndView

设置ModelAndView对象 , 根据view的名称 , 和视图解析器跳到指定的页面 .

页面 : {视图解析器前缀} + viewName +{视图解析器后缀}

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

对应的controller类

public class ControllerTest1 implements Controller {

    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //返回一个模型视图对象
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","ControllerTest1");
        mv.setViewName("test");
        return mv;
    }
}

2.2 ServletAPI

通过设置ServletAPI , 不需要视图解析器 .

通过HttpServletResponse进行输出
通过HttpServletResponse实现重定向
通过HttpServletResponse实现转发

@Controller
public class ResultGo {

    @RequestMapping("/result/t1")
    public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
        rsp.getWriter().println("Hello,Spring BY servlet API");
    }

    @RequestMapping("/result/t2")
    public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
        rsp.sendRedirect("/index.jsp");
    }

    @RequestMapping("/result/t3")
    public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception {
        //转发
        req.setAttribute("msg","/result/t3");
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);
    }

}

2.3 SpringMVC

通过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";
    }
}

通过SpringMVC来实现转发和重定向 - 有视图解析器；

重定向 , 不需要视图解析器 , 本质就是重新请求一个新地方嘛 , 所以注意路径问题.

可以重定向到另外一个请求实现 .

@Controller
public class ResultSpringMVC2 {
    @RequestMapping("/rsm2/t1")
    public String test1(){
        //转发
        return "test";
    }

    @RequestMapping("/rsm2/t2")
    public String test2(){
        //重定向
        return "redirect:/index.jsp";
        //return "redirect:hello.do"; //hello.do为另一个请求/
    }

}

3、数据处理（接受和回返）

3.1 处理提交数据

1、提交的域名称和处理方法的参数名一致

提交数据 : http://localhost:8080/hello?name=qeqwqw

处理方法 :

@RequestMapping("/hello")
public String hello(String name){
    System.out.println(name);
    return "hello";
}

后台输出 : qeqwqw

2、提交的域名称和处理方法的参数名不一致

提交数据 : http://localhost:8080/hello?username=qeqwqw

处理方法 :

//@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/user?name=wangdaw&id=1&age=15

处理方法 :

@RequestMapping("/user")
public String user(User user){
    System.out.println(user);
    return "hello";
}

后台输出 : User { id=1, name=‘wangdaw’, age=15 }

说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。

3.2 数据显示到前端

第一种 : 通过ModelAndView

我们前面一直都是如此 . 就不过多解释

public class ControllerTest1 implements Controller {

    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //返回一个模型视图对象
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","ControllerTest1");
        mv.setViewName("test");
        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("/ct2/hello")
public String hello(@RequestParam("username") String name, Model model){
    //封装要显示到视图中的数据
    //相当于req.setAttribute("name",name);
    model.addAttribute("msg",name);
    System.out.println(name);
    return "test";
}

3.3 对比

就对于新手而言简单来说使用区别就是：

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；

ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；

ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

4、乱码问题

我们可以使用SpringMVC的过滤器

在web.xml中进行配置

<filter>
    <filter-name>filte</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>filte</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

使用" /* "是为了让它作用到所有的页面，包括jsp文件

我们还可以自定义过虑器

创建一个实现过虑器接口的类

package com.wang.filte;

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;

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

        // 对需要增强方法 进行覆盖

        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();
        }

        //取一个值

        public String getParameter(String name) {
            Map<String, String[]> parameterMap = getParameterMap();
            String[] values = parameterMap.get(name);
            if (values == null) {
                return null;
            }
            return values[0]; // 取回参数的第一个值
        }

        //取所有值

        public String[] getParameterValues(String name) {
            Map<String, String[]> parameterMap = getParameterMap();
            String[] values = parameterMap.get(name);
            return values;
        }
    }

一个大佬写的，我搬运的

然后在web.xml中进行配置

<!--自定义filte-->
<filter>
    <filter-name>filte1</filter-name>
    <filter-class>com.wang.filte.GenericEncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>filte1</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
<!--/*  表示匹配所有 包括.jsp
    /   不包括.jsp

-->

基本可以解决乱码问题，如果还不行，就在找其他大佬吧

5、JSON

JSON ( JS对象标记) 是一种轻量级的数据交换格式
采用完全独立于编程语言的文本格式来储存和表示数据
简洁和清晰的层次结构使得JSON成为理想的数据交换语言
提升网络传输效率

在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。看看他的要求和语法格式：

对象表示为键值对，数据由逗号分隔
花括号保存对象
方括号保存数组

JSON 键值对是用来保存 JavaScript 对象的一种方式，和 JavaScript 对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号 “” 包裹，使用冒号 : 分隔，然后紧接着值：

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

5.1 Jackson的使用

Controller返回JSON数据

使用Jackson，需要导包

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.3</version>
</dependency>

配置好我们的项目
添加User实体类

package com.wang.pojo;

public class User {
    private int id;
    private String name;
    private int age;

    public User() {
    }

    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

编写Controller

package com.wang.cotroller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.wang.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@Controller
//@RestController  不使用视图解析器 ，与下面的@ResponseBody用法一样
public class json {


    @RequestMapping("/j1")
    @ResponseBody //不使用视图解析器，直接在localhost8080://项目名/j1 显示返回的字符串
    public String json1() throws JsonProcessingException {

        //jackson的对象
        ObjectMapper mapper=new ObjectMapper();

        //User对象
        User user=new User(1,"旁顾",35);

        mapper.writeValueAsString(user);


        return mapper.writeValueAsString(user);
    }

}

测试结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oqlSn3sW-1635489622994)(image-20211028175554575.png)]

然后我们发现，我们的输出有乱码

解决乱码的方式：

在我们的注解中配置json的编码格式

@RequestMapping(value = "/j1" ,produces = "application/json;charset=utf-8")

在我们的springmvc-servlet.xml中配置

 <!--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返回时间

//将时间转成json格式
@RequestMapping(value = "/j2" ,produces = "application/json;charset=utf-8")
@ResponseBody //不使用视图解析器，直接在localhost8080://项目名/j2 显示返回的字符串
public String json2() throws JsonProcessingException {

    //jackson的对象
    ObjectMapper mapper=new ObjectMapper();

    Date date=new Date();
    

    return  mapper.writeValueAsString(date);
}

测试结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SaXNRoGQ-1635489622995)(image-20211028180541897.png)]

我们发现我们转换的是一种时间戳格式

如果我们想要那种正常的格式，我们还需要进行优化

//将时间转成json格式
@RequestMapping(value = "/j2" ,produces = "application/json;charset=utf-8")
@ResponseBody //不使用视图解析器，直接在localhost8080://项目名/j2 显示返回的字符串
public String json2() throws JsonProcessingException {

    //jackson的对象
    ObjectMapper mapper=new ObjectMapper();

    Date date=new Date();

    //改变时间格式
    SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

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

测试结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nAX6J770-1635489622998)(image-20211028181135147.png)]

我们还有一种方式可以输出正常的时间格式

使用jackson自带的方法进行设置

@RequestMapping(value = "/j3" ,produces = "application/json;charset=utf-8")
@ResponseBody //不使用视图解析器，直接在localhost8080://项目名/j3 显示返回的字符串
public String json3() throws JsonProcessingException {

    //jackson的对象
    ObjectMapper mapper=new ObjectMapper();

    //不使用时间戳的方式  将使用时间戳改为false
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);

    Date date=new Date();

    //改变时间格式
    SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    mapper.setDateFormat(simpleDateFormat);


    return  mapper.writeValueAsString(date);
}

测试结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ovqET7Qz-1635489622999)(image-20211028181728939.png)]

我们最后可以将我们的json进行代码优化，编写成为一个工具类

package com.wang.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

public class JsonUtil {

    //返回字符串
    public static String getJson(Object object) throws JsonProcessingException {
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    //返回时间
    public static String getJson(Object object, String simpleDateFormat) throws JsonProcessingException {

        ObjectMapper mapper=new ObjectMapper();
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        SimpleDateFormat sdf=new SimpleDateFormat(simpleDateFormat);
        mapper.setDateFormat(sdf);
        return mapper.writeValueAsString(object);
    }
}

上面是我们写工具类所用到的思想，多多思考

测试：

@RequestMapping(value = "/j4" ,produces = "application/json;charset=utf-8")
@ResponseBody //不使用视图解析器，直接在localhost8080://项目名/j3 显示返回的字符串
public String json4() throws JsonProcessingException {

    User user1 = new User(1, "网二", 34);
    User user2 = new User(2, "沙雕", 43);
    User user3 = new User(3, "迪迦", 56);
    User user4 = new User(4, "雷猴", 67);
    List<User> list = new ArrayList<User>();
    list.add(user1);
    list.add(user2);
    list.add(user3);
    list.add(user4);
    return JsonUtil.getJson(list);
}

结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uIPBhlRk-1635489623001)(image-20211028183558869.png)]

5.2 fastJson

astjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。

我们需要导包

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

fastjson 三个主要的类：

【JSONObject 代表 json 对象】
- JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
- JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。
【JSONArray 代表 json 对象数组】
- 内部是有List接口中的方法来完成操作的。
【JSON 代表 JSONObject和JSONArray的转化】
- JSON类源码分析与使用
- 仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

ic String json4() throws JsonProcessingException {

User user1 = new User(1, "网二", 34);
User user2 = new User(2, "沙雕", 43);
User user3 = new User(3, "迪迦", 56);
User user4 = new User(4, "雷猴", 67);
List<User> list = new ArrayList<User>();
list.add(user1);
list.add(user2);
list.add(user3);
list.add(user4);
return JsonUtil.getJson(list);

}


结果

[外链图片转存中...(img-uIPBhlRk-1635489623001)]





### 5.2 fastJson



astjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。



我们需要导包

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

fastjson 三个主要的类：

【JSONObject 代表 json 对象】
- JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
- JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。
【JSONArray 代表 json 对象数组】
- 内部是有List接口中的方法来完成操作的。
【JSON 代表 JSONObject和JSONArray的转化】
- JSON类源码分析与使用
- 仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。