Jackson序列化教程

矫情吗；* 2023-02-14 10:42 12阅读 0赞

### 1、实体类 ###

import com.fasterxml.jackson.annotation.JsonFormat;
    import org.springframework.format.annotation.DateTimeFormat;
    
    import java.math.BigDecimal;
    import java.util.Date;
    
    public class Book {
    
        private Long id;
        private String name;
        private BigDecimal price;
        private Integer amount;
    
        /**
         * 默认是格林威治时区，而我们是东八区，所以时区设为GMT+8
         */
        @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
        private Date saleTime;
    
        public Book() {}
    
        public Book(Long id, String name, BigDecimal price, Integer amount, Date saleTime) {
            this.id = id;
            this.name = name;
            this.price = price;
            this.amount = amount;
            this.saleTime = saleTime;
        }
    
        public Long getId() {
            return id;
        }
    
        public void setId(Long id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public BigDecimal getPrice() {
            return price;
        }
    
        public void setPrice(BigDecimal price) {
            this.price = price;
        }
    
        public Integer getAmount() {
            return amount;
        }
    
        public void setAmount(Integer amount) {
            this.amount = amount;
        }
    
        public Date getSaleTime() {
            return saleTime;
        }
    
        public void setSaleTime(Date saleTime) {
            this.saleTime = saleTime;
        }
    
        @Override
        public String toString() {
            return "Book{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", price=" + price +
                    ", amount=" + amount +
                    ", saleTime=" + saleTime +
                    '}';
        }
    }

### 2、统一结果返回 ###

public class Result<T> {
        private Integer code;
        private String message;
        private T data;
    
        public Integer getCode() {
            return code;
        }
    
        public void setCode(Integer code) {
            this.code = code;
        }
    
        public String getMessage() {
            return message;
        }
    
        public void setMessage(String message) {
            this.message = message;
        }
    
        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    }

### 3、JSONUtil ###

import com.fasterxml.jackson.databind.JsonNode;
    import com.fasterxml.jackson.databind.ObjectMapper;
    
    import java.io.BufferedReader;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.math.BigDecimal;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class JSONUtil {
    
        /**
         * 序列化
         */
        public static String writeBookJson() throws Exception {
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Book b1 = new Book(1L,"西游记", BigDecimal.valueOf(89.9),1325,format.parse("2005-04-15 10:30:20"));
            Book b2 = new Book(2L,"红楼梦", BigDecimal.valueOf(109.5),320,format.parse("1999-12-18 10:30:20"));
            Book b3 = new Book(3L,"水浒传", BigDecimal.valueOf(204.0),569,format.parse("1993-11-12 10:30:20"));
            Book b4 = new Book(4L,"三国演义", BigDecimal.valueOf(100.5),742,format.parse("1996-03-15 10:30:20"));
            Book b5 = new Book(5L,"杨家将", BigDecimal.valueOf(99.9),31,format.parse("2008-01-21 10:30:20"));
            Book b6 = new Book(6L,"天龙八部", BigDecimal.valueOf(176.8),663,format.parse("2010-03-28 10:30:20"));
            Book b7 = new Book(7L,"倚天屠龙记", BigDecimal.valueOf(309.5),2005,format.parse("1997-02-09 10:30:20"));
            Book b8 = new Book(8L,"笑傲江湖", BigDecimal.valueOf(280.0),4700,format.parse("2001-06-02 10:30:20"));
            List<Book> books = new ArrayList<>();
            books.add(b1);
            books.add(b2);
            books.add(b3);
            books.add(b4);
            books.add(b5);
            books.add(b6);
            books.add(b7);
            books.add(b8);
            Result<List<Book>> result = new Result<>();
            result.setCode(200);
            result.setMessage("请求成功");
            result.setData(books);
            ObjectMapper objectMapper = new ObjectMapper();
            String jsonString = objectMapper.writeValueAsString(result);
            return jsonString;
    
        }
    
        /**
         * 反序列化
         */
        public static List<Book> readBookJson() throws Exception {
            InputStream in = JSONUtil.class.getClassLoader().getResourceAsStream("jackson/book.json");
            BufferedReader reader = new BufferedReader(new InputStreamReader(in));
            String result = "";
            String line;
            while ((line = reader.readLine()) != null){
                result += (line+"\r\n");
            }
            in.close();
            reader.close();
    
            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode jsonNode = objectMapper.readTree(result);
            JsonNode data = jsonNode.get("data");
            Iterator<JsonNode> iterator = data.iterator();
            List<Book> books = new ArrayList<>();
            while (iterator.hasNext()){
                JsonNode next = iterator.next();
                Book book = objectMapper.readValue(next.toString(), Book.class);
                books.add(book);
            }
            return books;
        }
    
        public static void main(String[] args) throws Exception {
            //System.out.println(writeBookJson());
            System.out.println(readBookJson());
    
        }
    
    
    }

### 4、book.json ###

{
      "code":200,
      "message":"请求成功",
      "data":[
        {"id":1,"name":"西游记","price":89.9,"amount":1325,"saleTime":"2005-04-15 10:30:20"},
        {"id":2,"name":"红楼梦","price":109.5,"amount":320,"saleTime":"1999-12-18 10:30:20"},
        {"id":3,"name":"水浒传","price":204.0,"amount":569,"saleTime":"1993-11-12 10:30:20"},
        {"id":4,"name":"三国演义","price":100.5,"amount":742,"saleTime":"1996-03-15 10:30:20"},
        {"id":5,"name":"杨家将","price":99.9,"amount":31,"saleTime":"2008-01-21 10:30:20"},
        {"id":6,"name":"天龙八部","price":176.8,"amount":663,"saleTime":"2010-03-28 10:30:20"},
        {"id":7,"name":"倚天屠龙记","price":309.5,"amount":2005,"saleTime":"1997-02-09 10:30:20"},
        {"id":8,"name":"笑傲江湖","price":280.0,"amount":4700,"saleTime":"2001-06-02 10:30:20"}
      ]
    }

### 5、Jackson序列化配置 ###

//这个特性，决定了解析器是否将自动关闭那些不属于parser自己的输入源。
            // 如果禁止，则调用应用不得不分别去关闭那些被用来创建parser的基础输入流InputStream和reader；
            //默认是true
            objectMapper.configure(JsonParser.Feature.AUTO_CLOSE_SOURCE, true);
            //是否允许解析使用Java/C++ 样式的注释（包括'/'+'*' 和'//' 变量）
            objectMapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
     
            //设置为true时，属性名称不带双引号
            objectMapper.configure(JsonGenerator.Feature.QUOTE_FIELD_NAMES, false);
            //反序列化是是否允许属性名称不带双引号
            objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
     
            //是否允许单引号来包住属性名称和字符串值
            objectMapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
     
            //是否允许JSON字符串包含非引号控制字符（值小于32的ASCII字符，包含制表符和换行符）
            objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);
     
            //是否允许JSON整数以多个0开始
            objectMapper.configure(JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS, true);
     
            //null的属性不序列化
            objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
     
            //按字母顺序排序属性,默认false
            objectMapper.configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY,true);
     
            //是否以类名作为根元素，可以通过@JsonRootName来自定义根元素名称,默认false
            objectMapper.configure(SerializationFeature.WRAP_ROOT_VALUE,true);
     
            //是否缩放排列输出,默认false
            objectMapper.configure(SerializationFeature.INDENT_OUTPUT,false);
     
            //序列化Date日期时以timestamps输出，默认true
            objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,true);
     
            //序列化枚举是否以toString()来输出，默认false，即默认以name()来输出
            objectMapper.configure(SerializationFeature.WRITE_ENUMS_USING_TO_STRING, true);
     
            //序列化枚举是否以ordinal()来输出，默认false
            objectMapper.configure(SerializationFeature.WRITE_ENUMS_USING_INDEX,false);
     
            //序列化单元素数组时不以数组来输出，默认false
            objectMapper.configure(SerializationFeature.WRITE_ENUMS_USING_TO_STRING,true);
     
            //序列化Map时对key进行排序操作，默认false
            objectMapper.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS,true);
     
            //序列化char[]时以json数组输出，默认false
            objectMapper.configure(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS,true);
     
            //序列化BigDecimal时是输出原始数字还是科学计数，默认false，即以toPlainString()科学计数方式来输出
            objectMapper.configure(SerializationFeature.WRITE_BIGDECIMAL_AS_PLAIN,true);