精华内容
下载资源
问答
  • jackjson
    2018-04-20 14:01:53

    jackjson

    https://github.com/FasterXML/jackson-docs
    https://github.com/FasterXML/jackson-core
    https://github.com/FasterXML/jackson-databind
    https://github.com/FasterXML/jackson-annotations

    ObjectMapper

    http://www.studytrails.com/java/json/jackson-create-json/
    http://tutorials.jenkov.com/java-json/jackson-objectmapper.html
    JackJson - JSON to Java

    Annotation

    https://github.com/FasterXML/jackson-docs/wiki/JacksonAnnotations
    http://tutorials.jenkov.com/java-json/jackson-annotations.html

    general annotationread or writedescription
    @JsonIgnoreread + write忽略某个字段
    @JsonIgnorePropertiesread + write忽略多个字段,ignoreUnknown=true可未知属性
    @JsonPropertyread + write重命名字段
    @JsonNamingread + write自定义属性序列化或反序列化规则
    @JsonFormatread + write时间格式化,有时区问题
    @JsonIncludewrite忽略满足条件的属性,如null
    @JsonValuewrite序列化对象为返回值,如把Enum序列化为code
    @JsonCreatorread反序列化指定值为对象,如把code序列化为Enum
    @JsonDeserializeread反序列为指定的接口或是泛型时,用来指定实际的类型

    Features

    JsonParser Features

    general featruedefaultdescription
    ALLOW_UNQUOTED_FIELD_NAMESfalse允许字段名称没有双引号
    ALLOW_SINGLE_QUOTESfalse允许字段名称和值使用单引号
    ALLOW_NUMERIC_LEADING_ZEROSfalse允许以0开头的数字

    Serialization Features

    general featruedefaultdescription
    INDENT_OUTPUTfalse格式化输出json,测试时有用

    Deserialization Features

    general featruedefaultdescription
    FAIL_ON_UNKNOWN_PROPERTIEStrue有未知的属性时报错

    Serialization Inclusion

    序列化时,是否显示某些属性,如Include.NOT_NULL表示如果字段值为null,则序列化输出时不显示该字段
    全局设置:setSerializationInclusion(Include.NON_NULL)
    单个设置:@JsonInclude(JsonInclude.Include.NON_NULL)

    Date Format

    默认在java.uti.Date和时间戳之间序列化和反序列化
    全局设置:setDateFormat(new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”))
    单个设置: @JsonFormat(pattern = “yyyy-MM-dd HH:mm:ss”,timezone = “Asia/Shanghai”)

    @JsonFormat有时区问题,参考:
    https://stackoverflow.com/questions/46011703/set-current-timezone-to-jsonformat-timezone-value
    https://github.com/FasterXML/jackson-databind/issues/1266

    Property Naming Strategy

    自定义属性序列化策略,比如下划线转骆峰
    全局设置: setPropertyNamingStrategy(PropertyNamingStrategy.SnakeCaseStrategy.SNAKE_CASE)
    单个设置:@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)

    General Configure

    ObjectMapper objectMapper = new ObjectMapper()
                .configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true)
                .configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true)
                .configure(JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS, true)
                .configure(SerializationFeature.INDENT_OUTPUT,true)
                .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false)
                .setSerializationInclusion(JsonInclude.Include.NON_NULL)
                .setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    更多相关内容
  • JackJson在对JSON数据进行生成与解析时,所需使用的相关jar包
  • jackjson2.2.3

    2020-09-19 10:14:54
    jackjson2.2.3下载
  • JackJson.zip

    2019-06-26 22:18:16
    Java解析json数据使用的JackJson 库数据类包含3个重要jar包
  • jackJson

    2021-07-05 09:12:39
    jackJson 将javaBean对象转换为json字符串 1、先创建一个jackJson的核心对象 ObjectMapper以及实体类对象 ObjectMapper om=new ObjectMapper(); User user=new User("才春磊",20,"1020308280@qq.com"); 2、把实体...

    jackJson

    将javaBean对象转换为json字符串

    1、先创建一个jackJson的核心对象 ObjectMapper以及实体类对象

    ObjectMapper om=new ObjectMapper();	
    User user=new User("才春磊",20,"1020308280@qq.com");
    

    2、把实体类转换成json格式的字符串

    try {
                String userstr = om.writeValueAsString(user);
                System.out.println(userstr);
            } catch (IOException e) {
                e.printStackTrace();
            }
    /*
    打印结果
    {"name":"才春磊","age":20,"email":"1020308280@qq.com"}
    */
    

    通过ObjectMapper中的writeValueAsString()方法将实体类的对象转换成了Json字符串

    将json字符串写入文件

    try {
                om.writeValue(new File("D:\\json.txt"),user);
            } catch (IOException e) {
                e.printStackTrace();
            }
    

    通过ObjectMapper中的writeValue()方法将实体类转换的Json字符串写入文件中

    注解:

    @JsonIgnore    写在实体类中,表示在将对象转换为Json字符串的时候忽略这个属性	
    @JsonFormat(pattern = "yyyy-MM-dd")     写在实体类中,表示将实体类对象转换为Json字符串的时候,日期类属性,以什么形式转换为Json字符串
    

    将json字符串转换成实体类对象

    public static void main(String[] args) {
        //把Json格式的字符串转换成指定的实体类对象
        //创建jackJson的核心类ObjectMapper
        ObjectMapper om =new ObjectMapper();
        //创建User实体类对象
        User user=new User("才春磊",20,"asdf");
        try {
        	//将实体类对象转换成Json字符串
            String userStr = om.writeValueAsString(user);
            System.out.println(userStr);
            //将User类转换过来的Json字符串转回Json对象
            //User.class反射的方法
            User user1 = om.readValue(userStr, User.class);
            System.out.println(user);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /*
    运行结果
    {"name":"才春磊","age":20,"email":"asdf"}
    User{name='才春磊', age=20, email='asdf'}
    */
    

    将List转换为json字符串

    public static void main(String[] args) {
            ObjectMapper om =new ObjectMapper();
            User user=new User("才春磊",20,"aaaa");
            User user2=new User("才春磊1",21,"bbbb");
            User user3=new User("才春磊2",22,"cccc");
            List<User> list=new ArrayList<User>();
            list.add(user);
            list.add(user2);
            list.add(user3);
            //把list集合转换成json字符串
            try {
                String listStr = om.writeValueAsString(list);
                System.out.println(listStr);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    /*
    运行结果为
    [{"name":"才春磊","age":20,"email":"aaaa"},
    {"name":"才春磊1","age":21,"email":"bbbb"},
    {"name":"才春磊2","age":22,"email":"cccc"}]
    */
    

    将Map转换为json字符串

    public static void main(String[] args) {
            ObjectMapper om=new ObjectMapper();
            Map<String,Object> map=new HashMap<String,Object>();
            map.put("name","才春磊");
            map.put("sex","男");
            map.put("age",20);
            try {
                String jsonMap = om.writeValueAsString(map);
                System.out.println(jsonMap);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    /*
    运行结果
    {"sex":"男","name":"才春磊","age":20}
    */
    
    展开全文
  • jackjson一个强大的json转其它类型,方便,快捷
  • jackjson2.6 jar包

    2017-06-15 17:41:54
    jackjson2.6 jar包
  • fastjson,jackjson,gson的各个使用方法

    转换

    准备一个vo
    @Data
    public class Person implements Serializable {
        private Integer id;
        private BigDecimal amount;
        private BigDecimal amountNUll;
        private String name;
        private String P;//就一个大写字母
        private String XYZabc;//连续3个大写字母
        private String XYNULL;
        private Date createTime;
    
    
        public Person(Integer id, String name, Date createTime) {
            this.id = id;
            this.name = name;
            this.createTime = createTime;
        }
    }
    
    

    1、string转object

     	String json = "{\"XYZabc\":\"XYZ\",\"amount\":8.88,\"createTime\":1654931545521,\"id\":1,\"name\":\"DZL\",\"p\":\"PPP\"}";
            // 方式1: 将json字符串转为Java对象
            Person person = JSON.parseObject(json,Person.class);
            System.out.println("fastjson:java对象->>>"+person);
    
            // 方式2: 将json字符串转为Java对象
            Person newPerson2 = JSONObject.parseObject(json, Person.class);
            System.out.println("fastjson:java对象->>>"+newPerson2);
    
            System.out.println("=========================================================");
            ObjectMapper objectMapper = new ObjectMapper();
            try {
                Person jackPerson = objectMapper.readValue(json, Person.class);
                System.out.println("java对象->>>"+jackPerson);
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
    
            System.out.println("=========================================================");
    
            final Gson gson = new Gson();
    
            Person gsonPerson = gson.fromJson(json, Person.class);
            System.out.println("java对象->>>"+gsonPerson);
    
    • jackjson 搞不定大写的P,XYZabc这样的属性key,都需要改小写,fast和gson都没大问题
    • gson 不认识1654931545521 这样的时间戳

    2、object转string

     	Person person = new Person(1,"DZL",new Date());
            person.setP("PPP");
            person.setXY("XYZ");
            person.setAmount(new BigDecimal("8.88"));
    
            // 方式1:将对象转为json字符串
            String json = JSON.toJSONString(person);
            System.out.println("fast json字符串1->>>"+json);
            System.out.println("=========================================================");
            // 方式2:将对象转为json字符串
            String json2 = JSONObject.toJSONString(person);
            System.out.println("fast json字符串1->>>"+json2);
    
            System.out.println("=========================================================");
    
            ObjectMapper objectMapper = new ObjectMapper();
            try {
                String jackStr = objectMapper.writeValueAsString(person);
                System.out.println("jack json字符串->>>"+jackStr);
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
            System.out.println("=========================================================");
    
            Gson gson = new Gson();
            String gsonStr = gson.toJson(person);
            System.out.println("gson json字符串->>>"+gsonStr);
    

    结果

    fast json字符串1->>>{"XYZabc":"XYZ","amount":8.88,"createTime":1654931545521,"id":1,"name":"DZL","p":"PPP"}
    =========================================================
    fast json字符串1->>>{"XYZabc":"XYZ","amount":8.88,"createTime":1654931545521,"id":1,"name":"DZL","p":"PPP"}
    =========================================================
    jack json字符串->>>{"id":1,"amount":8.88,"amountNUll":null,"name":"DZL","createTime":1654931545521,"p":"PPP","xyzabc":"XYZ","xynull":null}
    =========================================================
    gson json字符串->>>{"id":1,"amount":8.88,"name":"DZL","P":"PPP","XYZabc":"XYZ","createTime":"Jun 11, 2022 3:12:25 PM"}
    
    

    区别
    1、字符串和BigDecimal都的值如果是null,fastjson,和gson都默认没有打印,jack是默认打印的
    2、属性名称首字母大写,如一个P,fast,jack变小写了,gson依然是大写;
    3、属性名称如XYZabc 首字母2个大写字母的,fast和gson保持原样,fast全小写了

    3、array转json

      public static void fast_list2str_test(){
            List<Person> personList = new ArrayList<>();
            personList.add(new Person(1,"DT",new Date()));
            personList.add(new Person(2,"DT1",new Date()));
            personList.add(new Person(3,"DT2",new Date()));
            String json = JSONObject.toJSONString(personList);
            System.out.println("fast json->>>"+json);
        }
        public static void jack_list2str_test()  {
            ObjectMapper objectMapper = new ObjectMapper();
            List<Person> personList = new ArrayList<>();
            personList.add(new Person(1,"DT",new Date()));
            personList.add(new Person(2,"DT1",new Date()));
            personList.add(new Person(3,"DT2",new Date()));
            String json = null;
            try {
                json = objectMapper.writeValueAsString(personList);
            } catch (JsonProcessingException e) {
                throw new RuntimeException(e);
            }
            System.out.println("json->>>"+json);
        }
        public static void gson_list2str_test(){
            Gson gson = new Gson();
            List<Person> personList = new ArrayList<>();
            personList.add(new Person(1,"DT",new Date()));
            personList.add(new Person(2,"DT1",new Date()));
            personList.add(new Person(3,"DT2",new Date()));
            String json = gson.toJson(personList);
            System.out.println("json->>>"+json);
        }
    

    4、json转array

    5、注释

    5.1、排序

    // fastjson
    类上面加
    @JSONType(orders = {"id","name","XYZabc","createTime"})
    
    // jacckjson
        @JsonProperty(index = 2)
        private String channel
    

    5.2、豁免或包含

    • fast
      // 序列化的时候,豁免realName
      @JSONField(serialize=false)
      public String realName;

    @JSONType(ignores ={“id”,“sex”})
    public class 我是一个类

    @JSONType(includes={“name”,“sex”})
    public class 我是一个类

    • jack
    • gson

    5.3、 format

    • fast 起个别名
      @JSONField(name=“gender”)
      public String sex;

    • jackjson
      @JsonFormat(pattern =“yyyy-MM-dd HH:mm:ss”)
      private LocalDateTime createTime;

    • fastjson
      @JsonFormat(pattern =“yyyy-MM-dd HH:mm:ss”)
      private LocalDateTime createTime;

    5.4、非空是否打印(忽略null)

    // jackjson
    @JsonIgnore
    private LocalDateTime createTime;
    
    @JsonIgnore
    public LocalDateTime getCreateTime(){
    	return createTime;
    }
    
    //  fastjson
    @JSONField(serialize = false)
    private String name;
    或者类上面用包含,排除等方法
    
    //  gson
     @Expose
        private String user;
    

    5.5、 映射别名

    1)、fastjson
    	@JSONField(name="person_name")
    	private String name;
    
    	@JSONField(name="person_age")
    	private Integer age;
    
    2)、jackjson

    @JsonAlias({“n”,“Name”})
    private String name;

    3)、gson

    @SerializedName(“Name”)
    private String name;
    @SerializedName(“Pwd”)
    private String pwd;

    展开全文
  • jackjson与fastjson工具类

    2022-05-26 16:14:30
    jackjson与fastjson工具类关于JSON的工具类1.jackjson1.1依赖坐标1.1.1全局配置工具类1.1.2非全局配置工具类2.fastjson2.1依赖坐标2.1.1工具类 关于JSON的工具类 1.jackjson 1.1依赖坐标 <dependency> <...

    关于JSON的工具类

    1.jackjson

    1.1依赖坐标

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.8.3</version>
        </dependency>
    

    1.1.1全局配置工具类

    package com.common.service.dgcommon.config;
    
    import com.fasterxml.jackson.annotation.JsonInclude;
    import com.fasterxml.jackson.databind.DeserializationFeature;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.SerializationFeature;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.text.SimpleDateFormat;
    /**
     * @author: dgz
     * @createTime: 2021/08/05 16:09
     */
    @Configuration
    public class BeanConfig {
    
        @Bean
        public ObjectMapper getObjectMapper() {
            ObjectMapper MAPPER = new ObjectMapper();
            //对象的所有字段全部列入
            MAPPER.setSerializationInclusion(JsonInclude.Include.ALWAYS);
            //取消默认转换timestamps形式
            MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
            //忽略空Bean转json的错误
            MAPPER.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
            //所有的日期格式都统一为以下的样式,即yyyy-MM-dd HH:mm:ss
            MAPPER.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
            //忽略 在json字符串中存在,但是在java对象中不存在对应属性的情况。防止错误
            MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
            System.out.println("全局配置。。。。。");
            return MAPPER;
        }
    }
    
    
    package com.common.service.dgcommon.util.jsonUtils;
    
    import com.fasterxml.jackson.annotation.JsonInclude;
    import com.fasterxml.jackson.core.JsonGenerator;
    import com.fasterxml.jackson.core.type.TypeReference;
    import com.fasterxml.jackson.databind.*;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PostConstruct;
    import javax.annotation.Resource;
    import java.io.IOException;
    import java.text.SimpleDateFormat;
    import java.util.List;
    import java.util.Map;
    
    
    /**
     * @author: dgz
     * @createTime: 2021/08/05 16:09
     */
    @Slf4j
    @Component
    public final class JackJsonUtil {
    
        private static ObjectMapper MAPPER;
    
        private JackJsonUtil(ObjectMapper objectMapper) {
            MAPPER = objectMapper;
        }
    
        /**
         * 对象转Json格式字符串
         *
         * @param object 对象
         * @return Json格式字符串
         */
        public static String toJson(Object object) {
            if (object == null) {
                return null;
            }
            try {
                return object instanceof String ? (String) object : MAPPER.writeValueAsString(object);
            } catch (Exception e) {
                log.error("method=toJson() is convert error, errorMsg:{}", e.getMessage(), e);
                return null;
            }
        }
    
    
        /**
         * Object TO Json String 字符串输出(输出空字符)
         *
         * @param object 对象
         * @return Json格式字符串
         */
        public static String toJsonEmpty(Object object) {
            if (object == null) {
                return null;
            }
            try {
                MAPPER.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
                    @Override
                    public void serialize(Object param, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
                        //设置返回null转为 空字符串""
                        jsonGenerator.writeString("");
                    }
                });
                return MAPPER.writeValueAsString(object);
            } catch (Exception e) {
                log.error("method=toJsonEmpty() is convert error, errorMsg:{}", e.getMessage(), e);
            }
            return null;
        }
    
    
        /**
         * Object TO Json String 排除属性为null的值
         *
         * @param object 对象
         * @return Json格式字符串
         */
        public static String toJsonRemoveObjectPropertyNull(Object object) {
            if (object == null) {
                return null;
            }
            try {
                MAPPER.setSerializationInclusion(JsonInclude.Include.NON_NULL);
                return MAPPER.writeValueAsString(object);
            } catch (Exception e) {
                log.error("method=toJsonEmpty() is convert error, errorMsg:{}", e.getMessage(), e);
            }
            return null;
        }
    
    
        /**
         * Json 转为 Jave Bean
         *
         * @param text  json字符串
         * @param clazz 对象类型class
         * @param <T>   对象类型
         * @return 对象类型
         */
        public static <T> T fromJSON(String text, Class<T> clazz) {
            if (StringUtils.isEmpty(text) || clazz == null) {
                return null;
            }
            try {
                return MAPPER.readValue(text, clazz);
            } catch (Exception e) {
                log.error("method=toBean() is convert error, errorMsg:{}", e.getMessage(), e);
            }
            return null;
        }
    
    
        /**
         * Json 转为 Map
         *
         * @param text json
         * @param <K>  key
         * @param <V>  value
         * @return map
         */
        public static <K, V> Map<K, V> toMap(String text) {
            try {
                if (StringUtils.isEmpty(text)) {
                    return null;
                }
                return toObject(text, new TypeReference<Map<K, V>>() {
                });
            } catch (Exception e) {
                log.error("method=toMap() is convert error, errorMsg:{}", e.getMessage(), e);
            }
            return null;
        }
    
    
        /**
         * Json 转 List, Class 集合中泛型的类型,非集合本身
         *
         * @param text json
         * @param <T>  对象类型
         * @return List
         */
        public static <T> List<T> toList(String text) {
            if (StringUtils.isEmpty(text)) {
                return null;
            }
            try {
                return toObject(text, new TypeReference<List<T>>() {
                });
            } catch (Exception e) {
                log.error("method=toList() is convert error, errorMsg:{}", e.getMessage(), e);
            }
            return null;
        }
    
        /**
         * Json 转 Object
         */
        /**
         * @param text          json
         * @param typeReference TypeReference
         * @param <T>           类型
         * @return T
         */
        public static <T> T toObject(String text, TypeReference<T> typeReference) {
            try {
                if (StringUtils.isEmpty(text) || typeReference == null) {
                    return null;
                }
                return (T) (typeReference.getType().equals(String.class) ? text : MAPPER.readValue(text, typeReference));
            } catch (Exception e) {
                log.error("method=toObject() is convert error, errorMsg:{}", e.getMessage(), e);
            }
            return null;
        }
    
    }
     
     
    

    1.1.2非全局配置工具类

    package com.common.service.dgcommon.util.jsonUtils;
    
    import com.fasterxml.jackson.annotation.JsonInclude;
    import com.fasterxml.jackson.core.JsonGenerator;
    import com.fasterxml.jackson.core.type.TypeReference;
    import com.fasterxml.jackson.databind.*;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    
    import java.io.IOException;
    import java.text.SimpleDateFormat;
    import java.util.List;
    import java.util.Map;
    
    
    /**
     * @author: dgz
     * @createTime: 2021/08/05 16:09
     */
    @Slf4j
    public final class JackJsonUtil {
    
    
        private static ObjectMapper MAPPER = new ObjectMapper();
        // 日起格式化
        private static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";
    
        static {
            //对象的所有字段全部列入
            MAPPER.setSerializationInclusion(JsonInclude.Include.ALWAYS);
            //取消默认转换timestamps形式
            MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
            //忽略空Bean转json的错误
            MAPPER.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
            //所有的日期格式都统一为以下的样式,即yyyy-MM-dd HH:mm:ss
            MAPPER.setDateFormat(new SimpleDateFormat(STANDARD_FORMAT));
            //忽略 在json字符串中存在,但是在java对象中不存在对应属性的情况。防止错误
            MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        }
    
        private JackJsonUtil() {
        }
    
    
        //获取实例对象
        public static ObjectMapper getInstance() {
            return MAPPER;
        }
    
        /**
         * 对象转Json格式字符串
         *
         * @param object 对象
         * @return Json格式字符串
         */
        public static String toJson(Object object) {
            if (object == null) {
                return null;
            }
            try {
                return object instanceof String ? (String) object : MAPPER.writeValueAsString(object);
            } catch (Exception e) {
                log.error("method=toJson() is convert error, errorMsg:{}", e.getMessage(), e);
                return null;
            }
        }
    
    
        /**
         * Object TO Json String 字符串输出(输出空字符)
         *
         * @param object 对象
         * @return Json格式字符串
         */
        public static String toJsonEmpty(Object object) {
            if (object == null) {
                return null;
            }
            try {
                MAPPER.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
                    @Override
                    public void serialize(Object param, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
                        //设置返回null转为 空字符串""
                        jsonGenerator.writeString("");
                    }
                });
                return MAPPER.writeValueAsString(object);
            } catch (Exception e) {
                log.error("method=toJsonEmpty() is convert error, errorMsg:{}", e.getMessage(), e);
            }
            return null;
        }
    
    
        /**
         * Object TO Json String 排除属性为null的值
         *
         * @param object 对象
         * @return Json格式字符串
         */
        public static String toJsonRemoveObjectPropertyNull(Object object) {
            if (object == null) {
                return null;
            }
            try {
                MAPPER.setSerializationInclusion(JsonInclude.Include.NON_NULL);
                return MAPPER.writeValueAsString(object);
            } catch (Exception e) {
                log.error("method=toJsonEmpty() is convert error, errorMsg:{}", e.getMessage(), e);
            }
            return null;
        }
    
    
        /**
         * Json 转为 Jave Bean
         *
         * @param text  json字符串
         * @param clazz 对象类型class
         * @param <T>   对象类型
         * @return 对象类型
         */
        public static <T> T fromJSON(String text, Class<T> clazz) {
            if (StringUtils.isEmpty(text) || clazz == null) {
                return null;
            }
            try {
                return MAPPER.readValue(text, clazz);
            } catch (Exception e) {
                log.error("method=toBean() is convert error, errorMsg:{}", e.getMessage(), e);
            }
            return null;
        }
    
    
        /**
         * Json 转为 Map
         *
         * @param text json
         * @param <K>  key
         * @param <V>  value
         * @return map
         */
        public static <K, V> Map<K, V> toMap(String text) {
            try {
                if (StringUtils.isEmpty(text)) {
                    return null;
                }
                return toObject(text, new TypeReference<Map<K, V>>() {
                });
            } catch (Exception e) {
                log.error("method=toMap() is convert error, errorMsg:{}", e.getMessage(), e);
            }
            return null;
        }
    
    
        /**
         * Json 转 List, Class 集合中泛型的类型,非集合本身
         *
         * @param text json
         * @param <T>  对象类型
         * @return List
         */
        public static <T> List<T> toList(String text) {
            if (StringUtils.isEmpty(text)) {
                return null;
            }
            try {
                return toObject(text, new TypeReference<List<T>>() {
                });
            } catch (Exception e) {
                log.error("method=toList() is convert error, errorMsg:{}", e.getMessage(), e);
            }
            return null;
        }
    
        /**
         * Json 转 Object
         */
        /**
         * @param text          json
         * @param typeReference TypeReference
         * @param <T>           类型
         * @return T
         */
        public static <T> T toObject(String text, TypeReference<T> typeReference) {
            try {
                if (StringUtils.isEmpty(text) || typeReference == null) {
                    return null;
                }
                return (T) (typeReference.getType().equals(String.class) ? text : MAPPER.readValue(text, typeReference));
            } catch (Exception e) {
                log.error("method=toObject() is convert error, errorMsg:{}", e.getMessage(), e);
            }
            return null;
        }
    
    }
     
    

    2.fastjson

    2.1依赖坐标

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

    2.1.1工具类

    package com.common.service.dgcommon.util.jsonUtils;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.TypeReference;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    
    import java.util.List;
    import java.util.Map;
    
    /**
     * @author: dgz
     * @createTime: 2021/08/05 16:09
     */
    public class FastJsonUtils {
    
    
        /**
         * 功能描述:把JSON数据转换成指定的java对象
         *
         * @param jsonData JSON数据
         * @param clazz    指定的java对象
         * @return 指定的java对象
         */
        public static <T> T getJsonToBean(String jsonData, Class<T> clazz) {
            return JSON.parseObject(jsonData, clazz);
        }
    
        /**
         * 功能描述:把java对象转换成JSON数据
         *
         * @param object java对象
         * @return JSON数据
         */
        public static String getBeanToJson(Object object) {
            return JSON.toJSONString(object, SerializerFeature.PrettyFormat);
        }
    
        /**
         * 功能描述:把JSON数据转换成指定的java对象列表
         *
         * @param jsonData JSON数据
         * @param clazz    指定的java对象
         * @return List<T>
         */
        public static <T> List<T> getJsonToList(String jsonData, Class<T> clazz) {
            return JSON.parseArray(jsonData, clazz);
        }
    
        /**
         * 功能描述:把JSON数据转换成较为复杂的List<Map<String, Object>>
         *
         * @param jsonData JSON数据
         * @return List<Map < String, Object>>
         */
        public static List<Map<String, Object>> getJsonToListMap(String jsonData) {
            return toObject(jsonData, new TypeReference<List<Map<String, Object>>>() {
            });
        }
    
    
        /**
         * 功能描述:把JSON数据转换成Map<String, Object>
         *
         * @param jsonData JSON数据
         * @return Map < String, Object>
         */
        public static <k, v> Map<k, v> getJsonToMap(String jsonData) {
            return toObject(jsonData, new TypeReference<Map<k, v>>() {
            });
        }
    
    
        //发型方法
        public static <T> T toObject(String jsonData, TypeReference<T> tTypeReference) {
            return JSON.parseObject(jsonData, tTypeReference);
        }
    }
    
    
    展开全文
  • jackjson.zip

    2021-07-10 16:33:52
    jackjson三个最新包下载,之前没有使用,现在想改,结果找的挺麻烦。
  • jackjson使用详解

    千次阅读 2022-04-10 14:57:22
    文章目录序列化概念json概念jackjsonjackjson常用注解(对象属性中使用)jackjson常用操作 序列化概念 序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间,对象将其当前...
  • Jackjson.rar

    2021-07-03 13:02:40
    JackJson的依赖jar包源码,文档
  • 14. 集成`JackJson`

    2021-08-09 17:22:09
    Spring Boot 默认集成JackJson,无需依赖 SSM <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.10.1...
  • Spring-JackJson

    2022-03-31 16:52:38
    Spring-Json Jackson Jackson应该是目前比较好的json解析工具了 <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind --> <dependency>...jackson-
  • 起源 当后端接口向前端返回数据时,有时response数据是null, 十分不利于前端处理。 因此为了统一格式,需要返回在: 接口返回得数据是String类型时,不返回null,而返回 “” ...jackjson 是 spring boot 官方内置
  • Spring Boot Json 之 Jackjson Fastjson1 新建 Spring Boot Maven 示例工程项目2 编写代码用于测试示例2.1 用户实体类2.2 控制层代码3 Jackson3.1 依赖引入 Jackson3.2 配置 Jackson3.3 Jackson 序列化3.4 Jackson ...
  • 文章目录 JSON 概述 JackJson FastJson JSON 概述 JSON(JavaScript Object Notation,S对象标记)是一种轻量级的数据交换格式,目前使用特别广泛。 采用完全独立于编程语言的文本格式来存储和表示数据。 简洁和清晰的...
  • jackjson jar包

    2015-07-06 17:32:29
    jackson2.4 最高效的json转换,三个jar包,还有一个JSONUtil工具类,欢迎下载
  • 1.fastjson和jackJson:在把对象序列化成字符串的时候,是通过反射遍历该类中的所有的getter方法,通过getXX或者isXX ,然后根据JavaBeans规则-> 得到属性名称,XX,然后直接序列化为字符串。 2.Gson:在把对象序列...
  • springmvc jackjson的使用

    2021-06-22 22:12:12
    首先导包 <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.12.3</version>...mvc:an.
  • Jackjson使用

    千次阅读 2019-03-27 14:33:46
    一、Java对象 ⇒ JSON 1.1 转换方式 1.2 注解使用 1.3 普通对象转换 1.4 复杂Java对象转换 二、JSON ⇒ Java对象 2.1 JSON转换为Java对象 2.2 JSON转换为Java集合对象 ...创建Person.java类,实现setter、getter...
  • ssh框架jackjson升级

    2021-07-31 10:20:24
    运维ssh框架老项目,存在Jackson-databind任意文件读取漏洞, CVE编号: CVE-2020-8840 影响版本: 2.x Jackson-databind < 2.9.10.3 修复建议: 更新Jackson-databind至最新版本。......
  • JackJSON的用法

    千次阅读 2020-07-27 09:11:56
    网上大多数都是FastJSON的用法,很少有JackJSON的用法。我总结了几个自己经常用到的,供大家参考。 1.Java对象转化成JSON String getJSON(Object obj){ ObjectMapper objectMapper = new ObjectMapper(); //创建...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,507
精华内容 1,402
关键字:

jackjson