CreaAndroid【1】用注解和反射实现Json自动化解析

最新推荐文章于 2022-10-24 15:38:31 发布
最新推荐文章于 2022-10-24 15:38:31 发布
阅读量501 收藏
点赞数
分类专栏： android 文章标签： android json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011850919/article/details/48313829
版权

今天才写第一篇真正的博客，实在是拖了太长的时间，废话少说，先上一个自己写的Json解析类吧，使用注解和反射写的，类似Gson，但是肯定没那么完善，满足一般需求尚可。自己写而不用Gson的原因就是因为Gson封装度太高用起来不好自由控制。


废话少说，上代码


package uu.com.jsondemo.json;

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

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

public class JsonIn {
	
	public <T> T fromJson(JSONObject jsonObject, Class<T> jsonableClass) {
		return (T) readObject(jsonObject, jsonableClass);
	}
	
	public <T> void fromJson(JSONArray jsonArray, List<T> container) {
		if (container != null) {
			container.addAll((Collection<? extends T>) readCollection(jsonArray, container.getClass()));
		}
	}
	
	private Object readClass(JSONObject jsonObject, Class<?> jsonableClass, Object outObject) {
		if (jsonableClass.isAnnotationPresent(Jsonable.class)) {
			try {
				if (outObject == null) {
					outObject = jsonableClass.newInstance();
				}
		        for(Class<?> superClass = jsonableClass.getSuperclass(); superClass.equals(Object.class) == false; superClass = superClass.getSuperclass()) {  
		        	readClass(jsonObject, superClass, outObject);
		        }
				Field[] fields = jsonableClass.getDeclaredFields();
				for (Field field : fields) {
					readField(jsonObject, outObject, field);
				}
				return outObject;
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (InstantiationException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	private void readField(JSONObject jsonObject, Object outObject, Field field) throws IllegalAccessException {
		if (checkRule(field)) {
			if (field.isAnnotationPresent(Jsonable.JsonKey.class)) {
				Jsonable.JsonKey jsonKey = field.getAnnotation(Jsonable.JsonKey.class);
				if (jsonKey == null) {
					return;
				}
				field.setAccessible(true);
				Class<?> fieldClass = field.getType();
				if (fieldClass.isPrimitive()) {
					Object value = readPrimitiveField(fieldClass, jsonObject, jsonKey.name());
					if (value != null) {
						field.set(outObject, value);
					}
				} else {
					if (fieldClass.equals(String.class)) {
						field.set(outObject, JsonHelper.getStringValue(jsonObject, jsonKey.name(), null));
					} else if (Iterable.class.isAssignableFrom(fieldClass)) {
						JSONArray jsonArray = JsonHelper.getJsonArray(jsonObject, jsonKey.name(), null);
						if (jsonArray != null) {
							Object value = readCollection(jsonArray, fieldClass);
							if (value != null) {
								field.set(outObject, value);
							}
						}
					} else if (fieldClass.isArray()) {
						JSONArray jsonArray = JsonHelper.getJsonArray(jsonObject, jsonKey.name(), null);
						if (jsonArray != null) {
							Object value = readArray(jsonArray, fieldClass);
							if (value != null) {
								field.set(outObject, value);
							}
						}
					} else {
						JSONObject fieldObject = JsonHelper.getJsonObject(jsonObject, jsonKey.name(), null);
						if (fieldObject != null) {
							Object value = readClass(fieldObject, fieldClass, null);
							if (value != null) {
								field.set(outObject, value);
							}
						}
					}
				}
			}
		}
	}

	private Object readPrimitiveField(Class<?> fieldClass, JSONObject jsonObject, String key) {
		if (fieldClass.equals(int.class)) {
			return JsonHelper.getIntValue(jsonObject, key, 0);
		} else if (fieldClass.equals(byte.class)) {
			return JsonHelper.getIntValue(jsonObject, key, 0);
		} else if (fieldClass.equals(char.class)) {
			return JsonHelper.getIntValue(jsonObject, key, 0);
		} else if (fieldClass.equals(short.class)) {
			return JsonHelper.getIntValue(jsonObject, key, 0);
		} else if (fieldClass.equals(float.class)) {
			return (float) JsonHelper.getDoubleValue(jsonObject, key, 0);
		} else if (fieldClass.equals(double.class)) {
			return JsonHelper.getDoubleValue(jsonObject, key, 0);
		} else if (fieldClass.equals(long.class)) {
			return JsonHelper.getLongValue(jsonObject, key, 0);
		} else if (fieldClass.equals(boolean.class)) {
			return JsonHelper.getBooleanValue(jsonObject, key, false);
		}
		return null;
	}
	
	private <T extends Object> Collection<T> readCollection(JSONArray jsonArray, Class<?> fieldClass) {
		int componentCount = jsonArray.length();
		Collection<T> collection = null;
		if (fieldClass.equals(List.class) || fieldClass.equals(ArrayList.class)) {
			collection = new ArrayList<T>(componentCount);
		} else if (fieldClass.equals(LinkedList.class)) {
			collection = new LinkedList<T>();
		}
		if (collection != null) {
			for (int i = 0; i < componentCount; i++) {
				Object elementObject = JsonHelper.get(jsonArray, i, null);
				if (elementObject != null) {
					Object valueObject = readObject(elementObject, fieldClass);
					if (valueObject != null) {
						collection.add((T) valueObject);
					}
				}
			}
		}
		return collection;
	}
	
	private Object readArray(JSONArray jsonArray, Class<?> fieldClass) {
		int componentCount = jsonArray.length();
		Class<?> componentType = fieldClass.getComponentType();
		Object arrayObject = Array.newInstance(componentType, componentCount);
		for (int i = 0; i < componentCount; i++) {
			Object elementObject = JsonHelper.get(jsonArray, i, null);
			if (elementObject != null) {
				Object valueObject = readObject(elementObject, fieldClass);
				if (valueObject != null) {
					Array.set(arrayObject, i, valueObject);
				}
			}
		}
		return arrayObject;
	}
	
	private Object readObject(Object object, Class<?> fieldClass) {
		if (object instanceof JSONArray) {
			if (Iterable.class.isAssignableFrom(fieldClass)) {
				return readCollection((JSONArray) object, fieldClass);
			} else if (fieldClass.isArray()) {
				return readArray((JSONArray) object, fieldClass);
			}
		} else if (object instanceof JSONObject) {
			return readClass((JSONObject) object, fieldClass, null);
		}
		return object;
	}

	private boolean checkRule(Field field) {
		boolean isValidRule = true;
		if (field.isAnnotationPresent(Jsonable.JsonRule.class)) {
			Jsonable.JsonRule jsonRule = field.getAnnotation(Jsonable.JsonRule.class);
			if (jsonRule != null) {
				if (jsonRule.fromJson() == false) {
					isValidRule = false;
				}
			}
		}
		return isValidRule;
	}
	
}


package uu.com.jsondemo.json;

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

import java.lang.reflect.Array;
import java.lang.reflect.Field;

public class JsonOut {
	
	public JSONObject toJson(Object object) {
		return (JSONObject) writeObject(object);
	}

	public JSONArray toJsonArray(Iterable<?> collection) {
		return writeIterable(collection);
	}

	public <T> JSONArray toJsonArray(T[] objects) {
		return writeArray(objects);
	}
	
	private Object writeObject(Object object) {
		Class<?> objectClass = object.getClass();
		if (objectClass.isPrimitive() || objectClass.equals(String.class)) {
			return object;
		} else {
			JSONObject jsonObject = new JSONObject();
	        for(Class<?> superClass = objectClass.getSuperclass(); superClass.equals(Object.class) == false; superClass = superClass.getSuperclass()) {  
				writeClass(object, superClass, jsonObject);
	        }
			writeClass(object, objectClass, jsonObject);
			return jsonObject;
		}
	}

	private void writeClass(Object object, Class<?> objectClass,
			JSONObject jsonObject) {
		if (objectClass.isAnnotationPresent(Jsonable.class)) {
			Jsonable jsonable = objectClass.getAnnotation(Jsonable.class);
			if (jsonable != null) {
				Field[] fields = objectClass.getDeclaredFields();
				if (fields != null) {
					for (Field field : fields) {
						writeField(object, field, jsonObject);
					}
				}
			}
		}
	}

	private void writeField(Object object, Field field, JSONObject jsonObject) {
		if (checkRule(field)) {
			try {
				if (field.isAnnotationPresent(Jsonable.JsonKey.class)) {
					Jsonable.JsonKey jsonKey = field.getAnnotation(Jsonable.JsonKey.class);
					if (jsonKey == null) {
						return;
					}
					field.setAccessible(true);
					String key = jsonKey.name();
					Class<?> fieldTypeClass = field.getType();
					if (fieldTypeClass.isPrimitive()) {
						jsonObject.put(key, field.get(object));
					} else {
						Object fieldObject = field.get(object);
						if (fieldObject != null) {
							if (Iterable.class.isAssignableFrom(fieldTypeClass)) {
								jsonObject.put(key, writeIterable((Iterable<?>) fieldObject));
							} else if (fieldTypeClass.isArray()) {
								jsonObject.put(key, writeArray(fieldObject));
							} else {
								jsonObject.put(key, writeObject(fieldObject));
							}
						}
					}
				}
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
	}

	private JSONArray writeIterable(Iterable<?> it) {
		JSONArray json = new JSONArray();
		for (Object object :  it) {
			json.put(writeObject(object));
		}
		return json;
	}

	private JSONArray writeArray(Object array) {
		JSONArray json = new JSONArray();
		int arrayLength = Array.getLength(array);
		Class<?> componentClass = array.getClass().getComponentType();
		for (int i = 0; i < arrayLength; i++) {
			if (componentClass.isPrimitive()) {
				json.put(Array.get(array, i));
			} else {
				json.put(writeObject(Array.get(array, i)));
			}
		}
		return json;
	}

	private boolean checkRule(Field field) {
		boolean isValidRule = true;
		if (field.isAnnotationPresent(Jsonable.JsonRule.class)) {
			Jsonable.JsonRule jsonRule = field.getAnnotation(Jsonable.JsonRule.class);
			if (jsonRule != null) {
				if (jsonRule.toJson() == false) {
					isValidRule = false;
				}
			}
		}
		return isValidRule;
	}
}


package uu.com.jsondemo.json;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME) 
public @interface Jsonable {

	@Target(ElementType.FIELD)
	@Retention(RetentionPolicy.RUNTIME) 
	public @interface JsonKey {
		
		public String name();

	}

	@Target(ElementType.FIELD)
	@Retention(RetentionPolicy.RUNTIME) 
	public @interface JsonRule {
		
		public boolean toJson();

		public boolean fromJson();
	}

}


package uu.com.jsondemo.json;

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

public class JsonHelper {
	
	public static JSONObject asJsonObject(String json) {
		try {
			return (JSONObject) new JSONTokener(json).nextValue();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	
	public static JSONArray asJsonArray(String json) {
		try {
			return (JSONArray) new JSONTokener(json).nextValue();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	public static String getStringValue(String json, String key, String defaultValue) {
		return JsonHelper.getStringValue(JsonHelper.asJsonObject(json), key, defaultValue);
	}
	
	public static int getIntValue(String json, String key, int defaultValue) {
		return JsonHelper.getIntValue(JsonHelper.asJsonObject(json), key, defaultValue);
	}

	public static boolean getBooleanValue(String json, String key, boolean defaultValue) {
		return JsonHelper.getBooleanValue(JsonHelper.asJsonObject(json), key, defaultValue);
	}
	
	public static double getDoubleValue(String json, String key, double defaultValue) {
		return JsonHelper.getDoubleValue(JsonHelper.asJsonObject(json), key, defaultValue);
	}
	
	public static long getLongValue(String json, String key, long defaultValue) {
		return JsonHelper.getLongValue(JsonHelper.asJsonObject(json), key, defaultValue);
	}
	
	public static Object getValue(String json, String key, Object defaultValue) {
		return JsonHelper.getValue(JsonHelper.asJsonObject(json), key, defaultValue);
	}
	
	public static JSONObject getJsonObject(String json, String key, JSONObject defaultValue) {
		return JsonHelper.getJsonObject(JsonHelper.asJsonObject(json), key, defaultValue);
	}
	
	public static JSONArray getJsonArray(String json, String key, JSONArray defaultValue) {
		return JsonHelper.getJsonArray(JsonHelper.asJsonObject(json), key, defaultValue);
	}
	
	public static String getStringValue(JSONObject jsonObject, String key, String defaultValue) {
		if (JsonHelper.hasKey(jsonObject, key)) {
			try {
				return jsonObject.getString(key);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
		return defaultValue;
	}
	
	public static int getIntValue(JSONObject jsonObject, String key, int defaultValue) {
		if (JsonHelper.hasKey(jsonObject, key)) {
			try {
				return jsonObject.getInt(key);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
		return defaultValue;
	}

	public static boolean getBooleanValue(JSONObject jsonObject, String key, boolean defaultValue) {
		if (JsonHelper.hasKey(jsonObject, key)) {
			try {
				return jsonObject.getBoolean(key);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
		return defaultValue;
	}
	
	public static double getDoubleValue(JSONObject jsonObject, String key, double defaultValue) {
		if (JsonHelper.hasKey(jsonObject, key)) {
			try {
				return jsonObject.getDouble(key);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
		return defaultValue;
	}
	
	public static long getLongValue(JSONObject jsonObject, String key, long defaultValue) {
		if (JsonHelper.hasKey(jsonObject, key)) {
			try {
				return jsonObject.getLong(key);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
		return defaultValue;
	}
	
	public static Object getValue(JSONObject jsonObject, String key, Object defaultValue) {
		if (JsonHelper.hasKey(jsonObject, key)) {
			try {
				return jsonObject.get(key);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
		return defaultValue;
	}
	
	public static JSONObject getJsonObject(JSONObject jsonObject, String key, JSONObject defaultValue) {
		if (JsonHelper.hasKey(jsonObject, key)) {
			try {
				return jsonObject.getJSONObject(key);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
		return defaultValue;
	}
	
	public static JSONArray getJsonArray(JSONObject jsonObject, String key, JSONArray defaultValue) {
		if (JsonHelper.hasKey(jsonObject, key)) {
			try {
				return jsonObject.getJSONArray(key);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
		return defaultValue;
	}
	
	public static JSONObject getJsonObject(JSONArray jsonArray, int index, JSONObject defaultValue) {
		try {
			return jsonArray.getJSONObject(index);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return defaultValue;
	}
	
	public static Object get(JSONArray jsonArray, int index, Object defaultValue) {
		try {
			return jsonArray.get(index);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return defaultValue;
	}
	
	public static boolean hasKey(JSONObject jsonObject, String key) {
		if (jsonObject != null && key != null && !"".equals(key)) {
			return jsonObject.has(key) && !jsonObject.isNull(key);
		}
		return false;
	}
}

下面我们来测试一下，先写两个测试类


package uu.com.jsondemo.test;

import java.util.List;

import uu.com.jsondemo.json.Jsonable;

/**
 * Created by yanhaifeng on 2015/9/8.
 */
@Jsonable
public class TestBeanA {

    @Jsonable.JsonKey(name="id")
    private int id;

    @Jsonable.JsonKey(name="name")
    private String name;

    @Jsonable.JsonKey(name="array")
    private float[] array;

    @Jsonable.JsonKey(name="list")
    private List<String> list;

    @Jsonable.JsonKey(name="child_bean")
    private TestBeanB childBean;

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setArray(float[] array) {
        this.array = array;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setChildBean(TestBeanB childBean) {
        this.childBean = childBean;
    }
}


package uu.com.jsondemo.test;

import uu.com.aarimportdemo.json.Jsonable;

/**
 * Created by yanhaifeng on 2015/9/8.
 */
@Jsonable
public class TestBeanB extends TestBeanA {

    @Jsonable.JsonKey(name="child_name")
    private String childname;

    public void setChildname(String childname) {
        this.childname = childname;
    }
}

准备工作做好，开始测试 


    private void doTest() {
        float[] array = new float[] { 1.1f, 2.2f, 3.3f };

        List<String> list = new ArrayList<>();
        list.add("hahaha");
        list.add("hehehe");

        TestBeanB childBean = new TestBeanB();
        childBean.setChildname("this is a child");
        childBean.setId(2);

        TestBeanA bean = new TestBeanA();
        bean.setId(1);
        bean.setName("this is a bean");
        bean.setArray(array);
        bean.setList(list);
        bean.setChildBean(childBean);

        JSONObject jsonObject = new JsonOut().toJson(bean);

        Log.e("json_test", jsonObject.toString());

        TestBeanA outBean = new JsonIn().fromJson(jsonObject, TestBeanA.class);

        Log.e("json_test", new JsonOut().toJson(outBean).toString());
    }

自己运行一下，看看是不是你想要的效果呢？

Creacc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java使用自定义注解处理器实现自动化文档生成.txt
08-17
这个代码是一个自定义注解处理器，用于自动化生成API文档。在Java中，注解是一种元数据，可以附加到类、方法、字段等元素上，以提供额外的信息。而注解处理器则是一种工具，可以在编译时扫描和处理这些注解，并根据...
利用反射解析json数据
qiuchunjia的专栏
08-06 2870
在做项目的时候，发现android跟服务器交付的时候，要获取服务器的json数据，常规的解析就是拿到数据然后取出json字符串，然后挨个挨个的解析，如果接口很多的话，每一个接口都要写很多类似的解析方式，感觉很麻烦。然后我突然想起貌似可以利用反射解析这些数据，写一个方法，然后就可以解析所有的继承model类的javabean。空说有点听起来的有点懵懂的感觉。 返回的数据格式为这种{ "code":
Android端对不规范的json利用注解SerializedName写Bean类
chrislanbo的专栏
08-31 778
Android端对不规范的json利用注解SerializedName写Bean类
Android解析Json数据(二)—使用反射机制
Thinking in code
10-06 1945
网络传输中很多时候都会使用到JSon数据，每次都要更具key去解析实在是太繁琐、而且容易出错。这个可以通过java中的反射机制来解决，写一个公用的解析类而一劳永逸。
android 自动解析json,Android解析json数据示例代码(三种方式)
weixin_42548782的博客
05-25 333
Json数据[{"code":"110000","sheng":"11","di":"00","xian":"00","name":"北京市","level":1},{"code":"659004","sheng":"65","di":"90","xian":"04","name":"五家渠市","level":3},{"code":"710000","sheng":"71","di":"00",...
Android之解析JSON格式数据
qq_43691887的博客
04-09 2643
Android中解析Json格式数据
利用JAVA注解与反射 - 实现SQL语句自动生成
08-04
利用JAVA注解实现SQL语句自动生成 编写对应Entity添加相关注解，并通过SqlUtil工具，传入相关参数生成SQL语句 例如：要生成对应数据库Person的SQL增删改查 SqlUtil.create(Person.class) SqlUtil.insert(Person....
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
java基础之注解和反射
最新发布
08-05
java基础之注解和反射
JsonFormat与@DateTimeFormat注解实例解析
10-15
主要介绍了JsonFormat与@DateTimeFormat注解实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Android通过gson自动解析服务器返回的json数据
04-22
Android通过gson自动解析服务器返回的json数据
android在线版本更新源代码（update,json解析带注释）
03-24
这里共享一个android在线版本更新的代码，本代码采用json解析版本控制文件，有注释，希望大家批评指正。 注意：版本更新需要对apk文件进行签名!
android 自动解析json,Android 接口返回Json解析
weixin_32068473的博客
05-25 446
基于最原始、最愚蠢的网络请求返回包括网络请求状态，引发的一些思考( 只需要编写body部分，而且body对应的bean可以通过泛型传入，代替Class作为参数传入，将解析逻辑抽取并做到可配置，且可分类配置 )举个栗子先// 举个栗子，下面这个Json作为我们要解析的返回数据{"header": {"code": "SUCCESS","message": "响应成功"},"body": {"veri...
android 自动解析json,《android 利用自带技术解析json字符》
weixin_28327051的博客
05-25 80
/***把对象转化成Json字符串*@paramserializable传进来的对象必须实现Serializable接口*@returnJson字符串*/publicstaticStringtoJsonStr(Objectobj){JSONObjectobject=newJSONObject();try{@SuppressWarnings("rawtypes")Class...
Android 解析JSON数据
xaioxaiobai的博客
08-10 5524
使用JSONObject解析JSON数据，通过GSON去解析JSON数据。
android 动态解析json,使用GSON在android中解析动态“key”和“value”的JSON
weixin_36473855的博客
05-26 821
我能想到的最直接的方法是将结构视为Map(Map)。使用Gson，这是相对容易的，只要Map结构是静态已知的，来自根的每个分支都具有相同的深度，并且所有内容都是String。import java.io.FileReader;import java.lang.reflect.Type;import java.util.Map;import com.google.gson.Gson;import c...
FastAPI（28）- JSON Compatible Encoder 利器之 jsonable_encoder
qq_33801641的博客
09-25 982
jsonable_encoder 在实际应用场景中，可能需要将数据类型(如：Pydantic 模型)转换为与 JSON 兼容的类型(如：字典、列表) 比如：需要将数据存储在数据库中 为此，FastAPI 提供了一个 jsonable_encoder() 函数 jsonable_encoder 实际上是 FastAPI 内部用来转换数据的，但它在许多其他场景中很有用 实际栗子 需求 假设有一...
22_JSON兼容编码器
空巢青年_rui的博客
10-24 671
在某些情况下我们可能需要将一种数据类型（如，Pydantic的model）转换成与JSON相兼容的类型（如 dict、list 等）。例如，你想将它存放在数据库中。FastAPI对此提供了一个函数。
如何利用反射，解析json
雪中的烈焰
11-11 1172
java中反射的地位可想而知，有的人说反射就是程序员的春天，现在关于java的框架，反射几乎都会用到，因为确实很方便，说的那么多，那就开始一起探讨吧。 如果用过jdbc的话，我们是怎么加载驱动的呢？我们都会写这样一串代码 Class.forName(&quot;com.mysql.jdbc.Driver&quot;); 其实这里就是用到反射了。这是开场白，那我们就慢慢深入吧，首先新建一个类用于操作 public c...
使用注解和反射解释Junit的底层实现用注解给的int值排序
07-14
Junit 是一个流行的 Java 单元测试框架，它使用注解和反射来实现测试的自动化。在 Junit 中，可以使用注解来标记测试方法，并使用反射来执行这些方法。 要给注解中的 int 值排序，可以使用反射来获取注解的值并进行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值