TypeAdapterFactory
- 1.接口类，主要是用来创建TypeAdapter对象的
- 2.若Json中的数据结构相同，可以进行共享
- 3.其实现类分别是JsonAdapterAnnotationTypeAdapterFactory/ReflectiveTypeAdapterFactory/以及TypeAdapters中各种已经数据类型对应的factory
源码
public interface TypeAdapterFactory {
/**
* 创建一个类型适配器
* @param gson gson对象
* @param type TypeToken
* @param <T> 泛型
* @return 返回泛型类的TypeAdapter
*/
<T> TypeAdapter<T> create(Gson gson, TypeToken<T> type);
}
InstanceCreator
源码
public interface InstanceCreator<T> {
public T createInstance(Type type);
}
ObjectConstructor
- .接口泛型类，主要用于调用construct()来返回java object对象
源码
public interface ObjectConstructor<T> {
/**
* Returns a new instance.
*/
public T construct();
}
ConstructorConstructor
- 1.该类主要用于构建java object对象
- 2.通过传递的typeToken参数，返回对应ObjectConstructor对象，之后根据ObjectConstructor的construct方法返回Java Object对象
- 3.该类被用在ReflectiveTypeAdapterFactory和JsonAdapterAnnotationTypeAdapterFactory中构建java object对象
源码
public final class ConstructorConstructor {
/**
* Map 集合 key:type 指数据对象是什么类型的数据
* value:InstanceCreator 主要用于根据type创建实例
*
*
* 该集合主要用于缓存创建实例的方式 当下次再次使用时 直接取即可 无序再次通过反射来创建 提高效率
*/
private final Map<Type, InstanceCreator<?>> instanceCreators;
//反射工具类 主要帮助设置makeAccessible(true)
private final ReflectionAccessor accessor = ReflectionAccessor.getInstance();
//在构造函数中获取map集合，里面存储了对象的类以及实例 默认是空集合
public ConstructorConstructor(Map<Type, InstanceCreator<?>> instanceCreators) {
this.instanceCreators = instanceCreators;
}
/**
* 1.根据typeToken 获取对应的type以及class
* 2.1 尝试根据type从map取对应的InstanceCreate 若取到了直接new ObjectConstructor
* 在constructor方法中调用InstanceCreate.createInstance(type) 返回实例
* 2.2 尝试根据class从map取对应的InstanceCreate 若取到了直接new ObjectConstructor
* 在constructor方法中调用InstanceCreate.createInstance(type) 返回实例
* 2.3 以上两中都没有成功 此时就借助反射，根据class.getDeclaredConstructor(),获取构造器
若取到了直接new ObjectConstructor在constructor方法中调用newInstance 返回实例
* 2.4 若还是不能成功，则表示可能是集合 ，此时就根据类型来创建集合实例
* 2.5 以上以上不成功 只能通过Unsafe来构建 但是需要自己来处理回收
* @param typeToken
* @param <T>
* @return
*/
public <T> ObjectConstructor<T> get(TypeToken<T> typeToken) {
System.out.println("开始通过get获取对应的ObjectConstructor");
//获取typetoken的泛型类型
final Type type = typeToken.getType();
//获取泛型类型的class
final Class<? super T> rawType = typeToken.getRawType();
System.out.println("获取typetoken对应的type和rawtype:"+type+"-->"+rawType);
// 首先尝试创建实例
//先根据type取对应的InstanceCreator
final InstanceCreator<T> typeCreator = (InstanceCreator<T>) instanceCreators.get(type);
System.out.println("先根据type取对应的InstanceCreator:"+typeCreator);
//若不为空 则创建ObjectConstructor 在重写的方法中createInstance进行实例的创建
if (typeCreator != null) {
return new ObjectConstructor<T>() {
@Override public T construct() {
System.out.println("若不为空 则创建ObjectConstructor 在重写的方法中createInstance进行实例的创建 81:"+typeCreator+"-->"+type);
return typeCreator.createInstance(type);
}
};
}
// 接下来尝试实例创建器的原始类型匹配
//若根据type获取对应的InstanceCreator为空 则根据class从instanceCreators中取对应的InstanceCreator
final InstanceCreator<T> rawTypeCreator =
(InstanceCreator<T>) instanceCreators.get(rawType);
//若获取到rawTypeCreator，则创建ObjectConstructor 在方法中调用createInstance创建实例
if (rawTypeCreator != null) {
return new ObjectConstructor<T>() {
@Override public T construct() {
System.out.println("若根据type获取对应的InstanceCreator为空 则根据class从instanceCreators中取对应的InstanceCreator 96:"+rawTypeCreator+"-->"+type);
return rawTypeCreator.createInstance(type);
}
};
}
//若上面都没有从map中获取成功 则通过默认的方法构建ObjectConstructor
ObjectConstructor<T> defaultConstructor = newDefaultConstructor(rawType);
System.out.println("若上面都没有从map中获取成功 则通过默认的方法构建ObjectConstructor:"+defaultConstructor);
if (defaultConstructor != null) {
return defaultConstructor;
}
//若使用反射构造函数都没有创建成功
ObjectConstructor<T> defaultImplementation = newDefaultImplementationConstructor(type, rawType);
System.out.println("数组结构:"+defaultImplementation);
if (defaultImplementation != null) {
return defaultImplementation;
}
// 不安全的创建返回 不安全非佩奇
System.out.println("采用不安全的方式创建");
return newUnsafeAllocator(type, rawType);
}
private <T> ObjectConstructor<T> newDefaultConstructor(Class<? super T> rawType) {
try {
//class.getDeclaredConstructor 获取class的构造方法
final Constructor<? super T> constructor = rawType.getDeclaredConstructor();
if (!constructor.isAccessible()) {
accessor.makeAccessible(constructor);
}
return new ObjectConstructor<T>() {
@SuppressWarnings("unchecked") // T is the same raw type as is requested
@Override public T construct() {
try {
//通过构造的newInstance方法获取对应的实例对象
Object[] args = null;
return (T) constructor.newInstance(args);
} catch (InstantiationException e) {
// TODO: JsonParseException ?
throw new RuntimeException("Failed to invoke " + constructor + " with no args", e);
} catch (InvocationTargetException e) {
// TODO: don't wrap if cause is unchecked!
// TODO: JsonParseException ?
throw new RuntimeException("Failed to invoke " + constructor + " with no args",
e.getTargetException());
} catch (IllegalAccessException e) {
throw new AssertionError(e);
}
}
};
} catch (NoSuchMethodException e) {
return null;
}
}
/**
* 常用接口类型如Map和List及其构造函数子类型。
*/
private <T> ObjectConstructor<T> newDefaultImplementationConstructor(
final Type type, Class<? super T> rawType) {
//若是rawtype是list类型
if (Collection.class.isAssignableFrom(rawType)) {
if (SortedSet.class.isAssignableFrom(rawType)) {
return new ObjectConstructor<T>() {
@Override public T construct() {
return (T) new TreeSet<Object>();
}
};
//若是rawtype是EnumSet的子类
} else if (EnumSet.class.isAssignableFrom(rawType)) {
return new ObjectConstructor<T>() {
@SuppressWarnings("rawtypes")
@Override public T construct() {
if (type instanceof ParameterizedType) {
Type elementType = ((ParameterizedType) type).getActualTypeArguments()[0];
if (elementType instanceof Class) {
return (T) EnumSet.noneOf((Class)elementType);
} else {
throw new JsonIOException("Invalid EnumSet type: " + type.toString());
}
} else {
throw new JsonIOException("Invalid EnumSet type: " + type.toString());
}
}
};
//若是rawtype是Set的子类
} else if (Set.class.isAssignableFrom(rawType)) {
return new ObjectConstructor<T>() {
@Override public T construct() {
return (T) new LinkedHashSet<Object>();
}
};
//若是rawtype是Queue的子类
} else if (Queue.class.isAssignableFrom(rawType)) {
return new ObjectConstructor<T>() {
@Override public T construct() {
return (T) new ArrayDeque<Object>();
}
};
} else {//集合
return new ObjectConstructor<T>() {
@Override public T construct() {
return (T) new ArrayList<Object>();
}
};
}
}
//map类型
if (Map.class.isAssignableFrom(rawType)) {
if (ConcurrentNavigableMap.class.isAssignableFrom(rawType)) {
return new ObjectConstructor<T>() {
@Override public T construct() {
return (T) new ConcurrentSkipListMap<Object, Object>();
}
};
} else if (ConcurrentMap.class.isAssignableFrom(rawType)) {
return new ObjectConstructor<T>() {
@Override public T construct() {
return (T) new ConcurrentHashMap<Object, Object>();
}
};
} else if (SortedMap.class.isAssignableFrom(rawType)) {
return new ObjectConstructor<T>() {
@Override public T construct() {
return (T) new TreeMap<Object, Object>();
}
};
} else if (type instanceof ParameterizedType && !(String.class.isAssignableFrom(
TypeToken.get(((ParameterizedType) type).getActualTypeArguments()[0]).getRawType()))) {
return new ObjectConstructor<T>() {
@Override public T construct() {
return (T) new LinkedHashMap<Object, Object>();
}
};
} else {
return new ObjectConstructor<T>() {
@Override public T construct() {
return (T) new LinkedTreeMap<String, Object>();
}
};
}
}
return null;
}
private <T> ObjectConstructor<T> newUnsafeAllocator(
final Type type, final Class<? super T> rawType) {
return new ObjectConstructor<T>() {
private final UnsafeAllocator unsafeAllocator = UnsafeAllocator.create();
@SuppressWarnings("unchecked")
@Override public T construct() {
try {
Object newInstance = unsafeAllocator.newInstance(rawType);
return (T) newInstance;
} catch (Exception e) {
throw new RuntimeException(("Unable to invoke no-args constructor for " + type + ". "
+ "Registering an InstanceCreator with Gson for this type may fix this problem."), e);
}
}
};
}
@Override public String toString() {
return instanceCreators.toString();
}
}
* 说明
* instanceCreators： map集合，以Type为key,标识Java Object是什么类型的；以InstanceCreator为value，用来根据type来创建实例
* get(TypeToken<T> typeToken)： 返回ObjectConstructor对象
1.根据typeToken，获取对应泛型的type以及class
2.首先尝试根据type从map中获取到对应的InstanceCreate，若不为空，则直接创建ObjectConstructor对象，重写其construct方法，在该方法中调用InstanceCreate的createInstance()返回java object对象
3.若根据type没有获取到，则根据class从map中获取对应的InstanceCreate，若不为空，则直接创建ObjectConstructor对象，重写其construct方法，在该方法中调用InstanceCreate的createInstance()返回java object对象
4.若根据class没有获取到，则调用newDefaultConstructor()根据反射来创建java object对象
5.若反射构建对象失败，那么数据可能是list或map，则创建ObjectConstructor对象,重写其construct方法，在该方法中调用new 对应的类型来返回java object对象
6.若还是没有构建成功，则只能通过UnsafeAllocator来构建对象
JsonAdapterAnnotationTypeAdapterFactory
- 1.实现了TypeAdapterFactory接口
- 2.该类主要用于ReflectiveTypeAdapterFactory
源码
public final class JsonAdapterAnnotationTypeAdapterFactory implements TypeAdapterFactory {
//构造器
private final ConstructorConstructor constructorConstructor;
public JsonAdapterAnnotationTypeAdapterFactory(ConstructorConstructor constructorConstructor) {
this.constructorConstructor = constructorConstructor;
}
@SuppressWarnings("unchecked")
@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> targetType) {
//获取泛型的class
Class<? super T> rawType = targetType.getRawType();
//根据class获取JsonAdapter注解
JsonAdapter annotation = rawType.getAnnotation(JsonAdapter.class);
//若为空 则返回null
if (annotation == null) {
return null;
}
//若不为空 则根据注解的值以及类型 返回真正的typeAdapter
return (TypeAdapter<T>) getTypeAdapter(constructorConstructor, gson, targetType, annotation);
}
@SuppressWarnings({ "unchecked", "rawtypes" }) // Casts guarded by conditionals.
TypeAdapter<?> getTypeAdapter(ConstructorConstructor constructorConstructor, Gson gson,
TypeToken<?> type, JsonAdapter annotation) {
//JsonAdapter的value就是class 然后根据class通过typetoken获取到对应的type和class
//再通过构造器获取对应的ObjectConstructor
Object instance = constructorConstructor.get(TypeToken.get(annotation.value())).construct();
//
TypeAdapter<?> typeAdapter;
//若是typeadapter 直接赋值
if (instance instanceof TypeAdapter) {
typeAdapter = (TypeAdapter<?>) instance;
//若是TypeAdapterFactory 则调用create来返回typeAdapter
} else if (instance instanceof TypeAdapterFactory) {
typeAdapter = ((TypeAdapterFactory) instance).create(gson, type);
//若是JsonSerializer/JsonDeserializer 则创建TreeTypeAdapter
} else if (instance instanceof JsonSerializer || instance instanceof JsonDeserializer) {
JsonSerializer<?> serializer = instance instanceof JsonSerializer
? (JsonSerializer) instance
: null;
JsonDeserializer<?> deserializer = instance instanceof JsonDeserializer
? (JsonDeserializer) instance
: null;
typeAdapter = new TreeTypeAdapter(serializer, deserializer, gson, type, null);
//其他的类型则抛异常
} else {
throw new IllegalArgumentException("Invalid attempt to bind an instance of "
+ instance.getClass().getName() + " as a @JsonAdapter for " + type.toString()
+ ". @JsonAdapter value must be a TypeAdapter, TypeAdapterFactory,"
+ " JsonSerializer or JsonDeserializer.");
}
if (typeAdapter != null && annotation.nullSafe()) {
typeAdapter = typeAdapter.nullSafe();
}
return typeAdapter;
}
}
* 说明
1.ConstructorConstructor: 通过构造函数传递过来，主要用于在create()返回对应ObjectConstructor对象
2.重写create方法，判断TypeToken对应泛型是否是使用了JsonAdapter注解，若没有使用JsonAdapter注解，则返回空，表示不使用该factory;若不为空，则返回对应的factory
3.在getTypeAdapter() 通过TypeToken.get(annotation.value())获取注解的typeToken,然后结合constructorConstructor.get().construct()获取注解jsonAdapter注解上的class对象实例;若构建的实例是TypeAdapter类型的，则直接返回；若实例是TypeAdapterFactory类型的，调用create()方法来构建typeadapter对象；若是JsonSerializer或者JsonDeserializer，则构建TreeTypeAdapter；若都不是则直接退出
ReflectiveTypeAdapterFactory
- 1.实现了TypeAdapterFactory接口，重写create方法，创建一个TypeAdapter，实现数据的写入和读取
- 2.该工厂主要是当json解析的数据不是内置的数据类型，而且没有自定义解析工厂时, 将会采用反射机制实现序列化和反序列化
源码
public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {
private static String TAG="ReflectiveTypeAdapterFactory";
//实例构造器ConstructorConstructor
private final ConstructorConstructor constructorConstructor;
//
private final FieldNamingStrategy fieldNamingPolicy;
//排除器 也是一个TypeAdapterFactory
private final Excluder excluder;
//
private final JsonAdapterAnnotationTypeAdapterFactory jsonAdapterFactory;
//反射工具类 用于设置makeAccessible(true)
private final ReflectionAccessor accessor = ReflectionAccessor.getInstance();
public ReflectiveTypeAdapterFactory(ConstructorConstructor constructorConstructor,
FieldNamingStrategy fieldNamingPolicy, Excluder excluder,
JsonAdapterAnnotationTypeAdapterFactory jsonAdapterFactory) {
this.constructorConstructor = constructorConstructor;
this.fieldNamingPolicy = fieldNamingPolicy;
this.excluder = excluder;
this.jsonAdapterFactory = jsonAdapterFactory;
}
public ReflectiveTypeAdapterFactory(ConstructorConstructor constructorConstructor,
FieldNamingStrategy fieldNamingPolicy,
Excluder excluder) {
this(constructorConstructor,fieldNamingPolicy,excluder,null);
}
public boolean excludeField(Field f, boolean serialize) {
return excludeField(f, serialize, excluder);
}
static boolean excludeField(Field f, boolean serialize, Excluder excluder) {
return !excluder.excludeClass(f.getType(), serialize) && !excluder.excludeField(f, serialize);
}
/** first element holds the default name */
private List<String> getFieldNames(Field f) {
SerializedName annotation = f.getAnnotation(SerializedName.class);
if (annotation == null) {
String name = fieldNamingPolicy.translateName(f);
return Collections.singletonList(name);
}
String serializedName = annotation.value();
String[] alternates = annotation.alternate();
if (alternates.length == 0) {
return Collections.singletonList(serializedName);
}
List<String> fieldNames = new ArrayList<String>(alternates.length + 1);
fieldNames.add(serializedName);
for (String alternate : alternates) {
fieldNames.add(alternate);
}
return fieldNames;
}
@Override public <T> TypeAdapter<T> create(Gson gson, final TypeToken<T> type) {
Class<? super T> raw = type.getRawType();
System.out.println("create rawtype:"+raw);
if (!Object.class.isAssignableFrom(raw)) {
System.out.println("create object 是raw的父类");
return null; // it's a primitive!
}
ObjectConstructor<T> constructor = constructorConstructor.get(type);
System.out.println("create 通过构造器获取对应的ObjectConstructor："+constructor);
return new Adapter<T>(constructor, getBoundFields(gson, type, raw));
}
private ReflectiveTypeAdapterFactory.BoundField createBoundField(
final Gson context, final Field field, final String name,
final TypeToken<?> fieldType, boolean serialize, boolean deserialize) {
final boolean isPrimitive = Primitives.isPrimitive(fieldType.getRawType());
// special casing primitives here saves ~5% on Android...
JsonAdapter annotation = field.getAnnotation(JsonAdapter.class);
System.out.println("createBoundField :"+annotation);
TypeAdapter<?> mapped = null;
if (annotation != null) {
mapped = jsonAdapterFactory.getTypeAdapter(
constructorConstructor, context, fieldType, annotation);
}
final boolean jsonAdapterPresent = mapped != null;
if (mapped == null) mapped = context.getAdapter(fieldType);
final TypeAdapter<?> typeAdapter = mapped;
return new ReflectiveTypeAdapterFactory.BoundField(name, serialize, deserialize) {
@SuppressWarnings({"unchecked", "rawtypes"}) // the type adapter and field type always agree
@Override void write(JsonWriter writer, Object value)
throws IOException, IllegalAccessException {
Object fieldValue = field.get(value);
TypeAdapter t = jsonAdapterPresent ? typeAdapter
: new TypeAdapterRuntimeTypeWrapper(context, typeAdapter, fieldType.getType());
t.write(writer, fieldValue);
}
@Override void read(JsonReader reader, Object value)
throws IOException, IllegalAccessException {
Object fieldValue = typeAdapter.read(reader);
if (fieldValue != null || !isPrimitive) {
field.set(value, fieldValue);
}
}
@Override public boolean writeField(Object value) throws IOException, IllegalAccessException {
if (!serialized) return false;
Object fieldValue = field.get(value);
return fieldValue != value; // avoid recursion for example for Throwable.cause
}
};
}
/**
*
* @param context
* @param type
* @param raw
* @return
*/
private Map<String, BoundField> getBoundFields(Gson context, TypeToken<?> type, Class<?> raw) {
//创建map
Map<String, BoundField> result = new LinkedHashMap<String, BoundField>();
System.out.println("getBoundFields 创建map");
//若raw是接口类型 直接返回map
if (raw.isInterface()) {
System.out.println("getBoundFields 若raw是接口类型 直接返回map");
return result;
}
Type declaredType = type.getType();
System.out.println("getBoundFields 获取tokentoken泛型类型");
while (raw != Object.class) {
System.out.println("getBoundFields 不是object类");
Field[] fields = raw.getDeclaredFields();
System.out.println("getBoundFields getDeclaredFields："+fields.length);
for (Field field : fields) {
boolean serialize = excludeField(field, true);
boolean deserialize = excludeField(field, false);
System.out.println("getBoundFields 遍历 判断属性是否可以序列化和反序列化："+field.getName()+"-->"+serialize+"-->"+deserialize);
if (!serialize && !deserialize) {
continue;
}
accessor.makeAccessible(field);
Type fieldType = $Gson$Types.resolve(type.getType(), raw, field.getGenericType());
System.out.println("getBoundFields 遍历 判断属性的类型："+fieldType);
List<String> fieldNames = getFieldNames(field);
System.out.println("getBoundFields 遍历 获取属性名对应的name数组："+field.getName()+"-->"+fieldNames.size());
BoundField previous = null;
for (int i = 0, size = fieldNames.size(); i < size; ++i) {
String name = fieldNames.get(i);
System.out.println("遍历fieldNames："+i+" "+field+"-->"+name);
if (i != 0) serialize = false; // only serialize the default name
BoundField boundField = createBoundField(context, field, name,
TypeToken.get(fieldType), serialize, deserialize);
BoundField replaced = result.put(name, boundField);
System.out.println("遍历fieldNames：将数据封装到BoundField中"+context.toString()+"-->"+replaced);
if (previous == null) previous = replaced;
}
if (previous != null) {
throw new IllegalArgumentException(declaredType
+ " declares multiple JSON fields named " + previous.name);
}
}
type = TypeToken.get($Gson$Types.resolve(type.getType(), raw, raw.getGenericSuperclass()));
raw = type.getRawType();
}
return result;
}
static abstract class BoundField {
final String name;
final boolean serialized;
final boolean deserialized;
protected BoundField(String name, boolean serialized, boolean deserialized) {
this.name = name;
this.serialized = serialized;
this.deserialized = deserialized;
}
abstract boolean writeField(Object value) throws IOException, IllegalAccessException;
abstract void write(JsonWriter writer, Object value) throws IOException, IllegalAccessException;
abstract void read(JsonReader reader, Object value) throws IOException, IllegalAccessException;
}
public static final class Adapter<T> extends TypeAdapter<T> {
private final ObjectConstructor<T> constructor;
private final Map<String, BoundField> boundFields;
Adapter(ObjectConstructor<T> constructor, Map<String, BoundField> boundFields) {
this.constructor = constructor;
this.boundFields = boundFields;
}
@Override public T read(JsonReader in) throws IOException {
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
T instance = constructor.construct();
try {
in.beginObject();
while (in.hasNext()) {
String name = in.nextName();
BoundField field = boundFields.get(name);
if (field == null || !field.deserialized) {
in.skipValue();
} else {
field.read(in, instance);
}
}
} catch (IllegalStateException e) {
throw new JsonSyntaxException(e);
} catch (IllegalAccessException e) {
throw new AssertionError(e);
}
in.endObject();
return instance;
}
@Override public void write(JsonWriter out, T value) throws IOException {
System.out.println("write :"+out+"-->"+value);
if (value == null) {
out.nullValue();
return;
}
System.out.println("write 开始写入");
System.out.println("write :beginObject start------:"+out);
out.beginObject();
System.out.println("write :beginObject end-----:"+out.toString());
try {
for (BoundField boundField : boundFields.values()) {
System.out.println("write :遍历BoundField："+boundField.name);
if (boundField.writeField(value)) {
System.out.println("write :遍历BoundField："+boundField+"-->"+value);
//写入name
out.name(boundField.name);
//然后写入value
boundField.write(out, value);
}
}
} catch (IllegalAccessException e) {
throw new AssertionError(e);
}
out.endObject();
System.out.println("write :endObject：");
}
}
}
说明
-
1.BoundField是抽象类，用于存储属性名以及是否可以序列化和反序列化，并定义的write/read方法让typeAdapter进行读写操作
-
2.通过getFieldNames()可以获取到属性的所有属性名，因为一个属性上可以通过SerializedName注解来设置一个与json的key对应的name
1.首先通过f.getAnnotation(SerializedName.class)获取SerializedName注解
2.若没有获取到SerializedName注解，表示该属性没有使用SerializedName注解，直接将该属性名放入集合进行返回
3.若获取到SerializedName注解，表示该属性使用了SerializedName注解，则获取注解的value值以及alternate数组。若alternate为空 则直接将注解的name放入集合进行返回；若alternate不为空，则将注解name和alternate放入集合进行返回
-
3.通过createBoundField()将属性名包装成BoundField
1.首先通过field.getAnnotation(JsonAdapter.class)判断该属性是否使用了JsonAdapter接口
2.若属性获取到了JsonAdapter注解，表示该属性自定义解析器，则通过jsonAdapterFactory.getTypeAdapter()获取typeAdapter;若属性没有获取到JsonAdapter注解，则通过通过Gson.getAdapter()来获取对应数据类型的typeAdapter
3.创建BoundField的匿名类对象，重写在read和write方法，然后在方法里面调用typeAdapter的read和write方法
-
4.根据type从getBoundFields()获取java bean中所有的属性，然后将其封装成一个个BoundField对象
1.创建一个以属性名为key，以BoundField为value的map集合
2.判断type是不是接口，若是接口 则直接返回空map
3.while不断从当前类循环查找它的父类，然后当前类以及其父类的属性名
4.当我们发现其类不是object类时，通过getDeclaredFields()获取类的所有属性，然后将其分装成boundfield，最后将其添加到map集合中
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
