栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java-JSON

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java-JSON

JSON介绍

SON:JavaScript 对象表示法(JavaScript Object Notation)
JSON是存储和交换文本信息的语法。

JSON的特点:
1、JSON是轻量级的文本数据交换格式
2、JSON独立于语言和平台
3、JSON具有自我描述性,更易理解

JSON与XML
类似XML,比XML更小、更快,更易解析。
1、没有结束标签
2、更短
3、读写的速度更快
4、使用数组
5、不使用保留字

JSON的语法:
JSON语法是JavaScript对象表示法的子集。
1、数据在名称/值对中(键值对)
2、数据由逗号分隔
3、花括号保存对象
4、方括号保存数组

JSON值可以是:
1、数字(整数或浮点数)
2、字符串(在双引号中)
3、逻辑值(true或false)
4、数组(在方括号中)
5、对象(在花括号中)
6、null

JSON对象(JSON对象在花括号中书写,对象可以包含多个名称/值对)

{"firstName":"Jphn","lasrName":"Doe"}

JSON数组(JSON数组在方括号中书写,数组可包含多个对象,当然对象也可以包含数组)

{
    "employees": [
        {
            "firstName": "John",
            "lastName": "Doe",
            "hobby":["游泳","打游戏","跳舞"]
        },
        {
            "firstName": "Anna",
            "lastName": "Smith",
            "hobby":["游泳","打游戏","跳舞"]
        },
        {
            "firstName": "Peter",
            "lastName": "Jones",
            "hobby":["游泳","打游戏","跳舞"]
        },
    ]
}
常用的JSON工具
  1. Gson
  2. FastJSON
  3. Jackson(推荐)
Jackson基本教学

Jackson通过将JSON字段的名称与Java对象中的getter和setter方法进行匹配,将JSON对象的字段映射到Java对象中的属性。 Jackson删除了getter和setter方法名称的“ get”和“ set”部分,并将其余名称的第一个字符转换为小写。
如果需要以其他方式将JSON对象字段与Java对象字段匹配,则需要使用自定义序列化器和反序列化器,或者使用一些Jackson注解


  com.fasterxml.jackson.core
  jackson-databind
  2.9.6

JSON字符串–>Java对象
ObjectMapper objectMapper = new ObjectMapper();
​
String carJson =
    "{ "brand" : "Mercedes", "doors" : 5 }";
​
Car car = objectMapper.readValue(carJson, Car.class);
JSON数组字符串–>Java对象数组
String jsonArray = "[{"brand":"ford"}, {"brand":"Fiat"}]";
​
ObjectMapper objectMapper = new ObjectMapper();
​
Car[] cars2 = objectMapper.readValue(jsonArray, Car[].class);

JSON文件–>Java对象
ObjectMapper objectMapper = new ObjectMapper();
​
File file = new File("data/car.json");
​
Car car = objectMapper.readValue(file, Car.class);
JSON字节输入流–>Java对象
ObjectMapper objectMapper = new ObjectMapper();
​
InputStream input = new FileInputStream("data/car.json");
​
Car car = objectMapper.readValue(input, Car.class);
Jackson工具类
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.*;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// 注意如果转换对象有内部类 那么这个对象的内部类必须设置static
// 不然报错can only instantiate non-static inner class by using default, no-argument constructor
@Slf4j
public class JsonJacksonUtil {

    private static ObjectMapper objectMapper = new ObjectMapper();
    // 日起格式化
    private static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";
    static {
        //对象的所有字段全部列入
        objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
        //取消默认转换timestamps形式
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        //忽略空Bean转json的错误
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS,false);
        //所有的日期格式都统一为以下的样式,即yyyy-MM-dd HH:mm:ss
        objectMapper.setDateFormat(new SimpleDateFormat(STANDARD_FORMAT));
        //忽略 在json字符串中存在,但是在java对象中不存在对应属性的情况。防止错误
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
        // 允许出现单引号
        objectMapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
    }

    
    @SneakyThrows
    public static String toJson(Object obj)  {
        return objectMapper.writeValueAsString(obj);
    }

    
    @SneakyThrows
    public static String toJsonNotNull(Object obj)  {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return mapper.writeValueAsString(obj);
    }




    
    @SneakyThrows
    public static  T jsonToBean(String jsonString, Class clazz)  {
        objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
        return objectMapper.readValue(jsonString, clazz);
    }




    
    @SneakyThrows
    public static  List jsonToList(String jsonArrayStr, Class clazz)  {

        JavaType javaType = getCollectionType(ArrayList.class, clazz);
        List lst = (List) objectMapper.readValue(jsonArrayStr, javaType);
        return lst;
    }

    
    @SneakyThrows
    public static  T[] jsonToArray(String jsonArrayStr, Class clazz)  {
        JavaType javaType = getCollectionType(ArrayList.class, clazz);
        List lst = (List) objectMapper.readValue(jsonArrayStr, javaType);
        return (T[]) lst.toArray();
    }


    
    @SneakyThrows
    public static  Map jsonToMap(String jsonString)  {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return mapper.readValue(jsonString, Map.class);
    }


    
    @SneakyThrows
    public static  Map jsonToMap(String jsonString, Class clazz)  {
        Map> map = objectMapper.readValue(jsonString, new TypeReference>>() {
        });
        Map result = new HashMap();
        for (Map.Entry> entry : map.entrySet()) {
            result.put(entry.getKey(), map2pojo(entry.getValue(), clazz));
        }
        return result;
    }

    
    @SneakyThrows
    public static Map jsonToMapDepth(String json)  {
        return json2MapRecursion(json, objectMapper);
    }

    
    @SneakyThrows
    public static String mapToJson(Map map) {
        return objectMapper.writeValueAsString(map);
    }

    
    @SneakyThrows
    public static  T mapToBean(Object obj, Class clazz) {
        return objectMapper.convertValue(obj, clazz);
    }

    // 将Bean转成Map     原理就是属性名称对应key   属性值对应value
    @SneakyThrows
    public static Map beanToMap(Object obj) {
        return objectMapper.readValue(toJson(obj), Map.class);
    }


    //将JSON写入文件中
    @SneakyThrows
    public  static  void writeFileJson(File file,String data){
        OutputStream outputStream= new FileOutputStream(file);
        objectMapper.writeValue(outputStream, data);
    }
    //读取文件的JSON
    @SneakyThrows
    public  static  String readFileJson(File file){
       ObjectMapper mapper= new ObjectMapper();
       JsonNode rootNode = mapper.readValue(file, JsonNode.class);
       return toJson(rootNode);
    }


    // ----------------------------------------------------底层方法----------------------------------------------------------





    
    private static List json2ListRecursion(String json, ObjectMapper mapper) throws Exception {
        if (json == null) {
            return null;
        }

        List list = mapper.readValue(json, List.class);

        for (Object obj : list) {
            if (obj != null && obj instanceof String) {
                String str = (String) obj;
                if (str.startsWith("[")) {
                    obj = json2ListRecursion(str, mapper);
                } else if (obj.toString().startsWith("{")) {
                    obj = json2MapRecursion(str, mapper);
                }
            }
        }

        return list;
    }






    
    private static Map json2MapRecursion(String json, ObjectMapper mapper) throws Exception {
        if (json == null) {
            return null;
        }

        Map map = mapper.readValue(json, Map.class);

        for (Map.Entry entry : map.entrySet()) {
            Object obj = entry.getValue();
            if (obj != null && obj instanceof String) {
                String str = ((String) obj);

                if (str.startsWith("[")) {
                    List list = json2ListRecursion(str, mapper);
                    map.put(entry.getKey(), list);
                } else if (str.startsWith("{")) {
                    Map mapRecursion = json2MapRecursion(str, mapper);
                    map.put(entry.getKey(), mapRecursion);
                }
            }
        }

        return map;
    }


    
    public static JavaType getCollectionType(Class collectionClass, Class... elementClasses) {
        return objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
    }


    
    public static  T map2pojo(Map map, Class clazz) {
        return objectMapper.convertValue(map, clazz);
    }

}
 
FastJSON 
        
            com.alibaba
            fastjson
            1.2.51
        
JSON字符串–>Java对象
public static  T parseObject(String text, Class clazz) 
JSON数组字符串–>Java对象数组
public static  List parseArray(String text, Class clazz)
JSON对象转字符串
//JSONObject  和JSONArray
 public static String toJSONString(Object object)
FastJSON工具类
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.serializer.SimpleDateFormatSerializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Date;
import java.util.List;
import java.util.Map;

public class JsonFastJsonUtil {
    private final static Logger logger = LoggerFactory.getLogger(JsonFastJsonUtil.class);
    private static SerializeConfig config;

    static {
        config = new SerializeConfig();
        config.put(Date.class, new SimpleDateFormatSerializer("yyyy-MM-dd HH:mm:ss"));
    }

    private static final SerializerFeature[] features = {
            // 输出空置字段
            SerializerFeature.WriteMapNullValue,
            // list字段如果为null,输出为[],而不是null
            SerializerFeature.WriteNullListAsEmpty,
            // 数值字段如果为null,输出为0,而不是null
            SerializerFeature.WriteNullNumberAsZero,
            // Boolean字段如果为null,输出为false,而不是null
            SerializerFeature.WriteNullBooleanAsFalse,
            // 字符类型字段如果为null,输出为"",而不是null
            SerializerFeature.WriteNullStringAsEmpty
    };


    
    public static String toFeaturesJson(Object object) {
        return JSON.toJSONString(object, config, features);
    }

    
    public static String toJson(Object object) {
        return JSON.toJSONString(object, config);
    }

    
    public static Object parse(String json) {
        return JSON.parse(json);
    }

    
    public static  T parse(String json, Class cls) {
        return JSON.parseObject(json, cls);
    }

    
    @SuppressWarnings("unchecked")
    public static  Map toMap(String json) {
        return (Map) JSONObject.parseObject(json);
    }

    
    public static  List toList(String json, Class cls) {
        return JSON.parseArray(json, cls);
    }


    
    public static String   pretty(JSON json){
        String pretty = JSON.toJSONString(json, SerializerFeature.PrettyFormat, SerializerFeature.WriteMapNullValue,
                SerializerFeature.WriteDateUseDateFormat);
        return  pretty;
    }

}
Gson
       
            com.google.code.gson
            gson
            2.8.6
        

工具类

public class JsonGsonUtils {

   private  static Gson gson ;

   static {
       GsonBuilder gsonBuilder = new GsonBuilder() ;
       // 设置成漂亮的输出
//       gsonBuilder.setPrettyPrinting();
       //设定日期解析格式
       gsonBuilder.setDateFormat("yyyy-MM-dd HH:mm:ss");
       gson=gsonBuilder.create();
   }

    //把json 字符串 转换为 Map
    public static Map jsonTurnMap(String json){
        Map res = null;
        try {
            res = gson.fromJson(json, new TypeToken>() {
            }.getType());

        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        }
        return res;
    }



    // 把JSOn 字符串 转实体类 泛型版
    public static T jsonTurnJavaBena(String json, Class clazz){
       T res = null;
        try {
            res =  (T)gson.fromJson(json,clazz);
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        }
        return res;
    }


//    //把json 字符串 转换为 LIst
    public static    List  jsonTurnList(String json,Class clazz){
        List newres = new ArrayList<>();
        List res = null;
        try {
            res = gson.fromJson(json, new TypeToken>() {}.getType());

        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        }
        for (T re : res) {
            newres.add(JsonGsonUtils.jsonTurnJavaBena(JsonGsonUtils.objTurnJson(re),clazz));
        }

        return newres;
    }



    //把  实体类对象 , List , Map  转 json 字符串
    public static String objTurnJson(Object object){
        return  gson.toJson(object);
    }

}
美化输出的JSON(免依赖)

因为在有些场景下Json格式是需要给用户看的,如果不格式化那么就是一坨谁知道这是啥?

纯手写的美化json,无需任何依赖

package com.c4.utils;

public class JsonFormatTool
{
    
    private static String SPACE = "   ";

    
    public static String formatJson(String json)
    {
        StringBuffer result = new StringBuffer();

        int length = json.length();
        int number = 0;
        char key = 0;
        //遍历输入字符串。
        for (int i = 0; i < length; i++)
        {
            //1、获取当前字符。
            key = json.charAt(i);

            //2、如果当前字符是前方括号、前花括号做如下处理:
            if((key == '[') || (key == '{') )
            {
                //(1)如果前面还有字符,并且字符为“:”,打印:换行和缩进字符字符串。
                if((i - 1 > 0) && (json.charAt(i - 1) == ':'))
                {
                    result.append('n');
                    result.append(indent(number));
                }

                //(2)打印:当前字符。
                result.append(key);

                //(3)前方括号、前花括号,的后面必须换行。打印:换行。
                result.append('n');

                //(4)每出现一次前方括号、前花括号;缩进次数增加一次。打印:新行缩进。
                number++;
                result.append(indent(number));

                //(5)进行下一次循环。
                continue;
            }

            //3、如果当前字符是后方括号、后花括号做如下处理:
            if((key == ']') || (key == '}') )
            {
                //(1)后方括号、后花括号,的前面必须换行。打印:换行。
                result.append('n');

                //(2)每出现一次后方括号、后花括号;缩进次数减少一次。打印:缩进。
                number--;
                result.append(indent(number));

                //(3)打印:当前字符。
                result.append(key);

                //(4)如果当前字符后面还有字符,并且字符不为“,”,打印:换行。
                if(((i + 1) < length) && (json.charAt(i + 1) != ','))
                {
                    result.append('n');
                }

                //(5)继续下一次循环。
                continue;
            }

            //4、如果当前字符是逗号。逗号后面换行,并缩进,不改变缩进次数。
            if((key == ','))
            {
                result.append(key);
                result.append('n');
                result.append(indent(number));
                continue;
            }

            //5、打印:当前字符。
            result.append(key);
        }

        return result.toString();
    }

    
    private static String indent(int number)
    {
        StringBuffer result = new StringBuffer();
        for(int i = 0; i < number; i++)
        {
            result.append(SPACE);
        }
        return result.toString();
    }

    public static void main(String[] args) {
        JsonFormatTool json = new JsonFormatTool();
        String str = "{'age':23,'aihao':['pashan','movies'],'name':{'firstName':'zhang','lastName':'san','aihao':['pashan','movies','name':{'firstName':'zhang','lastName':'san','aihao':['pashan','movies']}]}}";
        String result = formatJson(str);

        System.out.println(result);

    }
}

点赞 -收藏-关注-便于以后复习和收到最新内容
有其他问题在评论区讨论-或者私信我-收到会在第一时间回复
如有侵权,请私信联系我
感谢,配合,希望我的努力对你有帮助^_^

转载请注明:文章转载自 www.mshxw.com
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号