基于JSON和java对象的互转方法

2024-03-26 02:00:16

先说下我自己的理解，一般而言，JSON字符串要转为java对象需要自己写一个跟JSON一模一样的实体类bean，然后用bean.class作为参数传给对应的方法，实现转化成功。

上述这种方法太麻烦了。其实有一种东西叫jsonObject可以直接不用新建实体类bean，而实现转化，先说org.json.JSONObject这个JSONObject，贴上代码：

import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.json.JSONObject;

/**
* Json工具类，实现了实体类和Json数据格式之间的互转功能 使用实例：<br>
*/
public class JsonUtils {
 /**
  * 将一个实体类对象转换成Json数据格式
  *
  * @param bean
  *   需要转换的实体类对象
  * @return 转换后的Json格式字符串
  */
 private static String beanToJson(Object bean) {
  StringBuilder json = new StringBuilder();
  json.append("{");
  PropertyDescriptor[] props = null;
  try {
   props = Introspector.getBeanInfo(bean.getClass(), Object.class)
     .getPropertyDescriptors();
  } catch (IntrospectionException e) {
  }
  if (props != null) {
   for (int i = 0; i < props.length; i++) {
    try {
     String name = objToJson(props[i].getName());
     String value = objToJson(props[i].getReadMethod()
       .invoke(bean));
     json.append(name);
     json.append(":");
     json.append(value);
     json.append(",");
    } catch (Exception e) {
    }
   }
   json.setCharAt(json.length() - 1, '}');
  } else {
   json.append("}");
  }
  return json.toString();
 }

 /**
  * 将一个List对象转换成Json数据格式返回
  *
  * @param list
  *   需要进行转换的List对象
  * @return 转换后的Json数据格式字符串
  */
 private static String listToJson(List<?> list) {
  StringBuilder json = new StringBuilder();
  json.append("[");
  if (list != null && list.size() > 0) {
   for (Object obj : list) {
    json.append(objToJson(obj));
    json.append(",");
   }
   json.setCharAt(json.length() - 1, ']');
  } else {
   json.append("]");
  }
  return json.toString();
 }

 /**
  * 将一个对象数组转换成Json数据格式返回
  *
  * @param array
  *   需要进行转换的数组对象
  * @return 转换后的Json数据格式字符串
  */
 private static String arrayToJson(Object[] array) {
  StringBuilder json = new StringBuilder();
  json.append("[");
  if (array != null && array.length > 0) {
   for (Object obj : array) {
    json.append(objToJson(obj));
    json.append(",");
   }
   json.setCharAt(json.length() - 1, ']');
  } else {
   json.append("]");
  }
  return json.toString();
 }

 /**
  * 将一个Map对象转换成Json数据格式返回
  *
  * @param map
  *   需要进行转换的Map对象
  * @return 转换后的Json数据格式字符串
  */
 private static String mapToJson(Map<?, ?> map) {
  StringBuilder json = new StringBuilder();
  json.append("{");
  if (map != null && map.size() > 0) {
   for (Object key : map.keySet()) {
    json.append(objToJson(key));
    json.append(":");
    json.append(objToJson(map.get(key)));
    json.append(",");
   }
   json.setCharAt(json.length() - 1, '}');
  } else {
   json.append("}");
  }
  return json.toString();
 }

 /**
  * 将一个Set对象转换成Json数据格式返回
  *
  * @param set
  *   需要进行转换的Set对象
  * @return 转换后的Json数据格式字符串
  */
 private static String setToJson(Set<?> set) {
  StringBuilder json = new StringBuilder();
  json.append("[");
  if (set != null && set.size() > 0) {
   for (Object obj : set) {
    json.append(objToJson(obj));
    json.append(",");
   }
   json.setCharAt(json.length() - 1, ']');
  } else {
   json.append("]");
  }
  return json.toString();
 }

 private static String stringToJson(String s) {
  if (s == null) {
   return "";
  }
  StringBuilder sb = new StringBuilder();
  for (int i = 0; i < s.length(); i++) {
   char ch = s.charAt(i);
   switch (ch) {
   case '"':
    sb.append("\\\"");
    break;
   case '\\':
    sb.append("\\\\");
    break;
   case '\b':
    sb.append("\\b");
    break;
   case '\f':
    sb.append("\\f");
    break;
   case '\n':
    sb.append("\\n");
    break;
   case '\r':
    sb.append("\\r");
    break;
   case '\t':
    sb.append("\\t");
    break;
   case '/':
    sb.append("\\/");
    break;
   default:
    if (ch >= '\u0000' && ch <= '\u001F') {
     String ss = Integer.toHexString(ch);
     sb.append("\\u");
     for (int k = 0; k < 4 - ss.length(); k++) {
      sb.append('0');
     }
     sb.append(ss.toUpperCase());
    } else {
     sb.append(ch);
    }
   }
  }
  return sb.toString();
 }

 public static String objToJson(Object obj) {
  StringBuilder json = new StringBuilder();
  if (obj == null) {
   json.append("\"\"");
  } else if (obj instanceof Number) {
   Number num = (Number)obj;
   json.append(num.toString());
  } else if (obj instanceof Boolean) {
   Boolean bl = (Boolean)obj;
   json.append(bl.toString());
  } else if (obj instanceof String) {
   json.append("\"").append(stringToJson(obj.toString())).append("\"");
  } else if (obj instanceof Object[]) {
   json.append(arrayToJson((Object[]) obj));
  } else if (obj instanceof List) {
   json.append(listToJson((List) obj));
  } else if (obj instanceof Map) {
   json.append(mapToJson((Map) obj));
  } else if (obj instanceof Set) {
   json.append(setToJson((Set) obj));
  } else {
   json.append(beanToJson(obj));
  }
  return json.toString();
 }

 /**
  * @Title: json2Map
  * @Creater: chencc <br>
  * @Date: 2011-3-28 <br>
  * @Description: TODO转化json2map
  * @param @param jsonString
  * @param @return
  * @return Map<String,Object>
  * @throws
  */
 @SuppressWarnings("unchecked")
 public static Map<String, Object> json2Map(String jsonString) {

  Map<String, Object> map = new HashMap<String, Object>();
  try {
   if(null != jsonString && !"".equals(jsonString)){
    JSONObject jsonObject = new JSONObject(jsonString);

    Iterator keyIter = jsonObject.keys();
    String key = "";
    Object value = null;

    while (keyIter.hasNext()) {
     key = (String) keyIter.next();
     value = jsonObject.get(key);
     map.put(key, value);
    }
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  return map;
 }

 //测试方法
 public static void main(String[] args) {
  Map<String,Object> params = new HashMap<String,Object>();
  params.put("callId123", Integer.valueOf(1000));
  Map retMap = new HashMap();
  retMap.put("params", params);
  retMap.put("result", true);
  List ls = new ArrayList();
  ls.add(new HashMap());
  ls.add("hello world!!");
  ls.add(new String[4]);
  retMap.put("list", ls);

  String[] strArray = new String[10];
  strArray[1]="first";
  strArray[2]="2";
  strArray[3]="3";
  System.out.println("Boolean:"+JsonUtils.objToJson(true));
  System.out.println("Number:"+JsonUtils.objToJson(23.3));
  System.out.println("String:"+JsonUtils.objToJson("sdhfsjdgksdlkjfk\"sd,!#%$^&*#(*@&*%&*$fsdfsdfsdf"));
  System.out.println("Map :"+JsonUtils.objToJson(retMap));
  System.out.println("List:"+JsonUtils.objToJson(ls));
  System.out.println("Array:"+JsonUtils.objToJson(strArray));

  String json = JsonUtils.objToJson(retMap);
  Map r = JsonUtils.json2Map(json);
  System.out.println(r.get("callId123"));

 }
}

再来聊聊net.sf.json.JSONObject这个JSONObject，代码如下

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;
import net.sf.json.util.CycleDetectionStrategy;
import net.sf.json.util.PropertyFilter;

import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonUtil {

 private static ObjectMapper objectMapper = null;
 /**
  * JSON初始化
  */
 static {
  objectMapper = new ObjectMapper();
  //设置为中国上海时区
  objectMapper.setTimeZone(TimeZone.getTimeZone("GMT+8"));
  //空值不序列化
  objectMapper.setSerializationInclusion(Include.NON_NULL);
  //反序列化时，属性不存在的兼容处理
  objectMapper.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
  //序列化时，日期的统一格式
  objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")); 

  objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); 

 } 

 /**
  * 把对象转换成为Json字符串
  *
  * @param obj
  * @return
  */
 public static String convertObjectToJson(Object obj) {
  if (obj == null) {
//    throw new IllegalArgumentException("对象参数不能为空。");
   return null;
  }
  try {
   return objectMapper.writeValueAsString(obj);

  } catch (IOException e) {
   e.printStackTrace();
  }
  return null;

 }
 /**
  * 把json字符串转成Object对象
  * @param jsonString
  * @return T
  */
 public static <T> T parseJsonToObject(String jsonString, Class<T> valueType) {

  if(jsonString == null || "".equals((jsonString))){
   return null;
  }
  try {
   return objectMapper.readValue(jsonString, valueType);
  } catch (Exception e) {
   e.printStackTrace();
  }
  return null;
 }
 /**
  * 把json字符串转成List对象
  * @param jsonString
  * @return List<T>
  */
 @SuppressWarnings("unchecked")
 public static <T> List<T> parseJsonToList(String jsonString,Class<T> valueType) {

  if(jsonString == null || "".equals((jsonString))){
   return null;
  }

  List<T> result = new ArrayList<T>();
  try {
   List<LinkedHashMap<Object, Object>> list = objectMapper.readValue(jsonString, List.class);

   for (LinkedHashMap<Object, Object> map : list) {

    String jsonStr = convertObjectToJson(map);

    T t = parseJsonToObject(jsonStr, valueType);

    result.add(t);
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  return result;
 }
 /**
  * JSON处理含有嵌套关系对象，避免出现异常：net.sf.json.JSONException: There is a cycle in the hierarchy的方法
  * 注意：这样获得到的字符串中，引起嵌套循环的属性会置为null
  *
  * @param obj
  * @return
  */
 public static JSONObject getJsonObject(Object obj) {

  JsonConfig jsonConfig = new JsonConfig();
  jsonConfig.setCycleDetectionStrategy(CycleDetectionStrategy.LENIENT);
  jsonConfig.setJsonPropertyFilter(new PropertyFilter() {

   @Override
   public boolean apply(Object source, String name, Object value) {
    if(value==null){
     return true;
    }
    return false;
   }
  });
  return JSONObject.fromObject(obj, jsonConfig);
 }
 /**
  * JSON处理含有嵌套关系对象，避免出现异常：net.sf.json.JSONException: There is a cycle in the hierarchy的方法

  * 注意：这样获得到的字符串中，引起嵌套循环的属性会置为null
  *
  * @param obj
  * @return
  */
 public static JSONArray getJsonArray(Object obj) {

  JsonConfig jsonConfig = new JsonConfig();
  jsonConfig.setCycleDetectionStrategy(CycleDetectionStrategy.LENIENT);

  return JSONArray.fromObject(obj, jsonConfig);
 }
 /**
  * 解析JSON字符串成一个MAP
  *
  * @param jsonStr json字符串，格式如： {dictTable:"BM_XB",groupValue:"分组值"}
  * @return
  */
 public static Map<String, Object> parseJsonStr(String jsonStr) {

  Map<String, Object> result = new HashMap<String, Object>();

  JSONObject jsonObj = JsonUtil.getJsonObject(jsonStr);

  for (Object key : jsonObj.keySet()) {
   result.put((String) key, jsonObj.get(key));
  }
  return result;
 }

}

总结：net.sf.json.JSONObject这个属于json-lib这个老牌的系列，依赖的包超级多，commons的lang、logging、beanutils、collections等组件都有。

而org.json则相对来说依赖的包少一些，速度和性能方面没有怎么进行测试。

以上这篇基于JSON和java对象的互转方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持我们。

java中实体类和JSON对象之间相互转化

在需要用到JSON对象封装数据的时候,往往会写很多代码,也有很多复制粘贴,为了用POJO的思想我们可以装JSON转化为实体对象进行操作 package myUtil; import java.io.IOException; import myProject.Student; import myProject.StudentList; import org.codehaus.jackson.map.ObjectMapper; import org.json.JSONArray; import or
使用Jackson来实现Java对象与JSON的相互转换的教程

一.入门 Jackson中有个ObjectMapper类很是实用,用于Java对象与JSON的互换. 1.JAVA对象转JSON[JSON序列化] import java.io.IOException; import java.text.ParseException; import java.text.SimpleDateFormat; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonDemo { p
Java中JSON字符串与java对象的互换实例详解

在开发过程中,经常需要和别的系统交换数据,数据交换的格式有XML.JSON等,JSON作为一个轻量级的数据格式比xml效率要高,XML需要很多的标签,这无疑占据了网络流量,JSON在这方面则做的很好,下面先看下JSON的格式, JSON可以有两种格式,一种是对象格式的,另一种是数组对象, {"name":"JSON","address":"北京市西城区","age":25}//JSON的对象格式的字符串 [
java对象与json对象间的相互转换的方法

工程中所需的jar包,因为在网上不太好找,所以我将它放到我的网盘里了,如有需要随便下载. 点击下载 1.简单的解析json字符串首先将json字符串转换为json对象,然后再解析json对象,过程如下. JSONObject jsonObject = JSONObject.fromObject(jsonStr); 根据json中的键得到它的值 String name = jsonObject.getString("name"); int num = jsonObject.getInt
基于JSON和java对象的互转方法

先说下我自己的理解,一般而言,JSON字符串要转为java对象需要自己写一个跟JSON一模一样的实体类bean,然后用bean.class作为参数传给对应的方法,实现转化成功. 上述这种方法太麻烦了.其实有一种东西叫jsonObject可以直接不用新建实体类bean,而实现转化,先说org.json.JSONObject这个JSONObject,贴上代码: import java.beans.IntrospectionException; import java.beans.Introspect
PHP基于MySQL数据库实现对象持久层的方法

本文实例讲述了PHP基于MySQL数据库实现对象持久层的方法.分享给大家供大家参考.具体如下: 心血来潮,做了一下PHP的对象到数据库的简单持久层. 不常用PHP,对PHP也不熟,关于PHP反射的大部分内容都是现学的. 目前功能比较弱,只是完成一些简单的工作,对象之间的关系还没法映射,并且对象的成员只能支持string或者integer两种类型的. 成员变量的值也没有转义一下... 下面就贴一下代码: 首先是数据库的相关定义,该文件定义了数据库的连接属性: <?php /* * Filename
基于序列化存取实现java对象深度克隆的方法详解

我们知道,在java中,将一个非原型类型类型的对象引用,赋值给另一个对象的引用之后,这两个引用就指向了同一个对象,如: 复制代码代码如下: public class DeepCloneTest { private class CloneTest { private Long myLong = new Long(1); } public static void main(String args[]) { new DeepCloneTest().Test(); } public void Te
基于idea 的 Java中的get/set方法之优雅的写法

曾几何时,我们写代码的时候,每次写Bean的时候都会使用快捷键生成get/set方法,有时候我经常会想,既然每一个Bean我们都会给其提供get/set方法,那么为什么还有会这个东西哪?(当然这只是一个问题,毕竟还是很有用的,这一点就是Java语言中的private.public等作用域) 今天说的当然不是这个,我们讨论的是希望有一种优雅的方式编写我们的get/set方法或者说是一种优雅的简化.那我们就说一下今天的主角吧! Lombok Java代码简化神器!就是如此美妙! Lombok是一个可
Docker学习之基于Dockerfile搭建JAVA Tomcat运行环境的方法

前言在第一篇文字中,我们完全人工方式,一个命令一个命令输入,实现一个java tomcat运行环境,虽然也初见成效,但很累人.如果依靠依靠脚本构建一个Tomcat容器实例,一个命令可以搞定,何乐而不为呢.好在Docker提供了Dockerfile作为构建Docker镜像脚本,避免人们一行一行的输入,真是善莫大焉.Dockerfile脚本可以做到随时维护修改,即可以分享,更有利于在模板化,更不用说传输了,好处那是一大箩筐! 最终目的:打造一个支持SSH终端登录.Tomcat7自动运行的Docke
GSON实现Java对象与JSON格式对象相互转换的完全教程

Gson是一个Java库,用来实现Json和Java对象之间的相互转换.Gson是一个托管在https://github.com/google/gson的开源项目. Gson中主要的类是Gson,也可以使用类GsonBuilder在创建Gson对象的同时设置一些选项. Gson对象在处理Json时不会保存任何状态,所以使用者能够很轻松的对同一个Gson对象进行多次序列化.反序列化等操作. 示例:基本使用 //Serialization Gson gson = new Gson(); gson.t
将Java对象序列化成JSON和XML格式的实例

1.先定义一个Java对象Person: public class Person { String name; int age; int number; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age =
Java对象和Json文本转换工具类的实现

目录安装下载源码编译源码添加依赖 Java对象基本数据类型数组列表字典类 Java对象转换为Json文本基本数据类型数组列表字典类 Json文本转换为Java对象基本数据类型数组列表字典类 Json 是一个用于 Java 对象和 Json 文本相互转换的工具类. 安装下载源码 git clone https://github.com/njdi/durian.git 编译源码 cd durian/ 切换至最新版本(Tag),如:0.4, git chec
Java中json与javaBean几种互转的讲解

一.java普通对象和json字符串的互转 java对象---->json 首先创建一个java对象: public class Student { //姓名 private String name; //年龄 private String age; //住址 private String address; public String getName() { return name; } public void setName(String name) { this.name = name; }

基于JSON和java对象的互转方法

相关推荐

随机推荐