通过反射解析json，无需依赖三方

最新推荐文章于 2020-06-29 09:49:23 发布
最新推荐文章于 2020-06-29 09:49:23 发布
阅读量824 收藏
点赞数
分类专栏： Android开发 java 文章标签： json 自定义 java 解析 string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q1435076663/article/details/51993407
版权 
package com.example.jsontools;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import android.util.Log;

/**
 * @author wly
 * @date 2016-07-22
 */
public class JsonUtil {

	/**
	 * 解析字符串 
	 */
	public static String getString(String jsonStr, String key){
		if(isEmpty(jsonStr) || isEmpty(key))
			return null;
		try {
			JSONObject obj = new JSONObject(jsonStr);
			String content = obj.optString(key);
			if(isEmpty(content))
				//统一将所有的空值状态返回为""
				return "";
			return content;
		} catch (JSONException e) {
			Log.e("JsonUtil", e.getMessage());
		}
		return null;
	}
	
	/**
	 * 无数据或解析异常时返回int最小值
	 */
	public static int getInt(String jsonStr, String key){
		if(isEmpty(jsonStr) || isEmpty(key))
			return Integer.MIN_VALUE;
		try {
			JSONObject obj = new JSONObject(jsonStr);
			int content = obj.optInt(key);
			return content;
		} catch (JSONException e) {
			return Integer.MIN_VALUE;
		}
	}
	
	/**
	 * 无数据或解析异常时返回long最小值
	 */
	public static long getLong(String jsonStr, String key){
		if(isEmpty(jsonStr) || isEmpty(key))
			return Long.MIN_VALUE;
		try{
			JSONObject obj = new JSONObject(jsonStr);
			long l = obj.optLong(key);
			return l;
		} catch (JSONException e){
			return Long.MIN_VALUE;
		}
	}
	
	/**
	 * 无数据或解析异常时返回Double最小值
	 */
	public static double getDouble(String jsonStr, String key){
		if(isEmpty(jsonStr) || isEmpty(key))
			return Double.MIN_VALUE;
		try{
			JSONObject obj = new JSONObject(jsonStr);
			double d = obj.optDouble(key);
			return d;
		} catch (JSONException e){
			return Double.MIN_VALUE;
		}
	}
	
	/**
	 * 将json转换为List<Bean>
	 */
	public static <T> List<T> json2BeanList(String jsonStr, Class<T> clazz){
		if(isEmpty(jsonStr))
			return null;
		try{
			List<T> beans = new ArrayList<T>();
			JSONArray arr = new JSONArray(jsonStr);
			for(int i = 0; i < arr.length(); i++)
				beans.add(json2Bean(arr.optJSONObject(i).toString(), clazz));
			return beans;
		} catch (Exception e) {
			Log.e("JsonUtil", e.getMessage());
		}
		return null;
	}
	
	/**
	 * 将json转换为Bean
	 */
	public static <T> T json2Bean(String jsonStr, Class<T> clazz){
		if(isEmpty(jsonStr))
			return null;
		try {
			JSONObject obj = new JSONObject(jsonStr);
			T bean = json2BeanByAttr(clazz, obj);
			return bean;
		} catch (InstantiationException e) {
			Log.e("JsonUtil", e.getMessage());
		} catch (IllegalAccessException e) {
			// 说明访问到了私有的属性，表示该javaBean是private的
			try {
				JSONObject obj = new JSONObject(jsonStr);
				T bean = json2BeanByMethod(clazz, obj);
				return bean;
			} catch (JSONException e1) {
				Log.e("JsonUtil", e1.getMessage());
			} catch (InstantiationException e1) {
				Log.e("JsonUtil", e1.getMessage());
			} catch (IllegalAccessException e1) {
				Log.e("JsonUtil", e1.getMessage());
			} catch (IllegalArgumentException e1) {
				Log.e("JsonUtil", e1.getMessage());
			} catch (InvocationTargetException e1) {
				Log.e("JsonUtil", e1.getMessage());
			}
		} catch (JSONException e) {
			Log.e("JsonUtil", e.getMessage());
		}
		return null;
	}
	
	/**
	 * 当javaBean属性为private修饰时通过set方法设置属性值
	 */
	private static <T> T json2BeanByMethod(Class<T> clazz, JSONObject obj) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
		T bean = clazz.newInstance();
		Method[] methods = clazz.getMethods();
		Field[] fds = clazz.getDeclaredFields();
		for(Field fd : fds){
			List<T> datas = null;
			if(beanContainsCollection(fd)) {
				JSONArray arr = obj.optJSONArray(fd.getName());
				for (int j = 0; j < methods.length; j++) {
					if(methods[j].getName().equalsIgnoreCase("get" + fd.getName()))
					{
						Type fc = fd.getGenericType();
						if(fc == null) continue;  
			            if(fc instanceof ParameterizedType){  
			            	// 如果是泛型参数的类型   
			                ParameterizedType pt = (ParameterizedType) fc;  
			                Class<T> genericClazz = (Class<T>) pt.getActualTypeArguments()[0]; // 得到泛型里的class类型对象。  
			                datas = json2BeanList(arr.toString(), genericClazz);;
			            }   
					}
				}
			}
			for (int i = 0; i < methods.length; i++) {
				if(methods[i].getName().equalsIgnoreCase("set" + fd.getName()))//拼接方法名
					if(datas != null && datas.size() > 0)
						methods[i].invoke(bean, datas);//执行方法
					else	
						methods[i].invoke(bean, obj.opt(fd.getName()));//执行方法
			}
		}
		return bean;
	}
	
	/**
	 * 当javaBean属性为public修饰时直接设置属性值
	 */
	private static <T> T json2BeanByAttr(Class<T> clazz, JSONObject obj) throws InstantiationException, IllegalAccessException{
		T bean = clazz.newInstance();
		Field[] fds = clazz.getDeclaredFields();
		for(Field fd : fds)
            fd.set(bean, obj.opt(fd.getName()));//设置属性
		return bean;
	}
	
	/**
	 * 集合对象转json
	 */
	public static <T> String beanList2Json(/*Class<T> bean,*/ List<T> infos){
		if(infos == null || infos.size() == 0)
			return null;
		StringBuffer buffer = new StringBuffer();
		buffer.append("[");
		for (int i = 0; i < infos.size(); i++) 
			buffer.append(bean2Json((Class<T>) infos.get(i).getClass(), infos.get(i)) + ((i == infos.size() - 1) ? "" : "," ));
		return buffer.append("]").toString();
	}
	
	/**
	 * Map<T, T>集合嵌套转换为json
	 */
	public static <T> String beanMap2Json(Map<T, T> maps){
		if(maps.size() == 0 || maps == null)
			return null;
		StringBuffer buffer = new StringBuffer();
//		buffer.apped("{");
		Set<T> keys = maps.keySet();
		for(T key : keys){
			if(maps.get(key).getClass().toString().contains("Map"))
				return "\"" + key + "\":" + beanMap2Json((Map<T, T>)maps.get(key));
			 else if(maps.get(key).getClass().toString().contains("List"))
				return "\"" + key + "\":" + beanList2Json((List<T>)maps.get(key));
			String bean2Json = bean2Json((Class<T>)maps.get(key).getClass(), maps.get(key));
			buffer.append("\"" + key + "\":[{").append(bean2Json.substring(1, bean2Json.length() - 1)).append("}],");
		}
		return buffer.substring(0, buffer.length() - 1);
	}

	/**
	 * Map<T, List<T>>集合嵌套转换为json
	 */
	public static <T> String beanListMap2Json(/*Class<T> bean, */Map<T, List<T>> maps){
		if(maps.size() == 0 || maps == null)
			return null;
		StringBuffer buffer = new StringBuffer();
		buffer.append("{");
		Set<T> keys = maps.keySet();
		for(T key : keys)
			buffer.append("\"" + key + "\":").append(beanList2Json(/*bean, */maps.get(key))).append(",");
		return buffer.substring(0, buffer.length() - 1) + "}";
	}
	
	
	/**
	 * 对象转json
	 */
	public static <T> String bean2Json(Class<T> clazz, T info){
		try {
			String json = bean2JsonByAttr(clazz, info);
			return json;
		} catch (IllegalAccessException e) {
			// 说明访问到了私有的属性，表示该javaBean是private的
			try {
				String json = bean2JsonByMethod(/*clazz, */info);
				return json;
			} catch (Exception e1) {
				Log.e("JsonUtil", e1.getMessage());
			}
		}
		return null;
	}
	
	private static <T> String bean2JsonByAttr(Class<T> clazz, T info) throws IllegalAccessException{
		StringBuffer buffer = new StringBuffer();
		Field[] fds = clazz.getDeclaredFields();
		buffer.append("{");
		for(Field fd : fds){
			if(beanContainsCollection(/*clazz, */fd/*, info*/)){
				String jsonBean = beanType(/*clazz,*/ fd, info);
				buffer.append(jsonBean + ",");
				continue;
			}
			String name = fd.getName();
			Object value = fd.get(info);
			try{
				if(fd.getType().newInstance() instanceof String)
					buffer.append("\"" + name + "\":\"" + value + "\",");
				else
					buffer.append("\"" + name + "\":" + value + ",");
			} catch (InstantiationException e) {
				buffer.append("\"" + name + "\":" + value + ",");
			}
		}
		return buffer.substring(0, buffer.length() - 1) + "}";
	}
	
	private static <T> String bean2JsonByMethod(/*Class<T> clazz, */T info) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException{
		StringBuffer buffer = new StringBuffer();
		Method[] methods = info.getClass().getMethods();
		Field[] fds = info.getClass().getDeclaredFields();
		buffer.append("{");
		for(Field fd : fds){
			if(beanContainsCollection(/*clazz, */fd/*, info*/)){
				String jsonBean = beanType(/*clazz,*/ fd, info);
				buffer.append(jsonBean + ",");
				continue;
			}
			for (int i = 0; i < methods.length; i++) {
				if(methods[i].getName().equalsIgnoreCase("get" + fd.getName())){
					Object value = methods[i].invoke(info);//执行方法
					String name = fd.getName();
					try{
						if(fd.getType().newInstance() instanceof String)
							buffer.append("\"" + name + "\":\"" + value + "\",");
						else
							buffer.append("\"" + name + "\":" + value + ",");
					} catch (InstantiationException e) {
						buffer.append("\"" + name + "\":" + value + ",");
					}
				}
			}
		}
		return buffer.substring(0, buffer.length() - 1) + "}";
	}
	
	/**
	 * 对象中如果包含有集合<对象>的处理方法
	 * @throws IllegalArgumentException 
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 */
	private static <T> String beanType(/*Class<T> clazz, */Field fd, T info){
		try {
			Object instance = fd.getType().newInstance();
		} catch (Exception e) {
			// 判断该属性是否是集合
			if(e.getMessage().contains("Map"))
				try {
					return beanMap2Json(/*clazz, */(Map<T, T>)fd.get(info));
				} catch (IllegalAccessException e1) {
					// 被private 修饰，调用get方法获取参数
					return beanTypeByMethod(/*clazz, */fd, info, "map");
				} catch (IllegalArgumentException e1) {
					Log.e("JsonUtil", e1.getMessage());
				}
			if(e.getMessage().contains("List"))
				try {
					return beanList2Json(/*clazz, */(List<T>)fd.get(info));
				} catch (IllegalAccessException e1) {
					// 被private 修饰，调用get方法获取参数
					return beanTypeByMethod(/*clazz, */fd, info, "list");
				} catch (IllegalArgumentException e1) {
					Log.e("JsonUtil", e1.getMessage());
				}
		}
//		// 判断属性为哪种集合
//		if(instance instanceof Map) 
//			return beanListMap2Json(clazz, (Map<T, List<T>>)fd.get(info));
//		if(instance instanceof List)
//			return beanList2Json(clazz, (List<T>)fd.get(info));
		return null;
	}

	private static <T> String beanTypeByMethod(/*Class<T> clazz, */Field fd, T info, String type) {
		Method[] methods = info.getClass().getMethods();
		for (int i = 0; i < methods.length; i++) {
			if(methods[i].getName().equalsIgnoreCase("get" + fd.getName())){
				try {
					Object value = methods[i].invoke(info);
					if(type.equals("list"))
						return "\"" + fd.getName() + "\":" + beanList2Json(/*clazz, */(List<T>)value);
					else
						return beanMap2Json(/*clazz, */(Map<T, T>)value);
				} catch (IllegalAccessException e2) {
					Log.e("JsonUtil", e2.getMessage());
				} catch (IllegalArgumentException e2) {
					Log.e("JsonUtil", e2.getMessage());
				} catch (InvocationTargetException e2) {
					Log.e("JsonUtil", e2.getMessage());
				}
			}
		}
		return null;
	}
	
	/**
	 * 判断对象中是否包含集合
	 */
	private static <T> boolean beanContainsCollection(/*Class<T> clazz, */Field fd/*, T info*/){
		try {
			Object instance = fd.getType().newInstance();
			// 判断该属性是否是集合
//			if(instance instanceof  Collection || instance instanceof Map)
//				return true;
		} catch (Exception e) {
			// 判断该属性是否是集合
			if(e.getMessage().contains("Map") || e.getMessage().contains("List"))
				return true;
		}
		return false;
	}
	
	/**
	 * 验证非空
	 */
	private static boolean isEmpty(String str){
		if(str == null || "".equals(str) || "null".equals(str))
			return true;
		return false;
	}
}
相对于上一篇博客，这里的方法更为全面一些，新增功能：将Map<T, T>  Map<T , List<T>>转换为Json字符串，以及解析json时解析到对象中的List<Bean>的解析，如果有什么问题，请及时指正，欢迎留言
q1435076663
关注
专栏目录
Flutter 应用热更新
xiangzhihong8的专栏
04-24 3852
Flutter 热更新简介 所谓热更新，指的是当应用代码出现缺陷问题时，不需要重新打包提交App Store即可完成缺陷的修复。众所周知，使用原生技术开发的应用体验虽然好，但开发、上线周期长也常常被诟病，特别是当应用出现线上问题时，不得不重新打包发布，大大的影响了用户体验，而热更新技术就是为有效解决线上缺陷而提出的。 不过，热更新虽然具有很大的优点，但是滥用热修复也会给应用带来不好的体验，并且苹果...
iOS：iOS开发非常全的三方库、插件等等
dienangpiao2051的博客
09-23 7567
iOS开发非常全的三方库、插件等等 github排名:https://github.com/trending, github搜索：https://github.com/search. 此文章转自github:https://github.com/Tim9Liu9/TimLiu-iOS 一、UI 下拉刷新 EGOTableViewPullRefresh- 最早...
利用java反射机制解析json
新仙出炉的博客
09-21 6253
Android开发时经常需要用到json数据
【反射】解析json 为例
masque的技术博客,欢迎指导!
07-27 160
好久没有弄过反射了，今天周末，想起来复习了下！ Person实体类   package com.masque.json; import java.util.Date; /** * * @title: 实体信息 * @description: json对应封装的实体 * @className: Person.java * @author: masque * @creat...
如何利用反射，解析json
雪中的烈焰
11-11 1242
java中反射的地位可想而知，有的人说反射就是程序员的春天，现在关于java的框架，反射几乎都会用到，因为确实很方便，说的那么多，那就开始一起探讨吧。 如果用过jdbc的话，我们是怎么加载驱动的呢？我们都会写这样一串代码 Class.forName(&quot;com.mysql.jdbc.Driver&quot;); 其实这里就是用到反射了。这是开场白，那我们就慢慢深入吧，首先新建一个类用于操作 public c...
用反射完成Json解析
qq_26946497的博客
01-10 707
前言： Json解析工具已经有一大堆一大堆得了，为什么还要多此一举，自己写一个出来呢？ 主要的原因是：大量的Json解析工具都不检查重复引用。一旦出现A中包含B，B中包含A这样的情况（在工作中是经常出现的！）就会崩溃！ 这个工具类首先完成了对重复性的检查。除此之外呢，就是对我个人来说的额外原因了：容易扩展。 毕竟自己写的代码，想咋扩咋扩，比起读那些工具类的源码真是轻松太多了，让解析效率见鬼
反射--> 解析JSON数据
weixin_30653097的博客
02-22 138
方法一 Persons.json文件 [ { "name": "Chris", "age": 18, "city": "Shanghai", "job": "iOS" }, { "name": "Ada", "age": 16, "city": "Beijing", "job": "student" }, { "name": "...
iOS快速开发框架Bee-Framework应用和解析（二) --- Bee framework架构概览
Yu的专栏
02-10 2830
在第二部分里，分享一下Bee Framework架构的看法。如果您下载了Bee Framework, 在/document/developer_manual.pdf有Bee的开发手册。手册里有典型的教程，也有对架构的讲解。本文试图融入个人的理解，解答以下问题：  Bee的MVC是如何工作的，核心组件是哪些？ Bee的整体架构如何？ 除了MVC, Bee提供了哪些常用的工具和服务？ 该
Android混淆打包总结
茅屋
05-05 6368
Android 混淆打包Android Studio和Eclipse虽然是两个不同的工具，混淆的使用虽然不同，但规则相同。Eclipse混淆在eclipse中，文件根目录中有如下两个文件projiect.properties和proguard-project.txt。 开启混淆打包只需要在projiect.properties中，被注释的有如下一句话proguard.config=${sdk.di
Android开源经典项目
Tamic （大白）
09-13 5788
Android开源项目大全，包括经典个人博客，组织和开源项目
java反射实现Object转json
05-30
利用java反射机制实现Object转json.
使用JSON所需依赖包
03-17
使用JSON时，所需要的依赖包：json-lib-2.4-jdk15.jar，commons-beanutils.jar，commons-httpclient.jar，commons-lang.jar，ezmorph.jar，morph-1.0.1.jar
JSON解析和反解析源代码
09-17
json解析和反解析的官方源代码，亲自测试可靠，没有BUG。
json，反射实现对象转json
八重齒
05-04 788
将一个对象转为json 对象定义实体：package com.ziv.bean; import java.util.List; public class User { private Integer[] id; private String name; private List&lt;UserDesc&gt; userDescs; public void setId(Integer[]...
json读写（简洁版，不依赖第三方库）
weixin_37055691的博客
06-29 439
#include <iostream> #include <fstream> #include <iomanip> #include "json.hpp" using namespace std; using json = nlohmann::json; int main() { cout << "Json test" << endl; //**********************************************json
Java反射机制的运用-Json解析
尹忠政的博客
03-08 586
大家好啊，好几天没写了，今天项目中json解析很是烦恼（Gson不可以用，原因后台爸爸们不规范），所以我就想要让原生json解析更快点，so，问题来了./** * 这个方法用于调用对象的方法更新字段 * */ public <T> void invoke(T t,String key,Object value,Class valueClass){ try
【Java学习20170411】反射+Json解析
linsila8121的博客
04-11 595
第七章 1、反射： 1）、用来实心动态代理； 2）、在运行过程中动态获取对象的类型； 3）、在运行过程中，动态加载对象； 4）、在运行过程中，动态的调用对象的方法； 5）、常常用来实现框架 2、Object是所有类型的父类，Java所有类型，包括自定义类型都默认继承Object 3、Class类型：反射技术的核心类，通过这个类，完成所有反射技术的实现，获取class对象的三种方法：
反射解析json为实体工具类
qq962464qq的博客
04-12 383
Json格式的数据是实际开发中经常用到的数据格式，java有直接解析为实体的方法，但是实体属性对用不上的时候回报错，所以写了一个用反射和泛型的方式来解析json为实体的工具类。非常简单 @SuppressWarnings("unchecked") public static T jsonToObject(JSONObject json,Class clazz) throws NoSuchM
json和反射
Luck_Ape的博客
09-03 452
现有一需求将实体对应属性的json解析写入到对应实体的字段属性中，对应属性较复杂(包含实体和list&lt;E&gt;等)。 方法如下： 已知实体以及每个属性字段所对应的值为复杂json存入map当中。然后将所有对应的值解析转换到对应实体的字段属性中。 代码如下：   private static &lt;T&gt; T transformMapToSjmhReportResultDa...
golang 反射解析json
最新发布
08-10
在 Golang 中，可以使用反射来解析 JSON 数据。下面是一个简单的示例： 首先，你需要定义一个结构体，该结构体的字段与 JSON 数据的字段对应。例如，假设我们有以下的 JSON 数据： ```json { "name": "John", ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值