SpringBoot返回Json数据_springboot返回json字符串

Spring Boot 返回 Json 数据

XML 文件的解析常见的解析工具有 DOM4j、JDOM 等，为了标准化 XML 文件解析，Java 中提出了 JAXP 规范，使用的解析模型有

1. DOM：将标记语言文档一次性加载进入内存中，在内存中形成一颗 DOM 树（服务器端常用）

• 优点：操作方便，可以对文档进行 CRUD 的所有操作

• 缺点：一次性加载进入内存形成 DOM 树，非常消耗资源

2. SAX：逐行读取，基于事件驱动（安卓终端常用）

• 优点：不消耗资源

• 缺点：只能读取，不能增删改

public class Test2
{
    public static void main(String\[] args) throws Exception
    {
        SAXParserFactory parserFactory = SAXParserFactory.newInstance();
        SAXParser saxParser = parserFactory.newSAXParser();
        final List < Student > studentList = new ArrayList < Student > ();
        //因为 SAX 解析并不缓存数据， 所以解析过程中的数据需要自行编程实现存储
        saxParser.parse("xml02/students.xml", new DefaultHandler()
        {
            private Student student = null;
            private int flag = 0;
            public void startElement(String uri, String localName, String qName, Attributes attributes)
            throws SAXException
            {
                if("student".equals(qName))
                {
                    student = new Student();
                    String id = attributes.getValue("id"); //获取当前标签的指定名称的属性 if(id!=null && id.trim().length()>0) student.setId(id);
                }
                else if("name".equals(qName)) flag = 1;
                else if("age".equals(qName)) flag = 2;
                else if("sex".equals(qName)) flag = 3;
            }
            @Override
            public void characters(char\[] ch, int start, int length) throws SAXException
            {
                String tmp = new String(ch, start, length);
                if(tmp != null && tmp.trim().length() > 0)
                {
                    if(flag == 1) student.setName(tmp.trim());
                    else if(flag == 2)
                    {
                        Integer kk = Integer.parseInt(tmp.trim());
                        student.setAge(kk);
                    }
                    else if(flag == 3) student.setSex(tmp.trim());
                }
            }
            @Override
            public void endElement(String uri, String localName, String qName) throws SAXException
            {
                flag = 0;
                if("student".equals(qName)) studentList.add(student);
            }
        });
        studentList.forEach(System.out::println);
    }
}
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

早期数据传输使用 xml 作为交互格式，例如 webservice 技术，但是由于 xml 解析比较麻烦，所以现在在项目开发中，在接口与接口之间以及前后端之间数据的传输都使用 Json 格式，在 Spring Boot 中接口返回 Json 格式的数据很简单，在 Controller 中使用@RestController 注解即可返回 Json 格式的数据，@RestController 也是 Spring Boot 新增的一个复合注解。

源代码：其中 Target、Retention 和 Documented 是元注解

@Target({ElementType.TYPE}) 用于声明注解可以使用在什么地方，Type 表示可以使用在类上

@Retention(RetentionPolicy.RUNTIME) 用于声明注解需要保持到什么阶段，Runtime 表示注解在编译生成的字节码中一直保持到运行时

@Documented

@Controller

@ResponseBody

public @interface RestController { String value() default “”; }

可以看出 @RestController 注解包含了原来的 @Controller 和 @ResponseBody 注解，使用过 Spring 对 @Controller 注解用于声明当前类是控制器类，@ResponseBody 注解是将返回的数据结构转换为 Json 格式。所以在默认情况下，使用了@RestController 注解即可将返回的数据结构转换成 Json 格式，Spring Boot 中默认使用的 Json 解析技术框架是 jackson。点开 pom.xml 中的 spring-boot-starter-web 依赖，可以看到一个 spring-boot-starter-json 依赖：

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-json</artifactId>

<scope>compile</scope> 
</dependency>
<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-json</artifactId>

<scope>compile</scope> </dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Spring Boot 中对依赖都做了很好的封装，可以看到很多 spring-boot-starter-xxx 系列的依赖，这是 Spring Boot 的特点之一，不需要人为去引入很多相关的依赖了，starter-xxx 系列直接都包含了所必要的依赖，所以再次点进去上面这个 spring-boot-starter-json 依赖，可以看到：

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<scope>compile</scope>
</dependency>

<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jdk8</artifactId>
<scope>compile</scope>
</dependency>

<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jsr310</artifactId>
<scope>compile</scope>
</dependency>

<dependency>
<groupId>com.fasterxml.jackson.module</groupId>
<artifactId>jackson-module-parameter-names</artifactId>
<scope>compile</scope>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Spring Boot 中默认使用的 json 解析框架是 jackson。默认的 jackson 框架对常用数据类型的转 Json 处理。

1.Spring Boot 默认对 Json 的处理

在实际项目中，常用的数据结构无非有类对象、List 对象、Map 对象，默认的 jackson 框架对这三个常用的数据结构都可以转成 json 的格式。
1.1 创建 User 实体类需要创建一个实体类 User。

public class User
{
    private Long id;
    private String username;
    private String password;
    /\* 省略 get、set 和带参构造方法 \*/
}
1
2
3
4
5
6
7

1.2 创建 Controller 类然后创建一个 Controller，分别返回 User 对象、List和 Map<String, Object>。

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/json")
public class JsonController {
    @RequestMapping("/user")
    public User getUser() {
        return new User(1, "闫峻", "123456");
    }

    @RequestMapping("/list")
    public List<User> getUserList() {
        List<User> userList = new ArrayList<>();
        User user1 = new User(1, "闫峻", "123456");
        User user2 = new User(2, "死胖子", "123456");
        userList.add(user1);
        userList.add(user2);
        return userList;
    }

    @RequestMapping("/map")
    public Map<String, Object> getMap() {
        Map<String, Object> map = new HashMap<>(3);
        User user = new User(1, "闫峻", "123456");
        map.put("作者信息", user);
        map.put("博客地址", "http://blog.yan.com");
        map.put("CSDN 地址", "http://blog.csdn.net/yanjun");
        map.put("粉丝数量", 4153);
        return map;
    }
}
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
34
35
36
37

1.3 测试不同数据类型返回的 json

写好了接口，分别返回了一个 User 对象、一个 List 集合和一个 Map 集合，其中 Map 集合中的 value 存的是不同的数据类型

在浏览器中输入：localhost:8080/json/user 返回 json：

{“id”:1,“username”:“闫峻”,“password”:“123456”}

在浏览器中输入：localhost:8080/json/list 返回 json：

[{“id”:1, “username”:“闫峻”, “password”:“123456”}, {“id”:2, “username”:“死胖子”, “password”:“123456”}]

在浏览器中输入：`localhost:8080/json/map 返回 json：

{" 作 者 信 息 " : {“id”:1, “username”:" 闫 峻 ", “password”:“123456”}, "CSDN 地 址 " :
“http://blog.csdn.net/yanjun”, “粉丝数量”:4153, “博客地址”:“http://blog.yan.com”}

可以看出 map 中不管是什么数据类型，都可以转成相应的 json 格式，这样就非常方便。

1.4 jackson 中对 null 的处理

在实际项目中，难免会遇到一些 null 值出现，转 json 时是不希望有这些 null 出现的，比如期望所有的 null 在转 json 时都变成""这种空字符串，那怎么做呢？在 Spring Boot 中做一下配置即可，新建一个 jackson 的配置类：

```java
    ```
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;

import java.io.IOException;

@Configuration //用于声明当前类是一个配置类，最新的注解为

@SpringBootConfiguration
public class JacksonConfig {
    @Bean
    //用于在配置类中,表示方法的返回值是一个受管 bean
    @Primary
    //如果多个配置，则以当前的为主
    @ConditionalOnMissingBean(ObjectMapper.class)
    //条件注解，表示如果受管 bean中没有,ObjectMapper类型的对象，则需要构建
    public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
        ObjectMapper objectMapper = builder.createXmlMapper(false).build();
        objectMapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
            @Override
            public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider)
                    throws IOException {
                jsonGenerator.writeString("");
               //针对 null 内容输出空字符串
            }
        });
        return objectMapper;
    }
}
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
34
35
36
37

然后修改一下上面返回 map 的接口， 将几个值改成 null 测试一下：

@RequestMapping("/map")
public Map<String, Object> getMap()
{
    Map<String, Object> map=new HashMap<>(3);
    User user=new User(1,"闫峻",null);
    map.put("作者信息",user);
    map.put("博客地址","<http://blog.yan.com>");
    map.put("CSDN 地址",null);
    map.put("粉丝数量",4153);
    return map;
}
1
2
3
4
5
6
7
8
9
10
11

重启项目再次输入 localhost:8080/json/map，可以看到 jackson 已经将所有 null 字段转成了空字符串了。例如返回数据为
{“作者信息”:{“id”:1,“username”:“闫峻”,“password”:“”},“CSDN 地址”:“”,“粉丝数量”:4153,“博客地址”:“http://blog.yan.com”}

配置属性不参与映射输出

@JsonIgnore 指定该属性不参与 JSON 字符串的映射 
private String password;
1
2

配置日期类型数据的映射格式:

@JsonFormat(pattern = "yyyy-MM-dd") 
private Date birth=new Date();
1
2

2.整合通用 Mapper 的开发方法

通用 mapper 就是基于 mybatis 的一款 MyBatis 增强插件，可以提供一些常用增、删、改、查的操作，不需要重复写一些常用的 sql。简化操作，精简代码，并且达到代码风格统一的目的。它的出现不是为了替代 mybatis，而是让 mybatis 的开发更方便。

添加依赖：

<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
<version>4.2.2</version> </dependency>
1
2
3
4

使用通用 mapper 的开发方式，采用注解定义映射关系，自动生成常见的 SQL 语句，不需要 xml 映射元文件

1.表名默认使用类名,驼峰转下划线(只对大写字母进行处理),如 TestUser 默认对应的表名为 test_user 2.表名可以使用@Table(name = “tableName”)进行指定,对不符合第一条默认规则的可以通过这种方式指定表名.

3.字段默认和@Column 一样,都会作为表字段,表字段默认为 Java 对象的 Field 名字驼峰转下划线形式.

4.可以使用@Column(name = “fieldName”)指定不符合第 3 条规则的字段名

5.使用@Transient 注解可以忽略字段,添加该注解的字段不会作为表字段使用.

6.建议一定是有一个@Id 注解作为主键的字段,可以有多个@Id 注解的字段作为联合主键.

7.默认情况下,实体类中如果不存在包含@Id 注解的字段,所有的字段都会作为主键字段进行使用(这种效率极低).

8.实体类可以继承使用,可以参考测试代码中的 tk.mybatis.mapper.model.UserLogin2 类.

9.由于基本类型,如 int 作为实体类字段时会有默认值 0,而且无法消除,所以实体类中建议不要使用基本类型.

10.@NameStyle 注解，用来配置对象名/字段和表名/字段之间的转换方式，该注解优先于全局配置 style，可选值：

normal:使用实体类名/属性名作为表名/字段名 camelhump:这是默认值，驼峰转换为下划线形式 uppercase:转换为大写 lowercase:转换为小写

@Entity //用于声明当前类是一个实体类
@Table(name = "tbl_users") // 用于声明当前类所对应的表名称
public class User implements Serializable {
    @Id //用于声明标识属性，对应表中的主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    声明主键生成策略
    private Long id;
    @Column //如果属性名称和列名称不一致，则需要通过@Column 进行配置对应的列名称 
    private String username;
    private String password;
    private Date birth;
    private Boolean sex;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

定义 mapper 接口

public interface UserMapper extends BaseMapper<User> { }
1

针对 mapper 接口进行注册，一般是依赖自动扫描实现。可以在主类或者配置上添加一个注解配置

SpringBoot 针对 Junit 的单元测试有很好的支持

@SpringBootTest
class CommonMapperApplicationTests
{
    @Autowired
    private UserMapper userMapper;
    @Test
    void contextLoads()
    {}
    @Test
    void testCreate()
    {
        User user = new User();
        user.setUsername("张三丰");
        user.setPassword("333333");
        user.setSex(true);
        int len = userMapper.insertSelective(user);
        Assertions.assertEquals(1, len);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

需要控制器调用业务，业务再通过 Mapper 访问数据库，最终返回 JSON 字符串

3.使用阿里巴巴 FastJson 的设置

3.1 jackson 和 fastJson 的对比

有很多人已经习惯于使用阿里巴巴的 fastJson 来做项目中 json 转换的相关工作，比如目前项目中使用的就是

阿里的 fastJson

关于 fastJson 和 jackson 的对比，网上有很多资料可以查看，主要是根据自己实际项目情况来选择合适的框架。从扩展上来看，fastJson 没有 jackson 灵活，从速度或者上手难度来看，fastJson 可以考虑，项目中目前使用的是阿里的 fastJson，挺方便的。

3.2 fastJson 依赖导入使用 fastJson 需要导入依赖

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
</dependency>
1
2
3
4

3.3 使用 fastJson 处理 null 使用 fastJson 时，对 null 的处理和 jackson 有些不同，需要继承 WebMvcConfigurationSupport 类或者实现 WebMvcConfiguration 接口，然后覆盖 configureMessageConverters 方法，在方法中可以选择对要实现 null 转换的场景，配置好即可。

import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

@Configuration
public class fastJsonConfig extends WebMvcConfigurationSupport {
    //使用阿里 FastJson 作为 JSON MessageConverter
    @Override
    public void configureMessageConverters(List\ <HttpMessageConverter\ <?>>converters) {
        FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
        FastJsonConfig config = new FastJsonConfig();
        config.setSerializerFeatures(SerializerFeature.WriteMapNullValue, // 保留 map 空的字段
                SerializerFeature.WriteNullStringAsEmpty, // 将 String 类型的 null 转成""
                SerializerFeature.WriteNullNumberAsZero, // 将 Number 类型的 null 转成 0
                SerializerFeature.WriteNullListAsEmpty, // 将 List 类型的 null 转成[]
                SerializerFeature.WriteNullBooleanAsFalse, // 将 Boolean 类型的 null 转成 false
                SerializerFeature.DisableCircularReferenceDetect); // 避免循环引用
        converter.setFastJsonConfig(config);
        converter.setDefaultCharset(Charset.forName("UTF-8"));
        List<MediaType> mediaTypeList = new ArrayList<>();
        // 解决中文乱码问题，相当于在 Controller 上的@RequestMapping 中加了个属性 produces = "application/json" mediaTypeList.add(MediaType.APPLICATION_JSON); converter.setSupportedMediaTypes(mediaTypeList); converters.add(converter);
    }
}
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

测试工具 postman

如果直接测试，则需要编写页面和 js 代码才能进行验证，可以使用 postman 避免这些繁琐的操作

这里针对日期类型数据的格式转换会有报错。最终提交数据为

{“username”:“谢逊”,“sex”:“true”,“birth”:“1989-02-03”,“password”:“666666”}

4. 封装统一返回的数据结构

在实际项目中，除了要封装数据之外，往往需要在返回的 json 中添加一些其他信息，比如返回一些状态码 code 【注意不是 response 的响应状态码】，返回一些 msg 给调用者，这样调用者可以根据 code 或者 msg 做一些逻辑判断。所以在实际项目中，需要封装一个统一的 json 返回结构存储返回信息。

4.1 定义统一的 json 结构

由于封装的 json 数据的类型不确定，所以在定义统一的 json 结构时需要用到泛型。统一的 json 结构中属性包括数据、状态码、提示信息即可，构造方法可以根据实际业务需求做相应的添加即可，一般来说，应该有默认的返回结构，也应该有用户指定的返回结构。

public class JsonResult<T> {
    private T data; //需要传递的数据
    private int code; //用户自定义相应码，注意不是服务器响应状态码。如果不需要传递详细信息还可以使用 boolean success;
    private String msg; // 服务器回传信息

    public JsonResult() {
        //若没有数据返回，默认状态码为 0，提示信息为：操作成功！
        this.code = 0;
        this.msg = "操作成功！";
    }

    public JsonResult(int code, String msg) {
        //若没有数据返回，可以人为指定状态码和提示信息 
        this.code = code;
        this.msg = msg;
    }

    public JsonResult(T data) {
        //有数据返回时，状态码为 0，默认提示信息为：操作成功！
        this.data = data;
        this.code = 0;
        this.msg = "操作成功！";
    }

    public JsonResult(T data, String msg) {
        //有数据返回，状态码为 0，人为指定提示信息 
        this.data = data;
        this.code = 0;
        this.msg = msg;
    }
    // 省略 get 和 set 方法
}
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

4.2 修改 Controller 中的返回值类型及测试

由于 JsonResult 使用了泛型，所以所有的返回值类型都可以使用该统一结构，在具体的场景将泛型替换成具体的数据类型即可，非常方便，也便于维护。在实际项目中，还可以继续封装，比如状态码和提示信息可以定义一个枚举类型，以后只需要维护这个枚举类型中的数据即可。根据以上的 JsonResult 可以改写一下 Controller

@RestController

@RequestMapping("/jsonresult")
public class JsonResultController {
    @RequestMapping("/user")
    public JsonResult<User> getUser() {

        User user = new User(1, "闫峻", "123456");

        return new JsonResult<>(user);

    }

    @RequestMapping("/list")

    public JsonResult<List> getUserList() {

        List<User> userList = new ArrayList<>();

        User user1 = new User(1, "闫峻", "123456");

        User user2 = new User(2, "死胖子", "123456");

        userList.add(user1);
        userList.add(user2);

        return new JsonResult<>(userList, "获取用户列表成功");

    }

    @RequestMapping("/map")
    public JsonResult<Map> getMap() {

        Map<String, Object > map = new HashMap<>(3);
        User user = new User(1, "闫峻", null);
        map.put("作者信息", user);

        map.put("博客地址", "<http://blog.yan.com>");
        map.put("CSDN 地址", null);
        map.put("粉丝数量", 4153);
        return new JsonResult<>(map);
    }

}
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
34
35
36
37
38
39
40
41
42
43
44

重新在浏览器中输入：localhost:8080/jsonresult/user 返回 json：

{“code”:0,“data”:{“id”:1,“password”:“123456”,“username”:“闫峻”},“msg”:“操作成功！”} 输入：localhost:8080/jsonresult/list，返回 json 格式：

{“code”:0, “data”:[{“id”:1, “password”:“123456”, “username”:" 闫峻 "}, {“id”:2, “password”:“123456”,

“username”:“死胖子”}], “msg”:“获取用户列表成功”} 输入：localhost:8080/jsonresult/map，返回 json 格式：

{“code”:“0”, “data”:{“作者信息”:{“id”:1, “password”:“”,“username”:“闫峻”},“CSDN 地址”:null,“粉丝数量”:4153,“博客地址”:“http://blog.yan.com”},“msg”:“操作成功！”}

通过封装，不但将数据通过 json 传给前端或者其他接口，还带上了状态码和提示信息，这在实际项目场景中应用非常广泛。

5. 总结

这里主要是对 Spring Boot 中 json 数据的返回做了详细的分析，从 Spring Boot 默认的 jackson 框架到阿里的 fastJson 框架，分别对它们的配置做了相应的描述。另外，结合实际项目情况，总结了实际项目中使用的 json 封装结构体，加入了状态码和提示信息，使得返回的 json 数据信息更加完整。