精华内容
下载资源
问答
  • 主要介绍了SpringBoot返回json数据的实现方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • springboot返回json数据

    2020-12-17 17:22:02
    默认情况下,当创建一个springboot项目时,添加了web依赖,这个依赖默认加入了jackson-databind作为JSON处理器,此时不需要添加额外的JSON处理器就能返回一段JSON了 创建一个Book实体类 package ...

    JSON是目前主流的前后端数据传输方式。默认情况下,当创建一个springboot项目时,添加了web依赖,这个依赖默认加入了jackson-databind作为JSON处理器,此时不需要添加额外的JSON处理器就能返回一段JSON了

    在这里插入图片描述

    创建一个Book实体类

    package com.example.jsonexer.entity;
    
    import lombok.Data;
    
    import java.util.Date;
    
    
    @Data
    public class Book {
    
        private String name;
        private String author;
        private Float price;
        private Date publicationDate;
    
    
    }
    
    

    创建BookController,返回Book对象

    @RestController
    public class BookController {
    
    
        @GetMapping("/book")
        public Book book(){
            Book book= new Book();
            book.setAuthor("罗贯中");
            book.setName("三国演义");
            book.setPrice(30f);
            book.setPublicationDate(new Date());
            return book;
    
        }
    }
    
    

    在浏览器中输入“http://localhost:8080/book”,即可看到返回的JSON数据,如图所示
    在这里插入图片描述

    FastJson使用

    package com.example.jsonexer.entity;
    
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    @Data
    @AllArgsConstructor
    public class Student {
    
        private int id;
        private String name;
        private int age;
    
    }
    
    
    package com.example.jsonexer.entity;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    
    import java.util.List;
    
    @Data
    @AllArgsConstructor
    
    public class Teacher {
    
        private int id;
        private String name;
    
        private List<Student> students;
    
    
    }
    
    

    测试:

    package com.example.jsonexer;
    
    import com.alibaba.fastjson.JSON;
    import com.example.jsonexer.entity.Student;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class JsonexerApplicationTests {
    
        @Test
        public void testJson() {
            Student student = new Student(0,"zhangsan",22);
            System.out.println(JSON.toJSONString(student));
        }
    
    }
    
    

    输出结果:

    {"age":22,"id":0,"name":"zhangsan"}
    

    输出的json格式与类Student中定义的属性其实是不一致的,这个其实不影响我们生成以及后面的解析,因为他有严格的get和set方法定义。

    @Test
        public void testJson2(){
            List<Student> stus = new ArrayList<Student>();
            for(int i = 0; i < 5; i++){
                Student student = new Student(i,"Student" + i,18 + i);
                stus.add(student);
            }
    
            System.out.println(JSON.toJSONString(stus));
        }
    

    输出结果:

    [{"age":18,"id":0,"name":"Student0"},{"age":19,"id":1,"name":"Student1"},{"age":20,"id":2,"name":"Student2"},{"age":21,"id":3,"name":"Student3"},{"age":22,"id":4,"name":"Student4"}]
    
    @Test
        public void testJson3(){
    
            List<Teacher> teachers = new ArrayList<>();
            long time = System.currentTimeMillis();
            for(int i = 0; i < 10; i++){
                Teacher teacher = new Teacher(i,"Teacher" + i);
                List<Student> stus = new ArrayList<Student>();
                for(int j = 0; j < 4; j++){
                    Student s = new Student(j,"Student" + j, 18 + j);
                    stus.add(s);
    
                }
                teacher.setStudents(stus);
                teachers.add(teacher);
            }
            String json = JSON.toJSONString(teachers);
            System.out.println("fastjson= " + json);
    
        }
    

    输出结果:

    fastjson= [{"id":0,"name":"Teacher0","students":[{"age":18,"id":0,"name":"Student0"},{"age":19,"id":1,"name":"Student1"},
    

    FastJson基本使用

    FastJson

    使用fastjson对Json的基本操作

    展开全文
  • springboot返回json数据对属性为null值的处理 参考网址: https://mp.weixin.qq.com/s/y7RXiF9ENxYnLWN_jdWbRg Spring Boot返回Json数据及数据封装 本来已收录到我写的10万字Springboot经典学习笔记中,笔记在持续...

    springboot返回json数据对属性为null值的处理

    参考网址:

    https://mp.weixin.qq.com/s/y7RXiF9ENxYnLWN_jdWbRg

    Spring Boot返回Json数据及数据封装

    本来已收录到我写的10万字Springboot经典学习笔记中,笔记在持续更新……文末有领取方式

    在项目开发中,接口与接口之间,前后端之间数据的传输都使用 Json 格式,在 Spring Boot 中,接口返回 Json 格式的数据很简单,在 Controller 中使用@RestController注解即可返回 Json 格式的数据,@RestController也是 Spring Boot 新增的一个注解,我们点进去看一下该注解都包含了哪些东西。

    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.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>
        <version>2.0.3.RELEASE</version>
        <scope>compile</scope>
    </dependency>
    

    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>
        <version>2.9.6</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.datatype</groupId>
        <artifactId>jackson-datatype-jdk8</artifactId>
        <version>2.9.6</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.datatype</groupId>
        <artifactId>jackson-datatype-jsr310</artifactId>
        <version>2.9.6</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.module</groupId>
        <artifactId>jackson-module-parameter-names</artifactId>
        <version>2.9.6</version>
        <scope>compile</scope>
    </dependency>
    

    到此为止,我们知道了 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 创建Controller类

    然后我们创建一个 Controller,分别返回 User对象、List<User>Map<String, Object>

    import com.itcodai.course02.entity.User;
    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.itcodai.com");
            map.put("CSDN地址", "http://blog.csdn.net/eson_15");
            map.put("粉丝数量", 4153);
            return map;
        }
    }
    

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

    OK,写好了接口,分别返回了一个 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/eson_15","粉丝数量":4153,"博客地址":"http://blog.itcodai.com"}
    

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

    1.4 jackson 中对null的处理

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

    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
    public class JacksonConfig {
        @Bean
        @Primary
        @ConditionalOnMissingBean(ObjectMapper.class)
        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("");
                }
            });
            return objectMapper;
        }
    }
    

    然后我们修改一下上面返回 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.itcodai.com");
        map.put("CSDN地址", null);
        map.put("粉丝数量", 4153);
        return map;
    }
    

    重启项目,再次输入:localhost:8080/json/map,可以看到 jackson 已经将所有 null 字段转成了空字符串了。

    {"作者信息":{"id":1,"username":"曹操","password":""},"CSDN地址":"","粉丝数量":4153,"博客地址":"http://blog.itcodai.com"}
    

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

    2.1 jackson 和 fastJson 的对比

    有很多朋友习惯于使用阿里巴巴的 fastJson 来做项目中 json 转换的相关工作,目前我们项目中使用的就是阿里的 fastJson,那么 jackson 和 fastJson 有哪些区别呢?根据网上公开的资料比较得到下表。

    选项fastJsonjackson
    上手难易程度容易中等
    高级特性支持中等丰富
    官方文档、Example支持中文英文
    处理json速度略快

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

    2.2 fastJson依赖导入

    使用 fastJson 需要导入依赖,本课程使用 1.2.35 版本,依赖如下:

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

    2.2 使用 fastJson 处理 null

    使用 fastJson 时,对 null 的处理和 jackson 有些不同,需要继承 WebMvcConfigurationSupport 类,然后覆盖 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
         * @param converters
         */
        @Override
        public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
            FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
            FastJsonConfig config = new FastJsonConfig();
            config.setSerializerFeatures(
                    // 保留map空的字段
                    SerializerFeature.WriteMapNullValue,
                    // 将String类型的null转成""
                    SerializerFeature.WriteNullStringAsEmpty,
                    // 将Number类型的null转成0
                    SerializerFeature.WriteNullNumberAsZero,
                    // 将List类型的null转成[]
                    SerializerFeature.WriteNullListAsEmpty,
                    // 将Boolean类型的null转成false
                    SerializerFeature.WriteNullBooleanAsFalse,
                    // 避免循环引用
                    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);
        }
    }
    

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

    以上是 Spring Boot 返回 json 的几个代表的例子,但是在实际项目中,除了要封装数据之外,我们往往需要在返回的 json 中添加一些其他信息,比如返回一些状态码 code ,返回一些 msg 给调用者,这样调用者可以根据 code 或者 msg 做一些逻辑判断。所以在实际项目中,我们需要封装一个统一的 json 返回结构存储返回信息。

    3.1 定义统一的 json 结构

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

    public class JsonResult<T> {
    
        private T data;
        private String code;
        private String msg;
    
        /**
         * 若没有数据返回,默认状态码为0,提示信息为:操作成功!
         */
        public JsonResult() {
            this.code = "0";
            this.msg = "操作成功!";
        }
    
        /**
         * 若没有数据返回,可以人为指定状态码和提示信息
         * @param code
         * @param msg
         */
        public JsonResult(String code, String msg) {
            this.code = code;
            this.msg = msg;
        }
    
        /**
         * 有数据返回时,状态码为0,默认提示信息为:操作成功!
         * @param data
         */
        public JsonResult(T data) {
            this.data = data;
            this.code = "0";
            this.msg = "操作成功!";
        }
    
        /**
         * 有数据返回,状态码为0,人为指定提示信息
         * @param data
         * @param msg
         */
        public JsonResult(T data, String msg) {
            this.data = data;
            this.code = "0";
            this.msg = msg;
        }
        // 省略get和set方法
    }
    

    3.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("公众号", "武哥聊编程");
            map.put("CSDN地址", null);
            map.put("粉丝数量", 4153);
            return new JsonResult<>(map);
        }
    }
    

    我们重新在浏览器中输入: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,"公众号":"武哥聊编程"},"msg":"操作成功!"}
    

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

    4. 总结

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

    展开全文
  • 步骤如下1:编写实体类Demo2 : 编写getDemo()方法3:测试总结:这里我们没有对数据进行任何操作,SpringBoot为什么能直接给我们返回json数据。这是因为SpringBoot默认使用的json解析框架是jackson,所以当你返回一...

    步骤如下

    1:编写实体类Demo

    2 : 编写getDemo()方法

    3:测试







    总结:这里我们没有对数据进行任何操作,SpringBoot为什么能直接给我们返回json数据。

    这是因为SpringBoot默认使用的json解析框架是jackson,所以当你返回一个demo对象时他会自动通过jackson解析框架将我们的对象解析成json返回回来。

    展开全文
  • SpringBoot 返回json数据 的几种方式

    万次阅读 2018-07-27 09:51:20
    String date = JSON.toJSONString(user); try { sendJsonData(response, date); } catch (Exception e) { e.printStackTrace(); } return null; } protected void sendJsonData(HttpServletResponse ...

    (一)@RestController    +   @RequestMapping("/")

    @RestController
    public class TestController {
    
        @RequestMapping("/")
        public User test(){
            User user = new User();
            user.setId(new BigDecimal(12));
            user.setSex("12");
            user.setUsername("phpfzh");
            return user;
        }
    }

    (二)@ResponseBody

    @Controller
    public class TestController2 {
    
        @ResponseBody
        @RequestMapping("/test2")
            public User test2(){
            User user = new User();
            user.setId(new BigDecimal(12));
            user.setSex("12");
            user.setUsername("phpfzh-test2");
            return user;
        }
    }
    
    

    (三)、response

    @Controller
    public class TestController3 {
    
    @RequestMapping("/test3")
      public String test(HttpServletResponse response){
            User user = new User();
            user.setId(new BigDecimal(12));
            user.setSex("12");
            user.setUsername("phpfzh-test3");
            String date = JSON.toJSONString(user);
            try {
            sendJsonData(response, date);
            } catch (Exception e) {
              e.printStackTrace();
        }
        return null;
    }
    
    protected void sendJsonData(HttpServletResponse response, String data) throws Exception{
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        out.println(data);
        out.flush();
        out.close();
        }
    }
    
    

    转载:https://blog.csdn.net/phpfzh/article/details/77978232

    可参考:https://blog.csdn.net/yelllowcong/article/details/79718068

    展开全文
  • 本文目录如下:1. Spring Boot 默认对Json的处理1.1 创建 User 实体类1.2 创建Controller类1.3 测试不同数据类型返回json1.4 jackso...
  • DB中存储的是时间格式,但是使用@RestController返回JSON数据时,时间格式转换为了时间戳的形式,现改为直接返回的是时间格式。 解决前: 解决后: 解决方式: 在yml文件中加入 spring: jackson: date-format...
  • 由于使用在@RequestBody 或 RequestMapping 返回json类型字符串的时候,会把string时间字段转换成lang类型,然后对应实体类的时候,会按照GMT+0时区的时间进行处理。 解决方式: spring: jackson: date-format...
  • SpringBoot返回Json和Jsp页面数据

    千次阅读 2019-04-28 17:04:22
    (一)SpringBoot返回json数据 pom.xml引入依赖项 <parent> <artifactId>springboot_parent</artifactId> <groupId>cn.lzj.springboot</groupId> <version>1.0-S...
  • 本文以spring boot项目为例给大家介绍SpringBoot项目中处理返回json的null值问题,本文通过实例代码给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友参考下
  • 方法一springboot默认使用jackson解析spring: jackson: date-format: yyyy-MM-dd HH:mm:ss方法二直接在属性上使用@JsonFormat注解 @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") private Date update...
  • springboot 返回json串含有斜杠

    千次阅读 2019-12-27 10:16:01
    于是想到直接存json串,事实上就是存String,但是当我把json串以String直接返回前端的时候,出现了斜杆,如下图 试了很多种方法,终于有了解决方法,阿里巴巴的JSON包还是牛逼 implementation group: '...
  • 数据库里面查出来的时间是时间错格式,前段需要处理才能展示相应的格式,自己一个个转的话太麻烦,所以可以在apllication.property加入下面配置就可以 ...spring.jackson.date-format=yyyy-MM-dd HH:mm:ss ...
  • 之前尝试了百度很多方式然后不能打印数据,后面把接收参数改为html就可以正常打印了 (吐槽一下,一般都是json,居然必须要html,我丢)
  • SpringBoot 返回JSON格式数据

    千次阅读 2019-05-21 09:04:58
    import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.http.converter.HttpMessageConverter; import org.springframework.web.servlet.config.annotation....
  • SpringBoot返回json数据

    千次阅读 2017-06-10 23:32:57
    * @RestController返回json字符串的数据 * @author zmk */ @RestController @SpringBootApplication public class DemoController { @RequestMapping("/demo") public DemoDto demo(){ DemoDto demoDto = new...
  • 使用spring boot jpa 操作数据库,返回时间格式为毫秒数,期望是日期格式 添加如下设置 spring.jackson.date-format=yyyy-MM-dd HH:mm:ss spring.jackson.time-zone=GMT+8 眼前一亮 ...
  • @JsonIgnore -- 忽略该字段 @JsonProperty(value = ...@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") -- 格式化字段输出 创建实体类 import com.fasterxml.jackson.annotation.JsonFormat; import com.faste...
  • 场景 实现 ...把SpringBoot的response编码设置为utf-8 找到application.properties配置文件 添加如下: #设置响应为utf-8 spring.http.encoding.force-response=true 再次刷新浏览器 ...
  • springBoot返回json设置

    2019-12-09 11:45:51
    网上有很多使用如下方法来修改json返回null或空字符串(springboot配置jackson不生效): @Bean @Primary @ConditionalOnMissingBean(ObjectMapper.class) public ObjectMapper jacksonObjectMapper(Jackson2...
  • SpringBoot返回字符串的方式也是有两种,一种是通过@ResponseBody 和@RequestMapping(value = "/request/data", method = RequestMethod.POST, produces = "application/json;charset=UTF-8") 中的produces = ...
  • 第一种解决方式:在请求RequestMapping直接设置,只针对请求,在拦截器返回json数据时有可能乱码 @RequestMapping(value ="/user", produces="application/json;charset=UTF-8") 第二种方式:不一定有效 #解决@...
  • 老问 你咋返回json 。。。怎么异步查数据。。。。 。。咳咳 统一回复。。。。我是比较实际的作风哈 教你原理 你可能不愿意听,。。那你就学用法吧啊。。(毕竟会多少没啥用,重要的是你能做出来什么成绩让领导...
  • 第一步 定义一个接口 ...第二步 定义一个统一格式的返回类(包含状态码,返回状态,返回消息,返回数据) @Data public class R { private Integer code; private boolean status; private String message; private
  • import com.fasterxml.jackson.annotation.JsonIgnore; @JsonIgnore private List<String> courseNames;
  • 一般情况下数据类型最常用的就是JSON以及XML,在这里我们就讲讲在SpringBoot里面我们怎样进行JSON数据返回以及数据一些特殊情况的处理。  如下图所示,我们建立好Controller控制层,和SpringMvc一样进行路径访问...
  • SpringBoot处理JSON数据

    千次阅读 2018-07-11 07:28:27
    SpringBoot内置了JSON解析功能,默认使用Jackson来自动完成当Controller返回的是一个Java对象或者是List集合时,SpringBoot自动将其转换成JSON数据一、新建项目 1.创建一个Maven项目,命名为SpringBoot_jsontest,...
  • 前言 JSON的可读性比XML强几条长安街,解析规则也简单许多。XML解析的时候规则太多了,动不动就非法字符,动不动就...而Spring Boot框架项目接口返回 JSON格式的数据比较简单:在 Controller 类中使用@RestControl...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,444
精华内容 16,177
关键字:

springboot返回json数据

spring 订阅