文章目录

Controller类，返回JSON数据(Jackson)【一个不乱码的对象】
扩展

Controller类，返回JSON数据(Jackson)【一个不乱码的对象】

Jackson应该是目前比较好的json解析工具了

当然工具不止这一个，比如还有阿里巴巴的 fastjson 等等。

1. 使用Jackson，需要额外导入pom依赖：jackson-databind

<!--jackson依赖-json解析工具-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.3</version>
</dependency>

2. 配置web.xml：注册DispatcherServlet、自带的过滤器

<servlet>
    <!--配置DispatcherServlet:这是个springmvc的核心：请求分发器，请前端控制器-->
    <servlet-name>spring-mvc</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>
<servlet-mapping>
    <!-- / 匹配所有的请求：（不包括jsp)-->
    <!-- /* 匹配所有的请求：（包括jsp)  不要用这个会404-->
    <servlet-name>spring-mvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>


<!--配置SpringMVC的中文乱码过滤-->
<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>
    <!--/ 匹配所有的请求：（不包括jsp)-->
    <!--/* 匹配所有的请求：（包括jsp)-->
    <url-pattern>/*</url-pattern>
</filter-mapping>

3. 配置springmvc-servlet.xml 【含jackson乱码的解决配置】

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

    <mvc:default-servlet-handler />


    <!--
    支持mvc注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系
        要想使@RequestMapping注解生效
        必须向上下文中注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
     -->
    <mvc:annotation-driven />



    <!--解决返回字符串（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>



    
    <!--视图解析器-->
    <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. 编写一个User的实体类

package com.kuang.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
//需要导入lombok
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private int age;
}

5. 在Artifacts中导入lib

6. 在com.kuang.controller包下，创建 UserController类

这里我们需要两个新东西，一个是@ResponseBody，一个是ObjectMapper对象，我们看下具体的用法

方法一：使用 @Controller + @ResponseBody

@ResponseBody：不会走视图解析器，会返回一个字符串

@Controller
public class UserController {

   @RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")//prodeces后面的，能防止乱码
   @ResponseBody
   public String json1() throws JsonProcessingException {
        //创建一个对象
        User user = new User(3,"张三",18);
//        Jackson-json解析工具,对象转为json格式
        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(user);
        return json;
   }
  
}

方法二：@RestController：类下的返回值只会返回字符串【推荐使用】

@RestController：效果相当于@Controller配合@ResponseBody

@RestController//类下的返回值只会返回字符串，效果相当于@Controller配合@ResponseBody
public class UserController {

	//produces可不要
    @RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")
    public String json1() throws JsonProcessingException {
        //创建一个对象
        User user = new User(3,"张三",18);

        //Jackson-json解析工具,对象转为json格式
        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(user);
        return json;//返回值简写为一行 new ObjectMapper().writeValueAsString(user);
    }
}

使用方法二，要在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>

扩展

1. 输出数组对象（即多个对象）

@RequestMapping("/j2")
    public String json2() throws JsonProcessingException {
        //创建对象
        User user1 = new User(3,"张三1",18);
        User user2 = new User(3,"张三2",18);
        User user3 = new User(3,"张三3",18);
        //创建集合，并把对象放入集合
        List<User> userList = new ArrayList<User>();
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
     //Jackson-json解析工具,对象转为json格式
        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(userList);
        return json;//返回值简写为一行 new ObjectMapper().writeValueAsString(userList);
    }

2.输出时间对象

第一种方法：【java代码，容易理解】

ObjectMapper解析时间对象后会转换为默认格式Timestamp:时间戳(时间戳是北京时间1970年01月01日08时00分00秒起至现在的总毫秒数)：先自定义定日期格式并把日期对象转换为日期字符串，日期字符串转为json字符串。

   //1.java方式获取时间对象格式转换为json字符串
    @RequestMapping(value = "/j3")
    public static String json3() throws JsonProcessingException {
        //Jackson-json解析工具,对象转为json格式
        //ObjectMapper解析时间对象后会转换为默认格式Timestamp:时间戳(时间戳是北京时间1970年01月01日08时00分00秒起至现在的总毫秒数)
        ObjectMapper mapper = new ObjectMapper();
        //获取当前日期
        Date date = new Date();
        //自定义日期的格式:如果不自定义日期格式用ObjectMapper解析时间后会转换为默认格式Timestamp:
        // 时间戳(时间戳是北京时间1970年01月01日08时00分00秒起至现在的总毫秒数)
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //当前日期格式字符串
        String dateFormat = sdf.format(date);
        //转换为json字符串日期格式
        String jsonDate = mapper.writeValueAsString(dateFormat);

        return jsonDate;
    }

第二种方法

把ObjectMapper解析时间对象后会转换为默认格式Timestamp:时间戳关闭，并为ObjectMapper设置指定日期格式，把当前日期对象转换为指定日期格式json字符串。

    @RequestMapping(value = "/j4")
    public String json4() throws JsonProcessingException {
        //Jackson-json解析工具,对象转为json格式
        ObjectMapper mapper = new ObjectMapper();
        //不使用时间戳的方式,默认使用时间戳,改为false不使用时间戳,
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //自定义日期格式对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //ObjectMapper设置指定日期格式
        mapper.setDateFormat(sdf);
        //获取当前日期
        Date date = new Date();
        String json = mapper.writeValueAsString(date);
        return json;
    }

第三种方式：抽取为工具类JsonUtils

如果要经常使用的话，可以将这些代码封装到一个工具类中

com.kuang.utils包下

//json日期格式工具
//json日期格式工具
public class JsonUtils {
    
    //方法重载使用:只传一个参数
    public static String getJson(Object object){
        //返回格式为"yyyy-MM-dd HH:mm:ss"
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }


    //传日期对象和日期格式
    public static String getJson(Object object,String dateFormat){
        ObjectMapper objectMapper = new ObjectMapper();
        //不使用时间戳的方式,默认使用时间戳,改为false不使用时间戳,
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //把传来的日期格式放入
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        //把传来的对象设置为指定日期格式
        objectMapper.setDateFormat(sdf);
        try {
            return objectMapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

com.kuang.controller包下编写方法

    //使用自己写的Json工具类
    @RequestMapping(value = "/j5")
    public String json5() throws JsonProcessingException {
        //获取当前日期
        Date date = new Date();

        //自定义格式:传两个值
        //String json = JsonUtil.getJson(date, "yyyy-MM-dd HH:mm:ss");

        
        //传一个值默认格式为"yyyy-MM-dd HH:mm:ss"
        String json2 = JsonUtils.getJson(date);
        return json2;
    }

原文链接：https://blog.csdn.net/weixin_42214698/article/details/121430969