Json抛弃第三方数据依赖，自己解析数据

最新推荐文章于 2023-01-04 14:14:52 发布
最新推荐文章于 2023-01-04 14:14:52 发布
阅读量217 收藏
点赞数
分类专栏： java reflect json 文章标签： java 反射 json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45285459/article/details/104152141
版权
java 同时被 3 个专栏收录
21 篇文章 0 订阅
订阅专栏
reflect
1 篇文章 0 订阅
订阅专栏
json
1 篇文章 0 订阅
订阅专栏
  1. 通过注解设置解析的参数
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface JSonPath {
	public String path();
}
  1. 使用Java 反射机制，获取类中的方法和属性

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 处理Jason中接收数据中数组，重复字段
 * @author Administrator
 *
 */
@SuppressWarnings("rawtypes")
public class JsonSuperClass {
	public final boolean isDebug = true;
	/**
	 * 读取数组中的所有类型的数据
	 * @param zlass
	 * @param clist
	 * @return
	 */
	private List<Class> getMySuperClasses(Class zlass,List<Class> clist){
		
		clist.add(zlass);
		Class mClass=zlass.getSuperclass();
		if(mClass.getName().equalsIgnoreCase("java.lang.Object"))
		{
			clist.add(mClass);
			return clist;
		}
		else{
			return getMySuperClasses(mClass, clist);
		}
	}
	
	protected List<Field> getAllField(Class mClass)
	{
		//There can't be a duplicate name
		List<Field> mField=new ArrayList<Field>();
		Set<String> mString=new HashSet<String>();
		List<Class> mSuperClass=getMySuperClasses(mClass, new ArrayList<Class>());
		for(int i=0;i<mSuperClass.size();i++)
		{
			Class mSubClass = mSuperClass.get(i);
			Field[] fields= mSubClass.getDeclaredFields();
			addAllOutSameName(mField, mString, fields);
		}
		return mField;
	}
	/**
	 * 剔除重复的值
	 * @param mAllField
	 * @param mSet
	 * @param mField
	 */
	private void addAllOutSameName(List<Field> mAllField, Set<String> mSet,
			Field[] mField) {
		// TODO Auto-generated method stub
		for(int i=0;i<mField.length;i++)
		{
			String name=mField[i].getName();
			if(mSet.contains(name))
			{
				continue;
			}
			else{
				mAllField.add(mField[i]);
				mSet.add(name);
			}
		}
	}

	/**
	 * read jason array
	 * @param mField
	 * @return
	 */
	protected Field[] mFieldArray(List<Field> mField)
	{
		Field[] mSubField = new Field[mField.size()];
		for(int i=0;i<mField.size();i++)
		{
			mSubField[i]=mField.get(i);
		}
		return mSubField;
	}
	
	
}




import android.annotation.SuppressLint;

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

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.List;

public class JsonParser extends JsonSuperClass{



    public JsonParser()
    {

    }

    public Object Parser(String mString, Class<?> mClass)
    {
        JSONObject mObj=null;
        try {
            mObj=new JSONObject(mString);
        } catch (JSONException e) {
            if(isDebug)
                System.out.println("-->class JsonParser line 28 \t"+e.getMessage());
        }
        return Parser(mObj,mClass);
    }

    @SuppressLint("NewApi")
    public Object Parser(JSONObject mObj,Class<?> mClass)
    {
        Object mObject =null;
        try {
            mObject= mClass.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            if(isDebug)
                System.err.println("-->class JsonParser line 41\t没有默认的构造函数，或者构造函数的访问权限不是公共的"+e.getMessage());
            return null;
        }
        Field[] mField = mFieldArray(getAllField(mClass));
        for(Field field:mField)
        {
            field.setAccessible(true);
            if(field.isAnnotationPresent(JSonPath.class))
            {
                JSonPath mAnnotation = field.getAnnotation(JSonPath.class);
                String mJSonKey = mAnnotation.path();//元注释
                Class<?> mSubClass = field.getType();
                /*类的反射机制（在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象
                 *，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。）*/
                if(mSubClass.equals(Long.class)|| "long".equalsIgnoreCase(mSubClass.getName()))
                {
                    try {
                        long mlong=mObj.getLong(mJSonKey);
                        field.setLong(mObject, mlong);
                    } catch (JSONException e) {
                        if(isDebug)
                            System.out.println("-->class JsonParser line 62   未获取数据：\t"+e.getMessage());
                    } catch (IllegalAccessException e) {
                        if(isDebug)
                            System.out.println("-->class JsonParser line 65 Field获取对象非公有异常"+e.getMessage());
                    } catch (IllegalArgumentException e) {
                        if(isDebug)
                            System.out.println("-->class JsonParser line 68  反射机制中设置的参数异常"+e.getMessage());
                    }
                }
                else if(mSubClass.equals(Integer.class) || "int".equalsIgnoreCase(mSubClass.getName()))
                {
                    try {
                        int mInt=mObj.getInt(mJSonKey);
                        field.setInt(mObject, mInt);
                    } catch (JSONException e) {
                        if(isDebug)
                            System.out.println("-->class JsonParser line 78\t未获取数据"+e.getMessage());
                    } catch (IllegalAccessException e) {
                        if(isDebug)
                            System.out.println("-->class JsonParser line 82 Field获取对象非公有异常"+e.getMessage());
                    } catch (IllegalArgumentException e) {
                        if(isDebug)
                            System.out.println("-->class JsonParser line 84  反射机制中设置的参数异常"+e.getMessage());
                    }
                }
                else if(mSubClass.equals(String.class))
                {
                    try {
                        String mString=mObj.getString(mJSonKey);
                        field.set(mObject,mString);
                    } catch (JSONException e) {
                        if(isDebug)
                            System.out.println("-->class JsonParser line 94\t未获取数据"+e.getMessage());
                        try {
                            field.set(mObject, null);
                        } catch (Exception e1) {
                            if(isDebug)
                                System.out.println("-->class JsonParser line 99\t"+e.getMessage());
                        }
                    } catch (IllegalAccessException e) {
                        if(isDebug)
                            System.out.println("-->class JsonParser line 103 Field获取对象非公有异常"+e.getMessage());
                    } catch (IllegalArgumentException e) {
                        if(isDebug)
                            System.out.println("-->class JsonParser line 106  反射机制中设置的参数异常"+e.getMessage());
                    }

                }
                else if(mSubClass.equals(java.util.List.class))
                {
                    Class<?> mListClass =null;
                    mListClass = getListFieldItemClass(field);
                    try {
                        JSONArray mArray=mObj.getJSONArray(mJSonKey);
                        List<?> mList= ParserArray(mArray, mListClass);
                        field.set(mObject, mList);
                    } catch (JSONException e) {
                        if(isDebug)
                            System.out.println("-->class JsonParser line 120\t未获取数据"+e.getMessage());
                    } catch (IllegalAccessException e) {
                        if(isDebug)
                            System.out.println("-->class JsonParser line 123 Field获取对象非公有异常"+e.getMessage());
                    } catch (IllegalArgumentException e) {
                        if(isDebug)
                            System.out.println("-->class JsonParser line 126  反射机制中设置的参数异常"+e.getMessage());
                    }

                }

            }
        }
        return mObject;
    }
    /**
     * 获取超类的实际类型
     * @param field
     * @return
     */
    @SuppressWarnings("rawtypes")
    private Class<?> getListFieldItemClass(Field field)
    {
        //String mString = field.getGenericType().toString();//返回泛型类型的定义
        //System.out.println("-->class JsonParser line 124 \t  "+mString);
        /*
         * 参数化类型在反射方法首次需要时创建（在此包中指定）。
         * 当创建参数化类型 p 时，p 实例化的一般类型声明会被解析，并且按递归方式创建 p 的所有类型参数
         * 类型变量：ParameterizedType 表示参数化类型，
         * TypeVariable 是各种类型变量的公共高级接口
         */
        ParameterizedType mType=(ParameterizedType) field.getGenericType();
        Class mClass =(Class) mType.getActualTypeArguments()[0];
        //System.out.println("-->class JsonParser line 133\t"+mClass.getName());
        return mClass;
    }
    /**
     * 将对应类型的数据存入到数组中
     * @param mArray
     * @param mClass
     * @return
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    private List ParserArray(JSONArray mArray, Class mClass)
    {
        List mSubList=null;
        int mIndex=0;
        if(mClass.equals(Long.class) || "long".equalsIgnoreCase(mClass.getName()))
        {
            mSubList = new ArrayList<Long>();
            mIndex = 1;
        }
        else if(mClass.equals(Integer.class ) || "int".equalsIgnoreCase(mClass.getName()))
        {
            mSubList = new ArrayList<Integer>();
            mIndex = 2;
        }
        else if(mClass.equals(String.class))
        {
            mSubList = new ArrayList<String>();
            mIndex = 3;
        }
        else
        {
            mSubList = new ArrayList<Object>();
            mIndex =4;
        }
        for(int i=0;i<mArray.length();i++)
        {
            try{
                switch(mIndex)
                {
                    case 1:
                        mSubList.add(mArray.getLong(i));
                        break;
                    case 2:
                        mSubList.add(mArray.getInt(i));
                        break;
                    case 3:
                        mSubList.add(mArray.getString(i));
                        break;
                    case 4:
                        try{
                            JSONObject mJsonObj = mArray.getJSONObject(i);
                            Object mObj= Parser(mJsonObj, mClass);
                            mSubList.add(mObj);
                        }catch(Exception e)
                        {
                            if(isDebug)
                                System.err.println("-->class JsonParser line 209\tjson解析异常"+e.getMessage());
                            break;
                        }
                        break;
                    default :
                        break;
                }
            }catch(Exception e)
            {
                if(isDebug)
                    System.out.println("-->class JsonParser line 219\t数据未获取到"+e.getMessage());
            }
        }
        return mSubList;
    }

}

3.测试案例

如创建User 类 ，那么解析的数据可以为

String mJsonStr = "{name:\"tom\",age:23}";
JsonParser mJsontool  = new JsonParser ();
User u = (User)  mJsontool.Parser((String)mJsonStr, User.class);
System.out.println(u);

这是测试类
public class User {

	@JSonPath(path = "name")
	private String name;
	
	@JSonPath(path = "age")
	private int age;

	

	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + "]";
	}
	
	
	
}

记得需要
org.json.JSONObject 这个包

JSON.jar

@松
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Json文件处理依赖包
01-06
Java使用JSon格式的文件，所以需要的所有jar包支持.
第三方提供的JSON数据获取
06-24 380
package javaDemo; import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.UnsupportedEncodingException; import java.net.URL; import java.net.URLConnection; import com.alibaba...
HTML解析看我就够了,不依赖任何第三方,两个方法搞定
weixin_30834783的博客
07-22 79
看完这篇文章你会知道HTML解析其实很简单~项目中后台返回的数据是HTML格式的,感觉特别蛋疼,花了不少时间找了不少资料,感觉解析起来都特别麻烦,经过一段时间研究,发现一般HTML格式的数据都是有规律可找的,那么福利来了,下面介绍一种不常见的但是非常简单易懂的方式---> 字符串截取不废话,上代码~ // 声明文件, @interface GKTopic : NSObject /// ...
Java一次性递归解析json报文为Map(不使用第三方jar包)
Roy_70的专栏
05-15 3898
前言json报文相信大家都接触过，对于前段JavaScript来说，它是最方便处理的数据格式，而对于后端应用来说，解析json报文并没有xml格式来的那么清晰明了，尤其是对于通用的处理来说很难做到，这里在参考了阿里巴巴的json(非fastjson项目)处理后，十分佩服它的思路，尤其是递归迭代的应用，现在将其源码贴出，供自己以及大家学习。
json解析的常用方式（不使用第三方库）
技术老鸟仍在坚持着，大家一起加油
03-05 2355
　　解析json数据有很多种方法，可以使用官方提供的JSONObject，也可以使用谷歌的开源库GSON，另外，一些第三方的开源库如Jackson，FastJSON等也非常不错。接下来主要学习前两种解析方式的用法。 JSONObject json数据： [{"id":"5", "version":"2.1", "name":"c book"}, {"id":&
JavaScript中解析JSON数据的三种方法
10-23
主要介绍了JavaScript中解析JSON数据的三种方法,本文讲解了eval()方法、new Function方法、JSON.parse()方法等三种方法,需要的朋友可以参考下
json数据解析json数据解析
09-18
json数据解析
php解析json数据实例
10-25
主要介绍了php解析json数据实例,很重要的一个应用,需要的朋友可以参考下
Jquery解析json数据详解
01-19
最近被jquery折磨了一番，倒腾了一个jquery解析json的demo,本demo想实现从asp.net后台实例化dataSet或者dataTable数据集，将dataSet转换成json并返回给客户端，客户端用jquery getJson方法解析出来并显示在页面上。...
Android编程解析Json格式数据的方法
09-03
此外，还有其他第三方库，如Gson和Jackson，它们提供了更强大的序列化和反序列化功能，可以更方便地将Json数据转换为Java对象，反之亦然。 总之，理解如何在Android中解析Json数据是开发过程中的基本技能。通过熟练...
不依赖任何库，使用Java实现对象转json
最新发布
weixin_35756373的博客
01-04 262
在 Java 中，可以使用 Google 的 Gson 库来将对象转换为 JSON 字符串。 首先，需要在项目中引入 Gson 库。 然后，可以使用如下代码将对象转换为 JSON 字符串： Gson gson =new Gson(); String json = gson.toJson(object); 其中，object 是要转换的对象，json 是转换后的 JSON 字符串。 如果希望在转换...
JSON数据如何进行解析呢，方式有哪些？
dadadid的博客
08-31 690
这个问题是我们作为程序员几乎每天都要进行的操作，那它有多少种方式呢，我们这里就这点来说一说。 解析的四种方式 官方解析 谷歌 Gson 解析 阿里巴巴 FastJson 解析 Jackson 解析 案例实操 这里我们就只讨论对象与 json 如何互相转换。 这里我们先创建好 Maven 项目，方便引入依赖，通过单元测试来实际检验我们不同的解析方式。 下面我们都使用 User 对象，先创建好我们需要的类。 User.java package org.example; public class User
java json解析jar包_请教java解析json字符串不使用第三方jar包自己怎么写
weixin_31269985的博客
02-15 300
展开全部importjava.util.regex.Matcher;importjava.util.regex.Pattern;importjavax.script.ScriptEngine;importjavax.script.ScriptEngineManager;importjavax.script.ScriptException;importsun.org.mozilla.ja...
依赖管理：究竟该用库还是服务？
cleargreen的博客
03-20 557
当一个系统变得越来越复杂的时候，它必然大量的依赖外部系统和内部其他系统的服务或者库才能达成业务目标，因此，这个时候，对依赖进行有效的管理才能提升业务故障容忍度，这也是大系统小做的核心思路。 在现实生活中，要创造一个没有任何外部依赖的应用并非不可能，但也是极具挑战的。这也是为什么依赖管理对于每个软件项目都是至关重要的一部分。 通常来说，软件中的依赖关系通常包括编译时依赖、测试时依赖和运行
java解析json（二） 解析json的方法介绍
冻梨不是梨的博客
10-27 354
解析json的方法有很多种，常用的有三种，分别是json官方自带的jon解析工具，阿里出品的解析工具，还有产自谷歌的解析工具。 接下来开始逐一介绍这三款工具。 （一） 官方自带的json工具JsonObject 和就JasonArray 如果只是简单一个json 字符串，那么可以直接使用就JsonObject即可，如果是数据类型的字符串，那么可以使用JasonArray。   （二）阿里...
JSONUtil常用工具类 依赖谷歌Gson
qq_39865076的博客
11-07 2971
JsonUtil java常用工具类 依赖： <dependency> <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId> </dependency> 代码...
java解析json的方法_java解析json方法总结
weixin_39980893的博客
02-26 97
工具包org.json.jar，是一个轻量级的，JAVA下的json构造和解析工具包，它还包含JSON与XML, HTTP headers, Cookies, CDL的转换。这里推荐使用：阿里巴巴FastJson是一个Json处理工具包，包括“序列化”和“反序列化”两部分，它具备如下特征：速度最快，测试表明，fastjson具有极快的性能，超越任其他的Java Json parser。包括自称最快...
JSON解析，不用第三方库实现JSON字符串转指定Bean对象
Yumito的博客
08-06 803
参考https://blog.csdn.net/arctan90/article/details/44035023?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_baidulandingword~default-0.control&spm=1001.2101.3001.4242 在SDK中不想加入gson或者alibaba的fastjson，但是后台给的json字串里有数十个参数。百度之后发现了大佬的文章。
json-java需要的依赖_java对象转json串，不依赖第三方库
weixin_27134143的博客
02-28 508
1.[代码][Java]代码import java.beans.BeanInfo;import java.beans.IntrospectionException;import java.beans.Introspector;import java.beans.PropertyDescriptor;import java.text.SimpleDateFormat;import java.util...
新手快速掌握：实战解析第三方接口json数据教程
在IT开发过程中，尤其是与第三方接口交互时，JSON数据解析是一项至关重要的技能。本篇文章针对新手，深入讲解了如何高效地解析来自第三方的JSON报文。首先，理解请求头的重要性被强调，特别是当数据不包含在请求头中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值