1342 lines
55 KiB
Java
1342 lines
55 KiB
Java
/*
|
||
* To change this license header, choose License Headers in Project Properties.
|
||
* To change this template file, choose Tools | Templates
|
||
* and open the template in the editor.
|
||
*/
|
||
package org.redkale.convert;
|
||
|
||
import java.io.File;
|
||
import java.lang.reflect.*;
|
||
import java.math.*;
|
||
import java.net.*;
|
||
import java.nio.ByteBuffer;
|
||
import java.nio.channels.CompletionHandler;
|
||
import java.util.*;
|
||
import java.util.concurrent.*;
|
||
import java.util.concurrent.atomic.*;
|
||
import java.util.concurrent.locks.ReentrantLock;
|
||
import java.util.regex.Pattern;
|
||
import java.util.stream.*;
|
||
import org.redkale.annotation.ConstructorParameters;
|
||
import org.redkale.convert.bson.BsonConvert;
|
||
import org.redkale.convert.ext.*;
|
||
import org.redkale.convert.json.JsonConvert;
|
||
import org.redkale.util.*;
|
||
|
||
/**
|
||
* 序列化模块的工厂类，用于注册自定义的序列化类型，获取Convert
|
||
*
|
||
* <p>
|
||
* 详情见: https://redkale.org
|
||
*
|
||
* @author zhangjx
|
||
* @param <R> Reader输入的子类
|
||
* @param <W> Writer输出的子类
|
||
*/
|
||
@SuppressWarnings("unchecked")
|
||
public abstract class ConvertFactory<R extends Reader, W extends Writer> {
|
||
|
||
private static final AtomicBoolean loaderInited = new AtomicBoolean();
|
||
|
||
private static Convert defProtobufConvert;
|
||
|
||
private final ConvertFactory parent;
|
||
|
||
protected Convert<R, W> convert;
|
||
|
||
protected boolean tiny; //String类型值为""，Boolean类型值为false时是否需要输出， 默认为false
|
||
|
||
private final Encodeable<W, ?> anyEncoder = new AnyEncoder(this);
|
||
|
||
//-----------------------------------------------------------------------------------
|
||
private final ConcurrentHashMap<Class, Creator> creators = new ConcurrentHashMap();
|
||
|
||
private final ConcurrentHashMap<String, Class> entitys = new ConcurrentHashMap();
|
||
|
||
private final ConcurrentHashMap<Type, Map<String, SimpledCoder<R, W, ?>>> fieldCoders = new ConcurrentHashMap();
|
||
|
||
private final ConcurrentHashMap<Type, Decodeable<R, ?>> decoders = new ConcurrentHashMap();
|
||
|
||
private final ConcurrentHashMap<Type, Encodeable<W, ?>> encoders = new ConcurrentHashMap();
|
||
|
||
private final ConcurrentHashMap<AccessibleObject, ConvertColumnEntry> columnEntrys = new ConcurrentHashMap();
|
||
|
||
private final Set<Class> skipIgnores = new HashSet();
|
||
|
||
final Set<String> ignoreMapColumns = new HashSet();
|
||
|
||
final ReentrantLock ignoreMapColumnLock = new ReentrantLock();
|
||
|
||
//key:需要屏蔽的字段；value：排除的字段名
|
||
private final ConcurrentHashMap<Class, Set<String>> ignoreAlls = new ConcurrentHashMap();
|
||
|
||
private boolean skipAllIgnore = false;
|
||
|
||
protected ConvertFactory(ConvertFactory<R, W> parent, boolean tiny) {
|
||
this.tiny = tiny;
|
||
this.parent = parent;
|
||
if (parent == null) {
|
||
//---------------------------------------------------------
|
||
|
||
this.register(boolean.class, BoolSimpledCoder.instance);
|
||
this.register(Boolean.class, BoolSimpledCoder.instance);
|
||
|
||
this.register(byte.class, ByteSimpledCoder.instance);
|
||
this.register(Byte.class, ByteSimpledCoder.instance);
|
||
|
||
this.register(short.class, ShortSimpledCoder.instance);
|
||
this.register(Short.class, ShortSimpledCoder.instance);
|
||
|
||
this.register(char.class, CharSimpledCoder.instance);
|
||
this.register(Character.class, CharSimpledCoder.instance);
|
||
|
||
this.register(int.class, IntSimpledCoder.instance);
|
||
this.register(Integer.class, IntSimpledCoder.instance);
|
||
|
||
this.register(long.class, LongSimpledCoder.instance);
|
||
this.register(Long.class, LongSimpledCoder.instance);
|
||
|
||
this.register(float.class, FloatSimpledCoder.instance);
|
||
this.register(Float.class, FloatSimpledCoder.instance);
|
||
|
||
this.register(double.class, DoubleSimpledCoder.instance);
|
||
this.register(Double.class, DoubleSimpledCoder.instance);
|
||
|
||
this.register(Number.class, NumberSimpledCoder.instance);
|
||
this.register(String.class, StringSimpledCoder.instance);
|
||
this.register(StringWrapper.class, StringWrapperSimpledCoder.instance);
|
||
this.register(CharSequence.class, CharSequenceSimpledCoder.instance);
|
||
this.register(StringBuilder.class, CharSequenceSimpledCoder.StringBuilderSimpledCoder.instance);
|
||
this.register(java.util.Date.class, DateSimpledCoder.instance);
|
||
this.register(java.time.Instant.class, InstantSimpledCoder.instance);
|
||
this.register(java.time.LocalDate.class, LocalDateSimpledCoder.instance);
|
||
this.register(java.time.LocalTime.class, LocalTimeSimpledCoder.instance);
|
||
this.register(java.time.LocalDateTime.class, LocalDateTimeSimpledCoder.instance);
|
||
this.register(java.time.Duration.class, DurationSimpledCoder.instance);
|
||
this.register(AtomicInteger.class, AtomicIntegerSimpledCoder.instance);
|
||
this.register(AtomicLong.class, AtomicLongSimpledCoder.instance);
|
||
this.register(BigInteger.class, BigIntegerSimpledCoder.instance);
|
||
this.register(BigDecimal.class, BigDecimalSimpledCoder.instance);
|
||
this.register(InetAddress.class, InetAddressSimpledCoder.instance);
|
||
this.register(LongAdder.class, LongAdderSimpledCoder.instance);
|
||
this.register(Uint128.class, Uint128SimpledCoder.instance);
|
||
this.register(Class.class, TypeSimpledCoder.instance);
|
||
this.register(InetSocketAddress.class, InetAddressSimpledCoder.InetSocketAddressSimpledCoder.instance);
|
||
this.register(Pattern.class, PatternSimpledCoder.instance);
|
||
this.register(File.class, FileSimpledCoder.instance);
|
||
this.register(Throwable.class, ThrowableSimpledCoder.instance);
|
||
this.register(CompletionHandler.class, CompletionHandlerSimpledCoder.instance);
|
||
this.register(URL.class, URLSimpledCoder.instance);
|
||
this.register(URI.class, URISimpledCoder.instance);
|
||
//---------------------------------------------------------
|
||
this.register(ByteBuffer.class, ByteBufferSimpledCoder.instance);
|
||
this.register(boolean[].class, BoolArraySimpledCoder.instance);
|
||
this.register(byte[].class, ByteArraySimpledCoder.instance);
|
||
this.register(short[].class, ShortArraySimpledCoder.instance);
|
||
this.register(char[].class, CharArraySimpledCoder.instance);
|
||
this.register(int[].class, IntArraySimpledCoder.instance);
|
||
this.register(IntStream.class, IntArraySimpledCoder.IntStreamSimpledCoder.instance);
|
||
this.register(long[].class, LongArraySimpledCoder.instance);
|
||
this.register(LongStream.class, LongArraySimpledCoder.LongStreamSimpledCoder.instance);
|
||
this.register(float[].class, FloatArraySimpledCoder.instance);
|
||
this.register(double[].class, DoubleArraySimpledCoder.instance);
|
||
this.register(DoubleStream.class, DoubleArraySimpledCoder.DoubleStreamSimpledCoder.instance);
|
||
this.register(String[].class, StringArraySimpledCoder.instance);
|
||
//---------------------------------------------------------
|
||
this.register(AnyValue.class, Creator.create(AnyValue.DefaultAnyValue.class));
|
||
this.register(HttpCookie.class, new Creator<HttpCookie>() {
|
||
@Override
|
||
@ConstructorParameters({"name", "value"})
|
||
public HttpCookie create(Object... params) {
|
||
return new HttpCookie((String) params[0], (String) params[1]);
|
||
}
|
||
|
||
});
|
||
try {
|
||
Class sqldateClass = Thread.currentThread().getContextClassLoader().loadClass("java.sql.Date");
|
||
Invoker<Object, Object> sqldateInvoker = Invoker.create(sqldateClass, "valueOf", String.class);
|
||
this.register(sqldateClass, new SimpledCoder<R, W, Object>() {
|
||
|
||
@Override
|
||
public void convertTo(W out, Object value) {
|
||
out.writeSmallString(value == null ? null : value.toString());
|
||
}
|
||
|
||
@Override
|
||
public Object convertFrom(R in) {
|
||
String t = in.readSmallString();
|
||
return t == null ? null : sqldateInvoker.invoke(null, t);
|
||
}
|
||
|
||
});
|
||
Class sqltimeClass = Thread.currentThread().getContextClassLoader().loadClass("java.sql.Time");
|
||
Invoker<Object, Object> sqltimeInvoker = Invoker.create(sqltimeClass, "valueOf", String.class);
|
||
this.register(sqltimeClass, new SimpledCoder<R, W, Object>() {
|
||
|
||
@Override
|
||
public void convertTo(W out, Object value) {
|
||
out.writeSmallString(value == null ? null : value.toString());
|
||
}
|
||
|
||
@Override
|
||
public Object convertFrom(R in) {
|
||
String t = in.readSmallString();
|
||
return t == null ? null : sqltimeInvoker.invoke(null, t);
|
||
}
|
||
|
||
});
|
||
Class timestampClass = Thread.currentThread().getContextClassLoader().loadClass("java.sql.Timestamp");
|
||
Invoker<Object, Object> timestampInvoker = Invoker.create(timestampClass, "valueOf", String.class);
|
||
this.register(timestampClass, new SimpledCoder<R, W, Object>() {
|
||
|
||
@Override
|
||
public void convertTo(W out, Object value) {
|
||
out.writeSmallString(value == null ? null : value.toString());
|
||
}
|
||
|
||
@Override
|
||
public Object convertFrom(R in) {
|
||
String t = in.readSmallString();
|
||
return t == null ? null : timestampInvoker.invoke(null, t);
|
||
}
|
||
|
||
});
|
||
} catch (Throwable t) {
|
||
}
|
||
}
|
||
}
|
||
|
||
public ConvertFactory parent() {
|
||
return this.parent;
|
||
}
|
||
|
||
public static Convert findConvert(ConvertType type) {
|
||
if (type == null) {
|
||
return null;
|
||
}
|
||
if (type == ConvertType.JSON) {
|
||
return JsonConvert.root();
|
||
}
|
||
if (type == ConvertType.BSON) {
|
||
return BsonConvert.root();
|
||
}
|
||
if (loaderInited.get()) {
|
||
if (type == ConvertType.PROTOBUF) {
|
||
return defProtobufConvert;
|
||
}
|
||
}
|
||
if (loaderInited.compareAndSet(false, true)) {
|
||
Iterator<ConvertProvider> it = ServiceLoader.load(ConvertProvider.class).iterator();
|
||
RedkaleClassLoader.putServiceLoader(ConvertProvider.class);
|
||
while (it.hasNext()) {
|
||
ConvertProvider cl = it.next();
|
||
RedkaleClassLoader.putReflectionPublicConstructors(cl.getClass(), cl.getClass().getName());
|
||
if (cl.type() == ConvertType.PROTOBUF) {
|
||
defProtobufConvert = cl.convert();
|
||
}
|
||
}
|
||
}
|
||
return type == ConvertType.PROTOBUF ? defProtobufConvert : null;
|
||
}
|
||
|
||
protected static boolean getSystemPropertyBoolean(String key, String parentkey, boolean defvalue) {
|
||
return Boolean.parseBoolean(System.getProperty(key, System.getProperty(parentkey, String.valueOf(defvalue))));
|
||
}
|
||
|
||
public abstract ConvertType getConvertType();
|
||
|
||
public abstract boolean isReversible(); //是否可逆的
|
||
|
||
public abstract boolean isFieldSort(); //当ConvertColumn.index相同时是否按字段名称排序
|
||
|
||
public abstract ConvertFactory createChild();
|
||
|
||
public abstract ConvertFactory createChild(boolean tiny);
|
||
|
||
protected SimpledCoder createEnumSimpledCoder(Class enumClass) {
|
||
return new EnumSimpledCoder(this, enumClass);
|
||
}
|
||
|
||
protected Type formatObjectType(Type type) {
|
||
if (type instanceof Class) {
|
||
Class<?> clazz = (Class) type;
|
||
ConvertImpl ci = clazz.getAnnotation(ConvertImpl.class);
|
||
if (ci != null && ci.value() != Object.class) {
|
||
if (!clazz.isAssignableFrom(ci.value())) {
|
||
throw new ConvertException("@" + ConvertImpl.class.getSimpleName() + ".value(" + ci.value() + ") must be " + clazz + "'s subclass");
|
||
}
|
||
if (!Modifier.isAbstract(clazz.getModifiers()) && !Modifier.isInterface(clazz.getModifiers())) {
|
||
throw new ConvertException("@" + ConvertImpl.class.getSimpleName() + " must at interface or abstract class, but " + clazz + " not");
|
||
}
|
||
Class impl = ci.value();
|
||
if (Modifier.isAbstract(impl.getModifiers()) || Modifier.isInterface(impl.getModifiers())) {
|
||
throw new ConvertException("@" + ConvertImpl.class.getSimpleName() + " at class " + impl + " cannot be interface or abstract class");
|
||
}
|
||
return impl;
|
||
}
|
||
}
|
||
return type;
|
||
}
|
||
|
||
protected <E> Encodeable<W, E> createDyncEncoder(Type type) {
|
||
return null;
|
||
}
|
||
|
||
protected ObjectDecoder createObjectDecoder(Type type) {
|
||
return new ObjectDecoder(type);
|
||
}
|
||
|
||
protected <E> Decodeable<R, E> createMultiImplDecoder(Class[] types) {
|
||
return null;
|
||
}
|
||
|
||
protected <E> ObjectEncoder<W, E> createObjectEncoder(Type type) {
|
||
return new ObjectEncoder(type);
|
||
}
|
||
|
||
protected <E> Decodeable<R, E> createMapDecoder(Type type) {
|
||
return new MapDecoder(this, type);
|
||
}
|
||
|
||
protected <E> Encodeable<W, E> createMapEncoder(Type type) {
|
||
return new MapEncoder(this, type);
|
||
}
|
||
|
||
protected <E> Decodeable<R, E> createArrayDecoder(Type type) {
|
||
return new ArrayDecoder(this, type);
|
||
}
|
||
|
||
protected <E> Encodeable<W, E> createArrayEncoder(Type type) {
|
||
return new ArrayEncoder(this, type);
|
||
}
|
||
|
||
protected <E> Decodeable<R, E> createCollectionDecoder(Type type) {
|
||
return new CollectionDecoder(this, type);
|
||
}
|
||
|
||
protected <E> Encodeable<W, E> createCollectionEncoder(Type type) {
|
||
return new CollectionEncoder(this, type);
|
||
}
|
||
|
||
protected <E> Decodeable<R, E> createStreamDecoder(Type type) {
|
||
return new StreamDecoder(this, type);
|
||
}
|
||
|
||
protected <E> Encodeable<W, E> createStreamEncoder(Type type) {
|
||
return new StreamEncoder(this, type);
|
||
}
|
||
|
||
public Convert getConvert() {
|
||
return convert;
|
||
}
|
||
|
||
public ConvertFactory tiny(boolean tiny) {
|
||
this.tiny = tiny;
|
||
return this;
|
||
}
|
||
|
||
public boolean isConvertDisabled(AccessibleObject element) {
|
||
ConvertDisabled[] ccs = element.getAnnotationsByType(ConvertDisabled.class);
|
||
if (ccs.length == 0 && element instanceof Method) {
|
||
final Method method = (Method) element;
|
||
String fieldName = readGetSetFieldName(method);
|
||
if (fieldName != null) {
|
||
try {
|
||
ccs = method.getDeclaringClass().getDeclaredField(fieldName).getAnnotationsByType(ConvertDisabled.class);
|
||
} catch (Exception e) { //说明没有该字段，忽略异常
|
||
}
|
||
}
|
||
}
|
||
final ConvertType ct = this.getConvertType();
|
||
for (ConvertDisabled ref : ccs) {
|
||
if (ref.type().contains(ct)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
public ConvertColumnEntry findRef(Class clazz, AccessibleObject element) {
|
||
if (element == null) {
|
||
return null;
|
||
}
|
||
ConvertColumnEntry en = this.columnEntrys.get(element);
|
||
Set<String> onlyColumns = ignoreAlls.get(clazz);
|
||
if (en != null && onlyColumns == null) {
|
||
return en;
|
||
}
|
||
final ConvertType ct = this.getConvertType();
|
||
ConvertColumn[] ccs = element.getAnnotationsByType(ConvertColumn.class);
|
||
String fieldName = null;
|
||
if (ccs.length == 0 && element instanceof Method) {
|
||
final Method method = (Method) element;
|
||
fieldName = readGetSetFieldName(method);
|
||
if (fieldName != null) {
|
||
Class mclz = method.getDeclaringClass();
|
||
do {
|
||
try {
|
||
ccs = mclz.getDeclaredField(fieldName).getAnnotationsByType(ConvertColumn.class);
|
||
break;
|
||
} catch (Exception e) { //说明没有该字段，忽略异常
|
||
}
|
||
} while (mclz != Object.class && (mclz = mclz.getSuperclass()) != Object.class);
|
||
}
|
||
}
|
||
if (onlyColumns != null && fieldName == null) {
|
||
if (element instanceof Method) {
|
||
fieldName = readGetSetFieldName((Method) element);
|
||
} else if (element instanceof Field) {
|
||
fieldName = ((Field) element).getName();
|
||
}
|
||
}
|
||
if (ccs.length == 0 && onlyColumns != null && fieldName != null) {
|
||
if (!onlyColumns.contains(fieldName)) {
|
||
return new ConvertColumnEntry(fieldName, true);
|
||
}
|
||
}
|
||
for (ConvertColumn ref : ccs) {
|
||
if (ref.type().contains(ct)) {
|
||
String realName = ref.name().isEmpty() ? fieldName : ref.name();
|
||
if (onlyColumns != null && fieldName != null) {
|
||
if (!onlyColumns.contains(realName)) {
|
||
return new ConvertColumnEntry(realName, true);
|
||
}
|
||
}
|
||
ConvertColumnEntry entry = new ConvertColumnEntry(ref);
|
||
if (skipAllIgnore) {
|
||
entry.setIgnore(false);
|
||
return entry;
|
||
}
|
||
if (skipIgnores.isEmpty()) {
|
||
if (onlyColumns != null && realName != null && onlyColumns.contains(realName)) {
|
||
entry.setIgnore(false);
|
||
}
|
||
return entry;
|
||
}
|
||
if (skipIgnores.contains(((Member) element).getDeclaringClass())) {
|
||
entry.setIgnore(false);
|
||
}
|
||
return entry;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
static Field readGetSetField(Method method) {
|
||
String name = readGetSetFieldName(method);
|
||
if (name == null) {
|
||
return null;
|
||
}
|
||
try {
|
||
return method.getDeclaringClass().getDeclaredField(name);
|
||
} catch (Exception e) {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
static String readGetSetFieldName(Method method) {
|
||
if (method == null) {
|
||
return null;
|
||
}
|
||
String fname = method.getName();
|
||
if (!(fname.startsWith("is") && fname.length() > 2)
|
||
&& !(fname.startsWith("get") && fname.length() > 3)
|
||
&& !(fname.startsWith("set") && fname.length() > 3)) {
|
||
return fname; //record类会直接用field名作为method名
|
||
}
|
||
fname = fname.substring(fname.startsWith("is") ? 2 : 3);
|
||
if (fname.length() > 1 && !(fname.charAt(1) >= 'A' && fname.charAt(1) <= 'Z')) {
|
||
fname = Character.toLowerCase(fname.charAt(0)) + fname.substring(1);
|
||
} else if (fname.length() == 1) {
|
||
fname = "" + Character.toLowerCase(fname.charAt(0));
|
||
}
|
||
return fname;
|
||
}
|
||
|
||
final String getEntityAlias(Class clazz) {
|
||
if (clazz == String.class) {
|
||
return "A";
|
||
}
|
||
if (clazz == int.class) {
|
||
return "I";
|
||
}
|
||
if (clazz == Integer.class) {
|
||
return "i";
|
||
}
|
||
if (clazz == long.class) {
|
||
return "J";
|
||
}
|
||
if (clazz == Long.class) {
|
||
return "j";
|
||
}
|
||
if (clazz == byte.class) {
|
||
return "B";
|
||
}
|
||
if (clazz == Byte.class) {
|
||
return "b";
|
||
}
|
||
if (clazz == boolean.class) {
|
||
return "Z";
|
||
}
|
||
if (clazz == Boolean.class) {
|
||
return "z";
|
||
}
|
||
if (clazz == short.class) {
|
||
return "S";
|
||
}
|
||
if (clazz == Short.class) {
|
||
return "s";
|
||
}
|
||
if (clazz == char.class) {
|
||
return "C";
|
||
}
|
||
if (clazz == Character.class) {
|
||
return "c";
|
||
}
|
||
if (clazz == float.class) {
|
||
return "F";
|
||
}
|
||
if (clazz == Float.class) {
|
||
return "f";
|
||
}
|
||
if (clazz == double.class) {
|
||
return "D";
|
||
}
|
||
if (clazz == Double.class) {
|
||
return "d";
|
||
}
|
||
|
||
if (clazz == String[].class) {
|
||
return "[A";
|
||
}
|
||
if (clazz == int[].class) {
|
||
return "[I";
|
||
}
|
||
if (clazz == long[].class) {
|
||
return "[J";
|
||
}
|
||
if (clazz == byte[].class) {
|
||
return "[B";
|
||
}
|
||
if (clazz == boolean[].class) {
|
||
return "[Z";
|
||
}
|
||
if (clazz == short[].class) {
|
||
return "[S";
|
||
}
|
||
if (clazz == char[].class) {
|
||
return "[C";
|
||
}
|
||
if (clazz == float[].class) {
|
||
return "[F";
|
||
}
|
||
if (clazz == double[].class) {
|
||
return "[D";
|
||
}
|
||
|
||
ConvertEntity ce = (ConvertEntity) clazz.getAnnotation(ConvertEntity.class);
|
||
if (ce != null && findEntityAlias(ce.value()) == null) {
|
||
entitys.put(ce.value(), clazz);
|
||
}
|
||
return ce == null ? clazz.getName() : ce.value();
|
||
}
|
||
|
||
final Class getEntityAlias(String name) {
|
||
if ("A".equals(name)) {
|
||
return String.class;
|
||
}
|
||
if ("I".equals(name)) {
|
||
return int.class;
|
||
}
|
||
if ("i".equals(name)) {
|
||
return Integer.class;
|
||
}
|
||
if ("J".equals(name)) {
|
||
return long.class;
|
||
}
|
||
if ("j".equals(name)) {
|
||
return Long.class;
|
||
}
|
||
if ("B".equals(name)) {
|
||
return byte.class;
|
||
}
|
||
if ("b".equals(name)) {
|
||
return Byte.class;
|
||
}
|
||
if ("Z".equals(name)) {
|
||
return boolean.class;
|
||
}
|
||
if ("z".equals(name)) {
|
||
return Boolean.class;
|
||
}
|
||
if ("S".equals(name)) {
|
||
return short.class;
|
||
}
|
||
if ("s".equals(name)) {
|
||
return Short.class;
|
||
}
|
||
if ("C".equals(name)) {
|
||
return char.class;
|
||
}
|
||
if ("c".equals(name)) {
|
||
return Character.class;
|
||
}
|
||
if ("F".equals(name)) {
|
||
return float.class;
|
||
}
|
||
if ("f".equals(name)) {
|
||
return Float.class;
|
||
}
|
||
if ("D".equals(name)) {
|
||
return double.class;
|
||
}
|
||
if ("d".equals(name)) {
|
||
return Double.class;
|
||
}
|
||
|
||
if ("[A".equals(name)) {
|
||
return String[].class;
|
||
}
|
||
if ("[I".equals(name)) {
|
||
return int[].class;
|
||
}
|
||
if ("[J".equals(name)) {
|
||
return long[].class;
|
||
}
|
||
if ("[B".equals(name)) {
|
||
return byte[].class;
|
||
}
|
||
if ("[Z".equals(name)) {
|
||
return boolean[].class;
|
||
}
|
||
if ("[S".equals(name)) {
|
||
return short[].class;
|
||
}
|
||
if ("[C".equals(name)) {
|
||
return char[].class;
|
||
}
|
||
if ("[F".equals(name)) {
|
||
return float[].class;
|
||
}
|
||
if ("[D".equals(name)) {
|
||
return double[].class;
|
||
}
|
||
|
||
Class clazz = findEntityAlias(name);
|
||
try {
|
||
return clazz == null ? Thread.currentThread().getContextClassLoader().loadClass(name) : clazz;
|
||
} catch (Exception ex) {
|
||
throw new ConvertException("convert entity is " + name, ex);
|
||
}
|
||
}
|
||
|
||
ConvertFactory columnFactory(Class type, ConvertCoder[] coders, boolean encode) {
|
||
if (coders == null || coders.length < 1) {
|
||
return this;
|
||
}
|
||
final ConvertType ct = this.getConvertType();
|
||
List<Encodeable> encoderList = null;
|
||
List<Decodeable> decoderList = null;
|
||
Class readerOrWriterClass = (Class) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[encode ? 1 : 0];
|
||
for (ConvertCoder ann : coders) {
|
||
if (!ann.type().contains(ct)) {
|
||
continue;
|
||
}
|
||
Class colType = type;
|
||
if (ann.column() != Object.class) {
|
||
colType = ann.column();
|
||
}
|
||
if (encode) {
|
||
Class<? extends Encodeable> enClazz = ann.encoder();
|
||
if (enClazz != Encodeable.class) {
|
||
try {
|
||
boolean skip = false;
|
||
RedkaleClassLoader.putReflectionPublicMethods(enClazz.getName());
|
||
for (Method method : enClazz.getMethods()) {
|
||
if (method.isBridge()) {
|
||
continue;
|
||
}
|
||
if ("convertTo".equals(method.getName()) && method.getParameterCount() == 2 && Writer.class.isAssignableFrom(method.getParameterTypes()[0])) {
|
||
skip = !method.getParameterTypes()[0].isAssignableFrom(readerOrWriterClass);
|
||
break;
|
||
}
|
||
}
|
||
if (skip) {
|
||
continue;
|
||
}
|
||
Encodeable encoder = null;
|
||
try {
|
||
Field instanceField = enClazz.getField("instance");
|
||
if (instanceField.getType() == enClazz && Modifier.isStatic(instanceField.getModifiers())) {
|
||
RedkaleClassLoader.putReflectionField("instance", instanceField);
|
||
encoder = (Encodeable) instanceField.get(null);
|
||
}
|
||
} catch (Exception e) {
|
||
}
|
||
if (encoder == null) {
|
||
Creator<? extends Encodeable> creator = Creator.create(enClazz);
|
||
Class[] paramTypes = creator.paramTypes();
|
||
if (paramTypes.length == 0) {
|
||
encoder = creator.create();
|
||
} else if (paramTypes.length == 1) {
|
||
if (Type.class.isAssignableFrom(paramTypes[0])) {
|
||
encoder = creator.create((Object) colType);
|
||
} else if (ConvertFactory.class.isAssignableFrom(paramTypes[0])) {
|
||
encoder = creator.create(this);
|
||
} else {
|
||
throw new ConvertException(enClazz + " not found public empty-parameter Constructor");
|
||
}
|
||
} else if (paramTypes.length == 2) {
|
||
if (ConvertFactory.class.isAssignableFrom(paramTypes[0]) && Type.class.isAssignableFrom(paramTypes[1])) {
|
||
encoder = creator.create(this, colType);
|
||
} else if (Type.class.isAssignableFrom(paramTypes[0]) && ConvertFactory.class.isAssignableFrom(paramTypes[1])) {
|
||
encoder = creator.create(colType, this);
|
||
} else {
|
||
throw new ConvertException(enClazz + " not found public empty-parameter Constructor");
|
||
}
|
||
} else {
|
||
throw new ConvertException(enClazz + " not found public empty-parameter Constructor");
|
||
}
|
||
RedkaleClassLoader.putReflectionPublicConstructors(enClazz, enClazz.getName());
|
||
}
|
||
if (encoderList == null) {
|
||
encoderList = new ArrayList<>();
|
||
}
|
||
encoderList.add(encoder);
|
||
} catch (Throwable t) {
|
||
throw new ConvertException(t);
|
||
}
|
||
}
|
||
} else {
|
||
Class<? extends Decodeable> deClazz = ann.decoder();
|
||
if (deClazz != Decodeable.class) {
|
||
try {
|
||
boolean skip = false;
|
||
RedkaleClassLoader.putReflectionPublicMethods(deClazz.getName());
|
||
for (Method method : deClazz.getMethods()) {
|
||
if (method.isBridge()) {
|
||
continue;
|
||
}
|
||
if ("convertFrom".equals(method.getName()) && method.getParameterCount() == 1 && Reader.class.isAssignableFrom(method.getParameterTypes()[0])) {
|
||
skip = !method.getParameterTypes()[0].isAssignableFrom(readerOrWriterClass);
|
||
break;
|
||
}
|
||
}
|
||
if (skip) {
|
||
continue;
|
||
}
|
||
Decodeable decoder = null;
|
||
try {
|
||
Field instanceField = deClazz.getField("instance");
|
||
if (instanceField.getType() == deClazz && Modifier.isStatic(instanceField.getModifiers())) {
|
||
RedkaleClassLoader.putReflectionField("instance", instanceField);
|
||
decoder = (Decodeable) instanceField.get(null);
|
||
}
|
||
} catch (Exception e) {
|
||
}
|
||
if (decoder == null) {
|
||
Creator<? extends Decodeable> creator = Creator.create(deClazz);
|
||
Class[] paramTypes = creator.paramTypes();
|
||
if (paramTypes.length == 0) {
|
||
decoder = creator.create();
|
||
} else if (paramTypes.length == 1) {
|
||
if (Type.class.isAssignableFrom(paramTypes[0])) {
|
||
decoder = creator.create((Object) colType);
|
||
} else if (ConvertFactory.class.isAssignableFrom(paramTypes[0])) {
|
||
decoder = creator.create(this);
|
||
} else {
|
||
throw new ConvertException(deClazz + " not found public empty-parameter Constructor");
|
||
}
|
||
} else if (paramTypes.length == 2) {
|
||
if (ConvertFactory.class.isAssignableFrom(paramTypes[0]) && Type.class.isAssignableFrom(paramTypes[1])) {
|
||
decoder = creator.create(this, colType);
|
||
} else if (Type.class.isAssignableFrom(paramTypes[0]) && ConvertFactory.class.isAssignableFrom(paramTypes[1])) {
|
||
decoder = creator.create(colType, this);
|
||
} else {
|
||
throw new ConvertException(deClazz + " not found public empty-parameter Constructor");
|
||
}
|
||
} else {
|
||
throw new ConvertException(deClazz + " not found public empty-parameter Constructor");
|
||
}
|
||
RedkaleClassLoader.putReflectionPublicConstructors(deClazz, deClazz.getName());
|
||
}
|
||
if (decoderList == null) {
|
||
decoderList = new ArrayList<>();
|
||
}
|
||
decoderList.add(decoder);
|
||
} catch (Throwable t) {
|
||
throw new ConvertException(t);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (encoderList == null && decoderList == null) {
|
||
return this;
|
||
}
|
||
ConvertFactory child = createChild();
|
||
if (encode) {
|
||
for (Encodeable item : encoderList) {
|
||
child.register(item.getType(), item);
|
||
if (item instanceof ObjectEncoder) {
|
||
((ObjectEncoder) item).init(child);
|
||
}
|
||
}
|
||
} else {
|
||
for (Decodeable item : decoderList) {
|
||
child.register(item.getType(), item);
|
||
if (item instanceof ObjectDecoder) {
|
||
((ObjectDecoder) item).init(child);
|
||
}
|
||
}
|
||
}
|
||
return child;
|
||
}
|
||
|
||
private Class findEntityAlias(String name) {
|
||
Class clazz = entitys.get(name);
|
||
return parent == null ? clazz : parent.findEntityAlias(name);
|
||
}
|
||
|
||
/**
|
||
* 使所有类的所有被声明为ConvertColumn.ignore = true 的字段或方法变为ConvertColumn.ignore = false
|
||
*
|
||
* @param skipIgnore 是否忽略Ignore注解
|
||
*/
|
||
public final void registerSkipAllIgnore(final boolean skipIgnore) {
|
||
this.skipAllIgnore = skipIgnore;
|
||
}
|
||
|
||
/**
|
||
* 使所有类的所有被声明为ConvertColumn.ignore = true 的字段或方法变为ConvertColumn.ignore = false
|
||
*
|
||
* @param skipIgnore 忽略ignore
|
||
*
|
||
* @return 自身
|
||
*/
|
||
public ConvertFactory<R, W> skipAllIgnore(final boolean skipIgnore) {
|
||
this.skipAllIgnore = skipIgnore;
|
||
return this;
|
||
}
|
||
|
||
/**
|
||
* 使该类所有被声明为ConvertColumn.ignore = true 的字段或方法变为ConvertColumn.ignore = false
|
||
*
|
||
* @param type 指定的类
|
||
*/
|
||
public final void registerSkipIgnore(final Class type) {
|
||
skipIgnores.add(type);
|
||
}
|
||
|
||
/**
|
||
* 屏蔽指定类所有字段，仅仅保留指定字段 <br>
|
||
* <b>注意: 该配置优先级高于skipAllIgnore和ConvertColumnEntry配置</b>
|
||
*
|
||
* @param type 指定的类
|
||
* @param excludeColumns 需要排除的字段名
|
||
*/
|
||
public final void registerIgnoreAll(final Class type, String... excludeColumns) {
|
||
ignoreAlls.computeIfAbsent(type, t -> new CopyOnWriteArraySet<>()).addAll(Arrays.asList(excludeColumns));
|
||
}
|
||
|
||
public final void registerIgnoreAll(final Class type, Collection<String> excludeColumns) {
|
||
ignoreAlls.computeIfAbsent(type, t -> new CopyOnWriteArraySet<>()).addAll(excludeColumns);
|
||
}
|
||
|
||
public final void register(final Class type, boolean ignore, String... columns) {
|
||
if (type == Map.class) {
|
||
ignoreMapColumnLock.lock();
|
||
try {
|
||
if (ignore) {
|
||
for (String column : columns) {
|
||
ignoreMapColumns.add(column);
|
||
}
|
||
} else {
|
||
for (String column : columns) {
|
||
ignoreMapColumns.remove(column);
|
||
}
|
||
}
|
||
} finally {
|
||
ignoreMapColumnLock.unlock();
|
||
}
|
||
return;
|
||
}
|
||
for (String column : columns) {
|
||
register(type, column, new ConvertColumnEntry(column, ignore));
|
||
}
|
||
}
|
||
|
||
public final void register(final Class type, boolean ignore, Collection<String> columns) {
|
||
if (type == Map.class) {
|
||
ignoreMapColumnLock.lock();
|
||
try {
|
||
if (ignore) {
|
||
for (String column : columns) {
|
||
ignoreMapColumns.add(column);
|
||
}
|
||
} else {
|
||
for (String column : columns) {
|
||
ignoreMapColumns.remove(column);
|
||
}
|
||
}
|
||
} finally {
|
||
ignoreMapColumnLock.unlock();
|
||
}
|
||
return;
|
||
}
|
||
for (String column : columns) {
|
||
register(type, column, new ConvertColumnEntry(column, ignore));
|
||
}
|
||
}
|
||
|
||
public final boolean register(final Class type, String column, String alias) {
|
||
return register(type, column, new ConvertColumnEntry(alias));
|
||
}
|
||
|
||
public final boolean register(final Class type, String column, ConvertColumnEntry entry) {
|
||
if (type == null || column == null || entry == null) {
|
||
return false;
|
||
}
|
||
Field field = null;
|
||
try {
|
||
field = type.getDeclaredField(column);
|
||
} catch (Exception e) {
|
||
}
|
||
String get = "get";
|
||
if (field != null && (field.getType() == boolean.class || field.getType() == Boolean.class)) {
|
||
get = "is";
|
||
}
|
||
char[] cols = column.toCharArray();
|
||
cols[0] = Character.toUpperCase(cols[0]);
|
||
final String bigColumn = new String(cols);
|
||
try {
|
||
register(type.getMethod(get + bigColumn), entry);
|
||
} catch (NoSuchMethodException mex) {
|
||
if (get.length() >= 3) { //get
|
||
try {
|
||
register(type.getMethod("is" + bigColumn), entry);
|
||
} catch (Exception ex) {
|
||
}
|
||
}
|
||
} catch (Exception ex) {
|
||
}
|
||
try {
|
||
register(type.getMethod("set" + bigColumn, field.getType()), entry);
|
||
} catch (Exception ex) {
|
||
}
|
||
return field == null ? true : register(field, entry);
|
||
}
|
||
|
||
public final <E> boolean register(final AccessibleObject field, final ConvertColumnEntry entry) {
|
||
if (field == null || entry == null) {
|
||
return false;
|
||
}
|
||
this.columnEntrys.put(field, entry);
|
||
return true;
|
||
}
|
||
|
||
public final void reloadCoder(final Type type) {
|
||
this.register(type, this.createDecoder(type));
|
||
this.register(type, this.createEncoder(type));
|
||
}
|
||
|
||
public final void reloadCoder(final Type type, final Class clazz) {
|
||
this.register(type, this.createDecoder(type, clazz, false));
|
||
this.register(type, this.createEncoder(type, clazz, false));
|
||
}
|
||
|
||
public final <E> void register(final Class<E> clazz, final Creator<? extends E> creator) {
|
||
creators.put(clazz, creator);
|
||
}
|
||
|
||
public final <T> Creator<T> findCreator(Class<T> type) {
|
||
Creator<T> creator = creators.get(type);
|
||
if (creator != null) {
|
||
return creator;
|
||
}
|
||
return this.parent == null ? null : this.parent.findCreator(type);
|
||
}
|
||
|
||
public final <T> Creator<T> loadCreator(Class<T> type) {
|
||
Creator result = findCreator(type);
|
||
if (result == null) {
|
||
result = Creator.create(type);
|
||
if (result != null) {
|
||
creators.put(type, result);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
//----------------------------------------------------------------------
|
||
public final <E> Encodeable<W, E> getAnyEncoder() {
|
||
return (Encodeable<W, E>) anyEncoder;
|
||
}
|
||
|
||
public final <E> void register(final Type clazz, final SimpledCoder<R, W, E> coder) {
|
||
decoders.put(clazz, coder);
|
||
encoders.put(clazz, coder);
|
||
}
|
||
|
||
public final <E> void register(final Type clazz, final Decodeable<R, E> decoder, final Encodeable<W, E> encoder) {
|
||
decoders.put(clazz, decoder);
|
||
encoders.put(clazz, encoder);
|
||
}
|
||
|
||
public final <E> void register(final Type clazz, final Decodeable<R, E> decoder) {
|
||
decoders.put(clazz, decoder);
|
||
}
|
||
|
||
public final <E> void register(final Type clazz, final Encodeable<W, E> encoder) {
|
||
encoders.put(clazz, encoder);
|
||
}
|
||
|
||
//coder = null表示删除该字段的指定SimpledCoder
|
||
public final <E> void register(final Class clazz, final String field, final SimpledCoder<R, W, E> coder) {
|
||
if (field == null || clazz == null) {
|
||
return;
|
||
}
|
||
try {
|
||
clazz.getDeclaredField(field);
|
||
} catch (Exception e) {
|
||
throw new ConvertException(clazz + " not found field(" + field + ")");
|
||
}
|
||
if (coder == null) {
|
||
Map map = this.fieldCoders.get(clazz);
|
||
if (map != null) {
|
||
map.remove(field);
|
||
}
|
||
} else {
|
||
this.fieldCoders.computeIfAbsent(clazz, c -> new ConcurrentHashMap<>()).put(field, coder);
|
||
}
|
||
}
|
||
|
||
public final <E> SimpledCoder<R, W, E> findFieldCoder(final Type clazz, final String field) {
|
||
if (field == null) {
|
||
return null;
|
||
}
|
||
Map<String, SimpledCoder<R, W, ?>> map = this.fieldCoders.get(clazz);
|
||
if (map == null) {
|
||
return parent == null ? null : parent.findFieldCoder(clazz, field);
|
||
}
|
||
return (SimpledCoder) map.get(field);
|
||
}
|
||
|
||
public final <E> Decodeable<R, E> findDecoder(final Type type) {
|
||
Decodeable<R, E> rs = (Decodeable<R, E>) decoders.get(type);
|
||
if (rs != null) {
|
||
return rs;
|
||
}
|
||
return this.parent == null ? null : this.parent.findDecoder(type);
|
||
}
|
||
|
||
public final <E> Encodeable<W, E> findEncoder(final Type type) {
|
||
Encodeable<W, E> rs = (Encodeable<W, E>) encoders.get(type);
|
||
if (rs != null) {
|
||
return rs;
|
||
}
|
||
return this.parent == null ? null : this.parent.findEncoder(type);
|
||
}
|
||
|
||
public final <E> Decodeable<R, E> loadDecoder(final Type type) {
|
||
Decodeable<R, E> decoder = findDecoder(type);
|
||
if (decoder != null) {
|
||
return decoder;
|
||
}
|
||
if (type instanceof GenericArrayType) {
|
||
return createArrayDecoder(type);
|
||
}
|
||
Class clazz;
|
||
if (type instanceof ParameterizedType) {
|
||
final ParameterizedType pts = (ParameterizedType) type;
|
||
clazz = (Class) (pts).getRawType();
|
||
} else if (type instanceof TypeVariable) { // e.g. <? extends E>
|
||
final TypeVariable tv = (TypeVariable) type;
|
||
Class cz = tv.getBounds().length == 0 ? Object.class : null;
|
||
for (Type f : tv.getBounds()) {
|
||
if (f instanceof Class) {
|
||
cz = (Class) f;
|
||
break;
|
||
}
|
||
}
|
||
clazz = cz;
|
||
if (cz == null) {
|
||
throw new ConvertException("not support the type (" + type + ")");
|
||
}
|
||
} else if (type instanceof WildcardType) { // e.g. <? extends Serializable>
|
||
final WildcardType wt = (WildcardType) type;
|
||
Class cz = null;
|
||
for (Type f : wt.getUpperBounds()) {
|
||
if (f instanceof Class) {
|
||
cz = (Class) f;
|
||
break;
|
||
}
|
||
}
|
||
clazz = cz;
|
||
if (cz == null) {
|
||
throw new ConvertException("not support the type (" + type + ")");
|
||
}
|
||
} else if (type instanceof Class) {
|
||
clazz = (Class) type;
|
||
} else {
|
||
throw new ConvertException("not support the type (" + type + ")");
|
||
}
|
||
//此处不能再findDecoder，否则type与class不一致, 如: RetResult 和 RetResult<Integer>
|
||
return createDecoder(type, clazz, false);
|
||
}
|
||
|
||
public final <E> Decodeable<R, E> createDecoder(final Type type) {
|
||
return createDecoder(type, false);
|
||
}
|
||
|
||
public final <E> Decodeable<R, E> createDecoder(final Type type, boolean skipCustomMethod) {
|
||
Class clazz;
|
||
if (type instanceof ParameterizedType) {
|
||
final ParameterizedType pts = (ParameterizedType) type;
|
||
clazz = (Class) (pts).getRawType();
|
||
} else if (type instanceof Class) {
|
||
clazz = (Class) type;
|
||
} else {
|
||
throw new ConvertException("not support the type (" + type + ")");
|
||
}
|
||
return createDecoder(type, clazz, skipCustomMethod);
|
||
}
|
||
|
||
private <E> Decodeable<R, E> createDecoder(final Type type, final Class clazz, boolean skipCustomMethod) {
|
||
Decodeable<R, E> decoder = null;
|
||
ObjectDecoder od = null;
|
||
if (clazz.isEnum()) {
|
||
decoder = createEnumSimpledCoder(clazz);
|
||
} else if (clazz.isArray()) {
|
||
decoder = createArrayDecoder(type);
|
||
} else if (Collection.class.isAssignableFrom(clazz)) {
|
||
decoder = createCollectionDecoder(type);
|
||
} else if (Stream.class.isAssignableFrom(clazz)) {
|
||
decoder = createStreamDecoder(type);
|
||
} else if (Map.class.isAssignableFrom(clazz)) {
|
||
decoder = createMapDecoder(type);
|
||
} else if (CompletionHandler.class.isAssignableFrom(clazz)) {
|
||
decoder = CompletionHandlerSimpledCoder.instance;
|
||
} else if (Optional.class == clazz) {
|
||
decoder = new OptionalCoder(this, type);
|
||
} else if (clazz == Object.class) {
|
||
od = createObjectDecoder(type);
|
||
decoder = od;
|
||
} else if (!clazz.getName().startsWith("java.")
|
||
|| java.net.HttpCookie.class == clazz
|
||
|| java.util.AbstractMap.SimpleEntry.class == clazz
|
||
|| clazz.getName().startsWith("java.awt.geom.Point2D")) {
|
||
Decodeable simpleCoder = null;
|
||
if (!skipCustomMethod) {
|
||
for (Class subclazz : getSuperClasses(clazz)) {
|
||
for (final Method method : subclazz.getDeclaredMethods()) {
|
||
if (!Modifier.isStatic(method.getModifiers())) {
|
||
continue;
|
||
}
|
||
Class[] paramTypes = method.getParameterTypes();
|
||
if (paramTypes.length != 1 && paramTypes.length != 2) {
|
||
continue;
|
||
}
|
||
if (paramTypes[0] != ConvertFactory.class && paramTypes[0] != this.getClass()) {
|
||
continue;
|
||
}
|
||
if (paramTypes.length == 2 && paramTypes[1] != Class.class && paramTypes[1] != Type.class) {
|
||
continue;
|
||
}
|
||
if (!Decodeable.class.isAssignableFrom(method.getReturnType())) {
|
||
continue;
|
||
}
|
||
if (Modifier.isPrivate(method.getModifiers()) && subclazz != clazz) {
|
||
continue; //声明private的只能被自身类使用
|
||
}
|
||
try {
|
||
method.setAccessible(true);
|
||
simpleCoder = (Decodeable) (paramTypes.length == 2 ? (paramTypes[1] == Type.class ? method.invoke(null, this, type) : method.invoke(null, this, clazz)) : method.invoke(null, this));
|
||
RedkaleClassLoader.putReflectionDeclaredMethods(subclazz.getName());
|
||
RedkaleClassLoader.putReflectionMethod(subclazz.getName(), method);
|
||
break;
|
||
} catch (Exception e) {
|
||
e.printStackTrace();
|
||
}
|
||
}
|
||
if (simpleCoder != null) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (simpleCoder == null) {
|
||
if (type instanceof Class) {
|
||
Class<?> typeclz = (Class) type;
|
||
ConvertImpl ci = typeclz.getAnnotation(ConvertImpl.class);
|
||
if (ci != null && ci.types().length > 0) {
|
||
for (Class sub : ci.types()) {
|
||
if (!typeclz.isAssignableFrom(sub)) {
|
||
throw new ConvertException("@" + ConvertImpl.class.getSimpleName() + ".types(" + sub + ") must be " + typeclz + "'s subclass");
|
||
}
|
||
}
|
||
decoder = createMultiImplDecoder(ci.types());
|
||
}
|
||
}
|
||
if (decoder == null) {
|
||
Type impl = formatObjectType(type);
|
||
od = createObjectDecoder(impl);
|
||
decoder = od;
|
||
}
|
||
} else {
|
||
decoder = simpleCoder;
|
||
}
|
||
}
|
||
if (decoder == null) {
|
||
throw new ConvertException("not support the type (" + type + ")");
|
||
}
|
||
register(type, decoder);
|
||
if (od != null) {
|
||
od.init(this);
|
||
}
|
||
return decoder;
|
||
}
|
||
|
||
public final <E> Encodeable<W, E> loadEncoder(final Type type) {
|
||
Encodeable<W, E> encoder = findEncoder(type);
|
||
if (encoder != null) {
|
||
return encoder;
|
||
}
|
||
if (type instanceof GenericArrayType) {
|
||
return createArrayEncoder(type);
|
||
}
|
||
Class clazz;
|
||
if (type instanceof ParameterizedType) {
|
||
final ParameterizedType pts = (ParameterizedType) type;
|
||
clazz = (Class) (pts).getRawType();
|
||
} else if (type instanceof TypeVariable) {
|
||
TypeVariable tv = (TypeVariable) type;
|
||
Type t = Object.class;
|
||
if (tv.getBounds().length == 1) {
|
||
t = tv.getBounds()[0];
|
||
}
|
||
if (!(t instanceof Class)) {
|
||
t = Object.class;
|
||
}
|
||
clazz = (Class) t;
|
||
} else if (type instanceof Class) {
|
||
clazz = (Class) type;
|
||
} else {
|
||
throw new ConvertException("not support the type (" + type + ")");
|
||
}
|
||
//此处不能再findEncoder，否则type与class不一致, 如: RetResult 和 RetResult<Integer>
|
||
return createEncoder(type, clazz, false);
|
||
}
|
||
|
||
public final <E> Encodeable<W, E> createEncoder(final Type type) {
|
||
return createEncoder(type, false);
|
||
}
|
||
|
||
public final <E> Encodeable<W, E> createEncoder(final Type type, boolean skipCustomMethod) {
|
||
Class clazz;
|
||
if (type instanceof ParameterizedType) {
|
||
final ParameterizedType pts = (ParameterizedType) type;
|
||
clazz = (Class) (pts).getRawType();
|
||
} else if (type instanceof Class) {
|
||
clazz = (Class) type;
|
||
} else {
|
||
throw new ConvertException("not support the type (" + type + ")");
|
||
}
|
||
return createEncoder(type, clazz, skipCustomMethod);
|
||
}
|
||
|
||
private <E> Encodeable<W, E> createEncoder(final Type type, final Class clazz, boolean skipCustomMethod) {
|
||
Encodeable<W, E> encoder = null;
|
||
ObjectEncoder oe = null;
|
||
if (clazz.isEnum()) {
|
||
encoder = createEnumSimpledCoder(clazz);
|
||
} else if (clazz.isArray()) {
|
||
encoder = createArrayEncoder(type);
|
||
} else if (Collection.class.isAssignableFrom(clazz)) {
|
||
encoder = createCollectionEncoder(type);
|
||
} else if (Stream.class.isAssignableFrom(clazz)) {
|
||
encoder = createStreamEncoder(type);
|
||
} else if (Map.class.isAssignableFrom(clazz)) {
|
||
encoder = createMapEncoder(type);
|
||
} else if (Optional.class == clazz) {
|
||
encoder = new OptionalCoder(this, type);
|
||
} else if (clazz == Object.class) {
|
||
return (Encodeable<W, E>) this.anyEncoder;
|
||
} else if (!clazz.getName().startsWith("java.") || java.net.HttpCookie.class == clazz
|
||
|| java.util.Map.Entry.class == clazz || java.util.AbstractMap.SimpleEntry.class == clazz) {
|
||
Encodeable simpleCoder = null;
|
||
if (!skipCustomMethod) {
|
||
for (Class subclazz : getSuperClasses(clazz)) {
|
||
for (final Method method : subclazz.getDeclaredMethods()) {
|
||
if (!Modifier.isStatic(method.getModifiers())) {
|
||
continue;
|
||
}
|
||
Class[] paramTypes = method.getParameterTypes();
|
||
if (paramTypes.length != 1 && paramTypes.length != 2) {
|
||
continue;
|
||
}
|
||
if (paramTypes[0] != ConvertFactory.class && paramTypes[0] != this.getClass()) {
|
||
continue;
|
||
}
|
||
if (paramTypes.length == 2 && paramTypes[1] != Class.class && paramTypes[1] != Type.class) {
|
||
continue;
|
||
}
|
||
if (!Encodeable.class.isAssignableFrom(method.getReturnType())) {
|
||
continue;
|
||
}
|
||
if (Modifier.isPrivate(method.getModifiers()) && subclazz != clazz) {
|
||
continue; //声明private的只能被自身类使用
|
||
}
|
||
try {
|
||
method.setAccessible(true);
|
||
simpleCoder = (Encodeable) (paramTypes.length == 2 ? (paramTypes[1] == Type.class ? method.invoke(null, this, type) : method.invoke(null, this, clazz)) : method.invoke(null, this));
|
||
RedkaleClassLoader.putReflectionDeclaredMethods(subclazz.getName());
|
||
RedkaleClassLoader.putReflectionMethod(subclazz.getName(), method);
|
||
break;
|
||
} catch (Exception e) {
|
||
e.printStackTrace();
|
||
}
|
||
}
|
||
if (simpleCoder != null) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (simpleCoder == null) {
|
||
Type impl = formatObjectType(type);
|
||
encoder = createDyncEncoder(impl);
|
||
if (encoder == null) {
|
||
oe = createObjectEncoder(impl);
|
||
encoder = oe;
|
||
}
|
||
} else {
|
||
encoder = simpleCoder;
|
||
}
|
||
}
|
||
if (encoder == null) {
|
||
throw new ConvertException("not support the type (" + type + ")");
|
||
}
|
||
register(type, encoder);
|
||
if (oe != null) {
|
||
oe.init(this);
|
||
}
|
||
return encoder;
|
||
|
||
}
|
||
|
||
private Set<Class> getSuperClasses(final Class clazz) {
|
||
Set<Class> set = new LinkedHashSet<>();
|
||
set.add(clazz);
|
||
Class recursClass = clazz;
|
||
while ((recursClass = recursClass.getSuperclass()) != null) {
|
||
if (recursClass == Object.class) {
|
||
break;
|
||
}
|
||
set.addAll(getSuperClasses(recursClass));
|
||
}
|
||
for (Class sub : clazz.getInterfaces()) {
|
||
set.addAll(getSuperClasses(sub));
|
||
}
|
||
return set;
|
||
}
|
||
|
||
}
|