diff --git a/.github/workflows/pull_request_5x.yml b/.github/workflows/pull_request_5x.yml index c2233f249..f9f710fb7 100644 --- a/.github/workflows/pull_request_5x.yml +++ b/.github/workflows/pull_request_5x.yml @@ -8,6 +8,16 @@ jobs: build: runs-on: ubuntu-latest + services: + redis: + image: redis:7-alpine + ports: + - 6379:6379 + options: >- + --health-cmd "redis-cli ping" + --health-interval 10s + --health-timeout 5s + --health-retries 5 steps: - uses: actions/checkout@v1 diff --git a/hsweb-core/pom.xml b/hsweb-core/pom.xml index 40dc7deef..f79713382 100644 --- a/hsweb-core/pom.xml +++ b/hsweb-core/pom.xml @@ -14,6 +14,29 @@ ${project.artifactId} 核心包 + + + + org.apache.maven.plugins + maven-compiler-plugin + + + + org.projectlombok + lombok + 1.18.42 + + + org.openjdk.jmh + jmh-generator-annprocess + 1.37 + + + + + + + @@ -168,11 +191,23 @@ hsweb-easy-orm-core + + org.ow2.asm + asm + 9.8 + + io.micrometer context-propagation true + + org.openjdk.jmh + jmh-core + 1.37 + test + - \ No newline at end of file + diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/AccessorFastBeanCopierBackend.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/AccessorFastBeanCopierBackend.java new file mode 100644 index 000000000..284ded523 --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/AccessorFastBeanCopierBackend.java @@ -0,0 +1,828 @@ +package org.hswebframework.web.bean; + +import lombok.extern.slf4j.Slf4j; +import org.hswebframework.ezorm.core.Extendable; +import org.hswebframework.web.bean.accessor.ConverterPropertyTransfer; +import org.hswebframework.web.bean.accessor.PropertyAccessor; +import org.hswebframework.web.bean.accessor.PropertyReader; +import org.hswebframework.web.bean.accessor.PropertyTransfer; +import org.hswebframework.web.bean.accessor.PropertyWriter; +import org.hswebframework.web.dict.EnumDict; +import org.springframework.core.ResolvableType; +import org.springframework.util.ReflectionUtils; + +import java.lang.reflect.Array; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +@Slf4j +abstract class AccessorFastBeanCopierBackend implements FastBeanCopierBackend { + + private static final Map, Class> PRIMITIVE_WRAPPERS = new HashMap<>(); + /** + * GenericKey 为瞬时组合 key，不能使用弱键缓存，否则 key 本身很容易被回收并导致热路径重复解析泛型。 + * 这里改用强缓存，通过 clearCache(ClassLoader) 显式回收动态 classloader 关联条目。 + */ + private static final Map[]> GENERIC_CACHE = new ConcurrentHashMap<>(); + + static { + PRIMITIVE_WRAPPERS.put(byte.class, Byte.class); + PRIMITIVE_WRAPPERS.put(short.class, Short.class); + PRIMITIVE_WRAPPERS.put(int.class, Integer.class); + PRIMITIVE_WRAPPERS.put(float.class, Float.class); + PRIMITIVE_WRAPPERS.put(double.class, Double.class); + PRIMITIVE_WRAPPERS.put(char.class, Character.class); + PRIMITIVE_WRAPPERS.put(boolean.class, Boolean.class); + PRIMITIVE_WRAPPERS.put(long.class, Long.class); + } + + private final PropertyAccessor propertyAccessor; + + protected AccessorFastBeanCopierBackend(PropertyAccessor propertyAccessor) { + this.propertyAccessor = Objects.requireNonNull(propertyAccessor, "propertyAccessor"); + } + + static void clearCache() { + GENERIC_CACHE.clear(); + } + + static void clearCache(ClassLoader loader) { + if (loader == null) { + clearCache(); + return; + } + GENERIC_CACHE.keySet().removeIf(key -> key.involves(loader)); + } + + @Override + public Copier createCopier(Class source, Class target) { + try { + Copier copier = new AccessorCopier(source, target, propertyAccessor); + boolean targetIsExtendable = Extendable.class.isAssignableFrom(target); + boolean sourceIsExtendable = Extendable.class.isAssignableFrom(source); + boolean targetIsMap = Map.class.isAssignableFrom(target); + boolean sourceIsMap = Map.class.isAssignableFrom(source); + if (sourceIsExtendable && targetIsMap) { + copier = new ExtendableToMapCopier(copier); + } else if (sourceIsMap && targetIsExtendable) { + copier = new MapToExtendableCopier(copier); + } else if (sourceIsExtendable) { + copier = new ExtendableToBeanCopier(copier); + } + return copier; + } catch (Throwable e) { + log.error("create bean copy {} => {} failed", source, target, e); + throw new UnsupportedOperationException(e.getMessage(), e); + } + } + + static final class AccessorCopier implements Copier { + private final NamedPropertyTransfer[] transfers; + private final ExtensionTransfer[] extensionTransfers; + private final Map sourceMapTransfers; + private final boolean sourceIsMap; + private final PropertyTransfer[] fastAccessorTransfers; + private final boolean fastAccessorMode; + + AccessorCopier(Class source, Class target, PropertyAccessor propertyAccessor) { + Map sourceProperties = null; + Map targetProperties = null; + + boolean targetIsExtendable = Extendable.class.isAssignableFrom(target); + boolean sourceIsExtendable = Extendable.class.isAssignableFrom(source); + boolean targetIsMap = Map.class.isAssignableFrom(target); + boolean sourceIsMap = Map.class.isAssignableFrom(source); + if (sourceIsMap) { + if (!targetIsMap) { + targetProperties = FastBeanCopierPropertySupport.createProperty(target); + sourceProperties = FastBeanCopierPropertySupport.createMapProperty(targetProperties); + } + } else if (targetIsMap) { + sourceProperties = FastBeanCopierPropertySupport.createProperty(source); + targetProperties = FastBeanCopierPropertySupport.createMapProperty(sourceProperties); + } else { + targetProperties = FastBeanCopierPropertySupport.createProperty(target); + sourceProperties = FastBeanCopierPropertySupport.createProperty(source); + } + if (sourceProperties == null || targetProperties == null) { + throw new UnsupportedOperationException("不支持的类型,source:" + source + " target:" + target); + } + + List mappings = new ArrayList<>(sourceProperties.size()); + List extensionMappings = new ArrayList<>(); + List fastTransfers = new ArrayList<>(sourceProperties.size()); + boolean accessorOnly = !sourceIsMap && !targetIsMap && !targetIsExtendable; + for (FastBeanCopierPropertySupport.ClassProperty sourceProperty : sourceProperties.values()) { + FastBeanCopierPropertySupport.ClassProperty targetProperty = targetProperties.get(sourceProperty.getName()); + if (targetProperty == null) { + if (targetIsExtendable && !sourceIsExtendable && !sourceIsMap) { + extensionMappings.add(new ExtensionTransfer(sourceProperty, propertyAccessor)); + } + continue; + } + NamedPropertyTransfer transfer = NamedPropertyTransfer.of(target, sourceProperty, targetProperty, propertyAccessor); + mappings.add(transfer); + if (accessorOnly && transfer instanceof AccessorPropertyTransfer) { + fastTransfers.add(((AccessorPropertyTransfer) transfer).transfer); + } else { + accessorOnly = false; + } + } + this.transfers = mappings.toArray(new NamedPropertyTransfer[0]); + this.extensionTransfers = extensionMappings.toArray(new ExtensionTransfer[0]); + this.sourceIsMap = sourceIsMap; + this.fastAccessorMode = accessorOnly && !fastTransfers.isEmpty() && fastTransfers.size() == mappings.size(); + this.fastAccessorTransfers = fastAccessorMode + ? fastTransfers.toArray(new PropertyTransfer[0]) + : null; + if (sourceIsMap) { + Map transferIndex = new HashMap<>(mappings.size()); + for (NamedPropertyTransfer transfer : mappings) { + transferIndex.put(transfer.name, transfer); + } + this.sourceMapTransfers = transferIndex; + } else { + this.sourceMapTransfers = Collections.emptyMap(); + } + } + + @Override + public void copy(Object source, Object target, Set ignore, Converter converter) { + try { + if (sourceIsMap) { + if (ignore.isEmpty()) { + copyMapWithoutIgnore((Map) source, target, converter); + } else { + copyMapWithIgnore((Map) source, target, ignore, converter); + } + } else if (ignore.isEmpty()) { + copyWithoutIgnore(source, target, converter); + } else { + copyWithIgnore(source, target, ignore, converter); + } + } catch (RuntimeException e) { + throw e; + } catch (Throwable e) { + throw new UnsupportedOperationException(e.getMessage(), e); + } + } + + private void copyWithoutIgnore(Object source, Object target, Converter converter) throws Throwable { + if (fastAccessorMode) { + for (PropertyTransfer transfer : fastAccessorTransfers) { + transfer.transfer(source, target); + } + return; + } + for (NamedPropertyTransfer transfer : transfers) { + transfer.transfer(source, target, converter); + } + if (extensionTransfers.length != 0) { + Extendable extendable = (Extendable) target; + for (ExtensionTransfer transfer : extensionTransfers) { + transfer.transfer(source, extendable); + } + } + } + + private void copyWithIgnore(Object source, Object target, Set ignore, Converter converter) throws Throwable { + for (NamedPropertyTransfer transfer : transfers) { + transfer.transfer(source, target, ignore, converter); + } + if (extensionTransfers.length != 0) { + Extendable extendable = (Extendable) target; + for (ExtensionTransfer transfer : extensionTransfers) { + transfer.transfer(source, extendable, ignore); + } + } + } + + private void copyMapWithoutIgnore(Map source, Object target, Converter converter) throws Throwable { + for (Map.Entry entry : source.entrySet()) { + NamedPropertyTransfer transfer = sourceMapTransfers.get(String.valueOf(entry.getKey())); + if (transfer != null) { + transfer.transferValue(entry.getValue(), target, converter); + } + } + } + + private void copyMapWithIgnore(Map source, Object target, Set ignore, Converter converter) throws Throwable { + for (Map.Entry entry : source.entrySet()) { + String name = String.valueOf(entry.getKey()); + if (ignore.contains(name)) { + continue; + } + NamedPropertyTransfer transfer = sourceMapTransfers.get(name); + if (transfer != null) { + transfer.transferValue(entry.getValue(), target, converter); + } + } + } + } + + abstract static class NamedPropertyTransfer { + private final String name; + + NamedPropertyTransfer(String name) { + this.name = name; + } + + final void transfer(Object source, Object target, Set ignore, Converter converter) throws Throwable { + if (!ignore.contains(name)) { + transfer(source, target, converter); + } + } + + abstract void transfer(Object source, Object target, Converter converter) throws Throwable; + + void transferValue(Object value, Object target, Converter converter) throws Throwable { + throw new UnsupportedOperationException("transferValue is only supported for map source transfers"); + } + + static NamedPropertyTransfer of(Class target, + FastBeanCopierPropertySupport.ClassProperty sourceProperty, + FastBeanCopierPropertySupport.ClassProperty targetProperty, + PropertyAccessor propertyAccessor) { + Class sourceType = sourceProperty.getType(); + Class targetType = targetProperty.getType(); + boolean sourcePrimitive = sourceProperty.isPrimitive(); + boolean targetPrimitive = targetProperty.isPrimitive(); + Class[] genericTypes = resolveGenericTypes(target, targetProperty); + + if (Map.class.isAssignableFrom(sourceProperty.getBeanType())) { + ValueWriter writer = createWriter(targetProperty, propertyAccessor); + if (targetType == Object.class) { + return new MapDirectPropertyTransfer(sourceProperty.getName(), writer, targetPrimitive); + } + if (requiresGenericConversion(targetType, genericTypes)) { + return new MapConvertingPropertyTransfer(sourceProperty.getName(), + writer, + targetPrimitive, + targetType, + genericTypes, + isNumberType(targetType), + true); + } + return new MapConvertingPropertyTransfer(sourceProperty.getName(), + writer, + targetPrimitive, + targetType, + genericTypes, + isNumberType(targetType), + true); + } + + PropertyTransfer accessorTransfer = createAccessorTransfer(sourceProperty, + targetProperty, + propertyAccessor, + sourceType, + targetType, + sourcePrimitive, + genericTypes); + if (accessorTransfer != null) { + return new AccessorPropertyTransfer(sourceProperty.getName(), accessorTransfer); + } + + boolean allowDirectAssignment = sourceType != targetType; + ConverterPropertyTransfer accessorConverterTransfer = createAccessorConverterTransfer(sourceProperty, + targetProperty, + propertyAccessor, + sourceType, + targetType, + sourcePrimitive, + genericTypes, + allowDirectAssignment); + if (accessorConverterTransfer != null) { + return new AccessorConverterTransfer(sourceProperty.getName(), accessorConverterTransfer); + } + + ValueReader reader = createReader(sourceProperty, propertyAccessor); + ValueWriter writer = createWriter(targetProperty, propertyAccessor); + if (sourceType == targetType) { + if (Cloneable.class.isAssignableFrom(targetType)) { + return new CloneablePropertyTransfer(sourceProperty.getName(), + reader, + writer, + sourcePrimitive, + targetType, + genericTypes); + } + if (requiresGenericConversion(targetType, genericTypes)) { + return new ConvertingPropertyTransfer(sourceProperty.getName(), + reader, + writer, + sourcePrimitive, + targetPrimitive, + targetType, + genericTypes, + false, + false); + } + return new DirectPropertyTransfer(sourceProperty.getName(), reader, writer, sourcePrimitive); + } + + if (targetType == Object.class || isStaticallyDirectAssignable(sourceType, targetType)) { + return new DirectPropertyTransfer(sourceProperty.getName(), reader, writer, sourcePrimitive); + } + + return new ConvertingPropertyTransfer(sourceProperty.getName(), + reader, + writer, + sourcePrimitive, + targetPrimitive, + targetType, + genericTypes, + isNumberType(targetType), + true); + } + + static ValueReader createReader(FastBeanCopierPropertySupport.ClassProperty property, + PropertyAccessor propertyAccessor) { + if (Map.class.isAssignableFrom(property.getBeanType())) { + return source -> ((Map) source).get(property.getName()); + } + PropertyReader reader = propertyAccessor.createReader(property.getBeanType(), property.getName()); + return reader::apply; + } + + @SuppressWarnings("unchecked") + static ValueWriter createWriter(FastBeanCopierPropertySupport.ClassProperty property, + PropertyAccessor propertyAccessor) { + if (Map.class.isAssignableFrom(property.getBeanType())) { + return (target, value) -> ((Map) target).put(property.getName(), value); + } + PropertyWriter writer = propertyAccessor.createWriter(property.getBeanType(), property.getName(), null); + return writer::accept; + } + + private static Class[] resolveGenericTypes(Class target, + FastBeanCopierPropertySupport.ClassProperty property) { + if (Map.class.isAssignableFrom(property.getBeanType())) { + return FastBeanCopierSupport.EMPTY_CLASS_ARRAY; + } + return GENERIC_CACHE.computeIfAbsent(new GenericKey(target, property.getBeanType(), property.getName()), key -> { + Field field = ReflectionUtils.findField(key.targetType, key.propertyName); + if (field == null) { + field = ReflectionUtils.findField(key.beanType, key.propertyName); + } + if (field == null) { + return FastBeanCopierSupport.EMPTY_CLASS_ARRAY; + } + Class[] arr = Arrays.stream(ResolvableType.forField(field).getGenerics()) + .map(ResolvableType::getRawClass) + .filter(Objects::nonNull) + .toArray(Class[]::new); + return arr.length == 0 ? FastBeanCopierSupport.EMPTY_CLASS_ARRAY : arr; + }); + } + + private static PropertyTransfer createAccessorTransfer(FastBeanCopierPropertySupport.ClassProperty sourceProperty, + FastBeanCopierPropertySupport.ClassProperty targetProperty, + PropertyAccessor propertyAccessor, + Class sourceType, + Class targetType, + boolean sourcePrimitive, + Class[] genericTypes) { + if (Map.class.isAssignableFrom(sourceProperty.getBeanType()) || Map.class.isAssignableFrom(targetProperty.getBeanType())) { + return null; + } + if (sourceType == targetType) { + if (Cloneable.class.isAssignableFrom(targetType) || requiresGenericConversion(targetType, genericTypes)) { + return null; + } + } else if (targetType != Object.class && !isStaticallyDirectAssignable(sourceType, targetType)) { + return null; + } + return propertyAccessor.createTransfer(sourceProperty.getBeanType(), + sourceProperty.getName(), + sourcePrimitive, + targetProperty.getBeanType(), + targetProperty.getName()); + } + + private static ConverterPropertyTransfer createAccessorConverterTransfer(FastBeanCopierPropertySupport.ClassProperty sourceProperty, + FastBeanCopierPropertySupport.ClassProperty targetProperty, + PropertyAccessor propertyAccessor, + Class sourceType, + Class targetType, + boolean sourcePrimitive, + Class[] genericTypes, + boolean allowDirectAssignment) { + if (Map.class.isAssignableFrom(sourceProperty.getBeanType()) || Map.class.isAssignableFrom(targetProperty.getBeanType())) { + return null; + } + if (sourceType == targetType) { + if (!requiresGenericConversion(targetType, genericTypes) || Cloneable.class.isAssignableFrom(targetType)) { + return null; + } + } else if (targetType == Object.class || isStaticallyDirectAssignable(sourceType, targetType)) { + return null; + } + return propertyAccessor.createConverterTransfer(sourceProperty.getBeanType(), + sourceProperty.getName(), + sourcePrimitive, + targetProperty.getBeanType(), + targetProperty.getName(), + allowDirectAssignment); + } + } + + static final class AccessorPropertyTransfer extends NamedPropertyTransfer { + private final PropertyTransfer transfer; + + AccessorPropertyTransfer(String name, PropertyTransfer transfer) { + super(name); + this.transfer = transfer; + } + + @Override + void transfer(Object source, Object target, Converter converter) { + transfer.transfer(source, target); + } + } + + static final class AccessorConverterTransfer extends NamedPropertyTransfer { + private final ConverterPropertyTransfer transfer; + + AccessorConverterTransfer(String name, ConverterPropertyTransfer transfer) { + super(name); + this.transfer = transfer; + } + + @Override + void transfer(Object source, Object target, Converter converter) { + transfer.transfer(source, target, converter); + } + } + + abstract static class ReaderWriterPropertyTransfer extends NamedPropertyTransfer { + protected final ValueReader reader; + protected final ValueWriter writer; + protected final boolean sourcePrimitive; + + ReaderWriterPropertyTransfer(String name, + ValueReader reader, + ValueWriter writer, + boolean sourcePrimitive) { + super(name); + this.reader = reader; + this.writer = writer; + this.sourcePrimitive = sourcePrimitive; + } + + protected final Object readValue(Object source) throws Throwable { + Object value = reader.read(source); + if (value == null && !sourcePrimitive) { + return null; + } + return value; + } + } + + static final class DirectPropertyTransfer extends ReaderWriterPropertyTransfer { + + DirectPropertyTransfer(String name, + ValueReader reader, + ValueWriter writer, + boolean sourcePrimitive) { + super(name, reader, writer, sourcePrimitive); + } + + @Override + void transfer(Object source, Object target, Converter converter) throws Throwable { + Object value = readValue(source); + if (value == null && !sourcePrimitive) { + return; + } + writer.write(target, value); + } + } + + static final class MapDirectPropertyTransfer extends NamedPropertyTransfer { + private final ValueWriter writer; + private final boolean targetPrimitive; + + MapDirectPropertyTransfer(String name, ValueWriter writer, boolean targetPrimitive) { + super(name); + this.writer = writer; + this.targetPrimitive = targetPrimitive; + } + + @Override + void transfer(Object source, Object target, Converter converter) { + throw new UnsupportedOperationException(); + } + + @Override + void transferValue(Object value, Object target, Converter converter) throws Throwable { + if (value == null && !targetPrimitive) { + return; + } + writer.write(target, value); + } + } + + static final class MapConvertingPropertyTransfer extends NamedPropertyTransfer { + private final ValueWriter writer; + private final boolean targetPrimitive; + private final Class targetType; + private final Class[] genericTypes; + private final boolean unwrapEnumDictNumber; + private final boolean allowDirectAssignable; + private final boolean beanLikeTarget; + + MapConvertingPropertyTransfer(String name, + ValueWriter writer, + boolean targetPrimitive, + Class targetType, + Class[] genericTypes, + boolean unwrapEnumDictNumber, + boolean allowDirectAssignable) { + super(name); + this.writer = writer; + this.targetPrimitive = targetPrimitive; + this.targetType = targetType; + this.genericTypes = genericTypes; + this.unwrapEnumDictNumber = unwrapEnumDictNumber; + this.allowDirectAssignable = allowDirectAssignable; + this.beanLikeTarget = isBeanLikeTarget(targetType); + } + + @Override + void transfer(Object source, Object target, Converter converter) { + throw new UnsupportedOperationException(); + } + + @Override + @SuppressWarnings("unchecked") + void transferValue(Object value, Object target, Converter converter) throws Throwable { + if (value == null && !targetPrimitive) { + return; + } + if (unwrapEnumDictNumber && value instanceof EnumDict) { + Object enumValue = ((EnumDict) value).getValue(); + if (enumValue != null) { + value = enumValue; + } + } + if (allowDirectAssignable && isDirectAssignable(targetType, value)) { + writer.write(target, value); + return; + } + if (beanLikeTarget && value instanceof Map) { + Object nested = FastBeanCopierSupport.copy(value, + FastBeanCopierSupport.getBeanFactory().newInstance(targetType), + converter, + Collections.emptySet()); + writer.write(target, nested); + return; + } + Object converted = converter.convert(value, (Class) targetType, genericTypes); + if (converted == null && !targetPrimitive) { + return; + } + writer.write(target, converted); + } + } + + static final class CloneablePropertyTransfer extends ReaderWriterPropertyTransfer { + private final Class targetType; + private final Class[] genericTypes; + + CloneablePropertyTransfer(String name, + ValueReader reader, + ValueWriter writer, + boolean sourcePrimitive, + Class targetType, + Class[] genericTypes) { + super(name, reader, writer, sourcePrimitive); + this.targetType = targetType; + this.genericTypes = genericTypes; + } + + @Override + @SuppressWarnings("unchecked") + void transfer(Object source, Object target, Converter converter) throws Throwable { + Object value = readValue(source); + if (value == null && !sourcePrimitive) { + return; + } + Object cloned = tryClone(value); + if (cloned != null) { + writer.write(target, cloned); + return; + } + if (requiresGenericConversion(targetType, genericTypes)) { + Object converted = converter.convert(value, (Class) targetType, genericTypes); + if (converted != null) { + writer.write(target, converted); + } + return; + } + writer.write(target, value); + } + } + + static final class ConvertingPropertyTransfer extends ReaderWriterPropertyTransfer { + private final boolean targetPrimitive; + private final Class targetType; + private final Class[] genericTypes; + private final boolean unwrapEnumDictNumber; + private final boolean allowDirectAssignable; + private final boolean beanLikeTarget; + + ConvertingPropertyTransfer(String name, + ValueReader reader, + ValueWriter writer, + boolean sourcePrimitive, + boolean targetPrimitive, + Class targetType, + Class[] genericTypes, + boolean unwrapEnumDictNumber, + boolean allowDirectAssignable) { + super(name, reader, writer, sourcePrimitive); + this.targetPrimitive = targetPrimitive; + this.targetType = targetType; + this.genericTypes = genericTypes; + this.unwrapEnumDictNumber = unwrapEnumDictNumber; + this.allowDirectAssignable = allowDirectAssignable; + this.beanLikeTarget = isBeanLikeTarget(targetType); + } + + @Override + @SuppressWarnings("unchecked") + void transfer(Object source, Object target, Converter converter) throws Throwable { + Object value = readValue(source); + if (value == null && !sourcePrimitive) { + return; + } + if (unwrapEnumDictNumber && value instanceof EnumDict) { + Object enumValue = ((EnumDict) value).getValue(); + if (enumValue != null) { + value = enumValue; + } + } + if (allowDirectAssignable && isDirectAssignable(targetType, value)) { + writer.write(target, value); + return; + } + if (beanLikeTarget && value instanceof Map) { + Object nested = FastBeanCopierSupport.copy(value, + FastBeanCopierSupport.getBeanFactory().newInstance(targetType), + converter, + Collections.emptySet()); + writer.write(target, nested); + return; + } + Object converted = converter.convert(value, (Class) targetType, genericTypes); + if (converted == null && !targetPrimitive) { + return; + } + writer.write(target, converted); + } + } + + static final class ExtensionTransfer { + private final String name; + private final boolean primitive; + private final ValueReader reader; + + ExtensionTransfer(FastBeanCopierPropertySupport.ClassProperty property, + PropertyAccessor propertyAccessor) { + this.name = property.getName(); + this.primitive = property.isPrimitive(); + this.reader = NamedPropertyTransfer.createReader(property, propertyAccessor); + } + + void transfer(Object source, Extendable target) throws Throwable { + Object value = reader.read(source); + if (value == null && !primitive) { + return; + } + target.setExtension(name, value); + } + + void transfer(Object source, Extendable target, Set ignore) throws Throwable { + if (!ignore.contains(name)) { + transfer(source, target); + } + } + } + + private static boolean requiresGenericConversion(Class targetType, Class[] genericTypes) { + return genericTypes.length > 0 + && (Map.class.isAssignableFrom(targetType) || Collection.class.isAssignableFrom(targetType)); + } + + private static boolean isStaticallyDirectAssignable(Class sourceType, Class targetType) { + return toWrapperType(targetType).isAssignableFrom(toWrapperType(sourceType)); + } + + private static Class toWrapperType(Class type) { + return type.isPrimitive() ? PRIMITIVE_WRAPPERS.getOrDefault(type, type) : type; + } + + private static boolean isDirectAssignable(Class targetType, Object value) { + if (value == null) { + return false; + } + if (targetType.isInstance(value)) { + return true; + } + if (targetType.isPrimitive()) { + Class wrapper = PRIMITIVE_WRAPPERS.get(targetType); + return wrapper != null && wrapper.isInstance(value); + } + return false; + } + + private static boolean isNumberType(Class targetType) { + if (Number.class.isAssignableFrom(targetType)) { + return true; + } + return targetType.isPrimitive() + && targetType != boolean.class + && targetType != char.class; + } + + private static boolean isBeanLikeTarget(Class targetType) { + return targetType != Object.class + && targetType != String.class + && targetType != CharSequence.class + && targetType != Date.class + && targetType != Boolean.class + && targetType != Character.class + && targetType != boolean.class + && targetType != char.class + && !targetType.isEnum() + && !targetType.isArray() + && !Collection.class.isAssignableFrom(targetType) + && !Map.class.isAssignableFrom(targetType) + && !isNumberType(targetType); + } + + private static Object tryClone(Object value) { + try { + if (value.getClass().isArray()) { + int length = Array.getLength(value); + Object clone = Array.newInstance(value.getClass().getComponentType(), length); + System.arraycopy(value, 0, clone, 0, length); + return clone; + } + Method clone = value.getClass().getMethod("clone"); + ReflectionUtils.makeAccessible(clone); + return clone.invoke(value); + } catch (Throwable ignore) { + return null; + } + } + + interface ValueReader { + Object read(Object source) throws Throwable; + } + + interface ValueWriter { + void write(Object target, Object value) throws Throwable; + } + + private static final class GenericKey { + private final Class targetType; + private final Class beanType; + private final String propertyName; + + private GenericKey(Class targetType, Class beanType, String propertyName) { + this.targetType = targetType; + this.beanType = beanType; + this.propertyName = propertyName; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof GenericKey)) { + return false; + } + GenericKey that = (GenericKey) obj; + return targetType == that.targetType + && beanType == that.beanType + && Objects.equals(propertyName, that.propertyName); + } + + @Override + public int hashCode() { + int result = System.identityHashCode(targetType); + result = 31 * result + System.identityHashCode(beanType); + result = 31 * result + propertyName.hashCode(); + return result; + } + + private boolean involves(ClassLoader loader) { + return FastBeanCopierSupport.isClassLoaderMatch(targetType, loader) + || FastBeanCopierSupport.isClassLoaderMatch(beanType, loader); + } + } +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/AsmAccessorFastBeanCopierBackend.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/AsmAccessorFastBeanCopierBackend.java new file mode 100644 index 000000000..4b283dfa0 --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/AsmAccessorFastBeanCopierBackend.java @@ -0,0 +1,33 @@ +package org.hswebframework.web.bean; + +import org.hswebframework.ezorm.core.Extendable; +import org.hswebframework.web.bean.accessor.AsmBeanAccessor; + +import java.util.Map; + +final class AsmAccessorFastBeanCopierBackend extends AccessorFastBeanCopierBackend { + private final AsmBeanAccessor asmBeanAccessor; + + AsmAccessorFastBeanCopierBackend() { + this(new AsmBeanAccessor()); + } + + private AsmAccessorFastBeanCopierBackend(AsmBeanAccessor accessor) { + super(accessor); + this.asmBeanAccessor = accessor; + } + + @Override + public Copier createCopier(Class source, Class target) { + if (!Map.class.isAssignableFrom(source) + && !Map.class.isAssignableFrom(target) + && !Extendable.class.isAssignableFrom(source) + && !Extendable.class.isAssignableFrom(target)) { + Copier copier = asmBeanAccessor.createDirectCopier(source, target); + if (copier != null) { + return copier; + } + } + return super.createCopier(source, target); + } +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/ClassDescription.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/ClassDescription.java index 88a571e4b..51c6fbfa7 100644 --- a/hsweb-core/src/main/java/org/hswebframework/web/bean/ClassDescription.java +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/ClassDescription.java @@ -12,6 +12,7 @@ public class ClassDescription { private final Class type; private final boolean collectionType; + private final boolean mapType; private final boolean arrayType; private final boolean enumType; private final boolean enumDict; @@ -23,24 +24,21 @@ public class ClassDescription { public ClassDescription(Class type) { this.type = type; - - collectionType = Collection.class.isAssignableFrom(type); - enumDict = EnumDict.class.isAssignableFrom(type); - arrayType = type.isArray(); - enumType = type.isEnum(); - - number = Number.class.isAssignableFrom(type); + this.collectionType = Collection.class.isAssignableFrom(type); + this.mapType = Map.class.isAssignableFrom(type); + this.enumDict = EnumDict.class.isAssignableFrom(type); + this.arrayType = type.isArray(); + this.enumType = type.isEnum(); + this.number = Number.class.isAssignableFrom(type); if (enumType) { - enums = type.getEnumConstants(); + this.enums = type.getEnumConstants(); } else { - enums = null; + this.enums = null; } - Map f = new HashMap<>(); - ReflectionUtils.doWithFields(type, field -> { - f.put(field.getName(), field); - }); - fields = Collections.unmodifiableMap(f); - fieldSize = fields.size(); + Map fields = new HashMap<>(); + ReflectionUtils.doWithFields(type, field -> fields.put(field.getName(), field)); + this.fields = Collections.unmodifiableMap(fields); + this.fieldSize = this.fields.size(); } } diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/ClassDescriptions.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/ClassDescriptions.java index 731a50b41..ff2ba0c79 100644 --- a/hsweb-core/src/main/java/org/hswebframework/web/bean/ClassDescriptions.java +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/ClassDescriptions.java @@ -1,16 +1,20 @@ package org.hswebframework.web.bean; - -import java.util.Map; -import java.util.concurrent.ConcurrentHashMap; - public class ClassDescriptions { - private static final Map, ClassDescription> CACHE = new ConcurrentHashMap<>(); + private static final ClassLoaderScopedClassCache CACHE = new ClassLoaderScopedClassCache<>(); public static ClassDescription getDescription(Class type) { return CACHE.computeIfAbsent(type, ClassDescription::new); } + static void clearCache() { + CACHE.clear(); + } + + static void clearCache(ClassLoader loader) { + CACHE.clear(loader); + } + } diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/ClassLoaderScopedClassCache.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/ClassLoaderScopedClassCache.java new file mode 100644 index 000000000..d036839a4 --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/ClassLoaderScopedClassCache.java @@ -0,0 +1,45 @@ +package org.hswebframework.web.bean; + +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Function; + +/** + * 按 classloader 分段的 Class 维度强缓存。 + *

+ * 普通稳定 classloader 直接走强缓存，动态 classloader 场景也保持强缓存命中， + * 通过 {@link #clear(ClassLoader)} 显式回收对应分段，避免弱/软引用在热路径上导致缓存重建。 + * + * @param value type + * @author zhouhao + * @since 5.0.2 + */ +final class ClassLoaderScopedClassCache { + + private final Map, V> stableCache = new ConcurrentHashMap<>(); + private final Map, V>> volatileCache = new ConcurrentHashMap<>(); + + V computeIfAbsent(Class type, Function, V> mappingFunction) { + if (!FastBeanCopierSupport.isVolatileClassLoaderType(type)) { + return stableCache.computeIfAbsent(type, mappingFunction); + } + ClassLoader loader = FastBeanCopierSupport.getClassLoader(type); + return volatileCache + .computeIfAbsent(loader, ignore -> new ConcurrentHashMap<>()) + .computeIfAbsent(type, mappingFunction); + } + + void clear() { + stableCache.clear(); + volatileCache.clear(); + } + + void clear(ClassLoader loader) { + if (loader == null) { + clear(); + return; + } + stableCache.keySet().removeIf(type -> FastBeanCopierSupport.isClassLoaderMatch(type, loader)); + volatileCache.remove(loader); + } +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopier.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopier.java index fdb5fec9f..d542fe275 100644 --- a/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopier.java +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopier.java @@ -1,781 +1,114 @@ package org.hswebframework.web.bean; -import com.google.common.collect.Maps; -import io.netty.util.internal.ConcurrentSet; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.SneakyThrows; -import lombok.extern.slf4j.Slf4j; -import org.apache.commons.beanutils.BeanUtilsBean; -import org.apache.commons.beanutils.ConvertUtilsBean; -import org.apache.commons.beanutils.PropertyUtilsBean; -import org.hswebframework.ezorm.core.Extendable; -import org.hswebframework.utils.time.DateFormatter; -import org.hswebframework.web.dict.EnumDict; -import org.hswebframework.web.proxy.Proxy; -import org.hswebframework.web.utils.DynamicArrayList; -import org.springframework.core.ResolvableType; -import org.springframework.util.ClassUtils; -import org.springframework.util.CollectionUtils; -import org.springframework.util.NumberUtils; -import org.springframework.util.ReflectionUtils; - -import java.beans.PropertyDescriptor; -import java.lang.reflect.Array; -import java.lang.reflect.Field; -import java.util.*; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentMap; -import java.util.function.BiFunction; -import java.util.function.Function; +import java.util.Set; import java.util.function.Supplier; -import java.util.stream.Collectors; -import java.util.stream.Stream; /** - * @author zhouhao - * @since 3.0 + * FastBeanCopier facade. */ -@Slf4j public final class FastBeanCopier { - private static final Map CACHE = new ConcurrentHashMap<>(); - - private static final PropertyUtilsBean propertyUtils = BeanUtilsBean.getInstance().getPropertyUtils(); - - private static final ConvertUtilsBean convertUtils = BeanUtilsBean.getInstance().getConvertUtils(); - - private static final Map, Class> wrapperClassMapping = new HashMap<>(); @SuppressWarnings("all") - public static final Class[] EMPTY_CLASS_ARRAY = new Class[0]; + public static final Class[] EMPTY_CLASS_ARRAY = FastBeanCopierSupport.EMPTY_CLASS_ARRAY; - private static BeanFactory BEAN_FACTORY; + /** + * @deprecated 请改用 {@link FastBeanCopierSupport#DEFAULT_CONVERT} + */ + @Deprecated + public static final DefaultConverter DEFAULT_CONVERT = new DefaultConverter(); - public static final DefaultConverter DEFAULT_CONVERT; + private FastBeanCopier() { + } public static void setBeanFactory(BeanFactory beanFactory) { - BEAN_FACTORY = beanFactory; + FastBeanCopierSupport.setBeanFactory(beanFactory); DEFAULT_CONVERT.setBeanFactory(beanFactory); } public static BeanFactory getBeanFactory() { - return BEAN_FACTORY; + return FastBeanCopierSupport.getBeanFactory(); + } + + public static void setBackend(FastBeanCopierBackend backend) { + FastBeanCopierSupport.setBackend(backend); } - static { - wrapperClassMapping.put(byte.class, Byte.class); - wrapperClassMapping.put(short.class, Short.class); - wrapperClassMapping.put(int.class, Integer.class); - wrapperClassMapping.put(float.class, Float.class); - wrapperClassMapping.put(double.class, Double.class); - wrapperClassMapping.put(char.class, Character.class); - wrapperClassMapping.put(boolean.class, Boolean.class); - wrapperClassMapping.put(long.class, Long.class); - BEAN_FACTORY = new BeanFactory() { - @Override - @SneakyThrows - @SuppressWarnings("all") - public T newInstance(Class beanType) { - return beanType == Map.class ? (T) new HashMap<>() : beanType.newInstance(); - } - }; - DEFAULT_CONVERT = new DefaultConverter(); - DEFAULT_CONVERT.setBeanFactory(BEAN_FACTORY); + public static FastBeanCopierBackend getBackend() { + return FastBeanCopierSupport.getBackend(); } @SuppressWarnings("all") public static Set include(String... inculdeProperties) { - return new HashSet(Arrays.asList(inculdeProperties)) { - @Override - public boolean contains(Object o) { - return !super.contains(o); - } - }; + return FastBeanCopierSupport.include(inculdeProperties); } public static Object getProperty(Object source, String key) { - if (source instanceof Map) { - return ((Map) source).get(key); - } - SingleValueMap map = new SingleValueMap<>(); - copy(source, map, include(key)); - return map.getValue(); + return FastBeanCopierSupport.getProperty(source, key); } public static T copy(S source, T target, String... ignore) { - return copy(source, target, DEFAULT_CONVERT, ignore); + return FastBeanCopierSupport.copy(source, target, ignore); } public static T copy(S source, Supplier target, String... ignore) { - return copy(source, target.get(), DEFAULT_CONVERT, ignore); + return FastBeanCopierSupport.copy(source, target, ignore); } - @SneakyThrows public static T copy(S source, Class target, String... ignore) { - return copy(source, target.newInstance(), DEFAULT_CONVERT, ignore); + return FastBeanCopierSupport.copy(source, target, ignore); } public static T copy(S source, T target, Converter converter, String... ignore) { - return copy(source, target, converter, (ignore == null || ignore.length == 0) ? Collections.emptySet() : new HashSet<>(Arrays.asList(ignore))); + return FastBeanCopierSupport.copy(source, target, converter, ignore); } public static T copy(S source, T target, Set ignore) { - return copy(source, target, DEFAULT_CONVERT, ignore); + return FastBeanCopierSupport.copy(source, target, ignore); } - @SuppressWarnings("all") public static T copy(S source, T target, Converter converter, Set ignore) { - if (source instanceof Map && target instanceof Map) { - if (CollectionUtils.isEmpty(ignore)) { - ((Map) target).putAll(((Map) source)); - } else { - ((Map) source) - .forEach((k, v) -> { - if (!ignore.contains(k)) { - ((Map) target).put(k, v); - } - }); - } - return target; - } - - getCopier(source, target, true) - .copy(source, target, ignore, converter); - return target; + return FastBeanCopierSupport.copy(source, target, converter, ignore); } static Class getUserClass(Object object) { - if (object instanceof Map) { - return Map.class; - } - Class type = ClassUtils.getUserClass(object); - - if (java.lang.reflect.Proxy.isProxyClass(type)) { - Class[] interfaces = type.getInterfaces(); - return interfaces[0]; - } - - return type; + return FastBeanCopierSupport.getUserClass(object); } public static Copier getCopier(Object source, Object target, boolean autoCreate) { - Class sourceType = getUserClass(source); - Class targetType = getUserClass(target); - CacheKey key = createCacheKey(sourceType, targetType); - if (autoCreate) { - return CACHE.computeIfAbsent(key, k -> createCopier(k.sourceType, k.targetType)); - } else { - return CACHE.get(key); - } - - } - - private static CacheKey createCacheKey(Class source, Class target) { - return new CacheKey(source, target); + return FastBeanCopierSupport.getCopier(source, target, autoCreate); } public static Copier createCopier(Class source, Class target) { - String sourceName = source.getName(); - String tartName = target.getName(); - if (sourceName.startsWith("package ")) { - sourceName = sourceName.substring("package ".length()); - } - if (tartName.startsWith("package ")) { - tartName = tartName.substring("package ".length()); - } - boolean targetIsExtendable = Extendable.class.isAssignableFrom(target); - boolean sourceIsExtendable = Extendable.class.isAssignableFrom(source); - boolean targetIsMap = Map.class.isAssignableFrom(target); - boolean sourceIsMap = Map.class.isAssignableFrom(source); - - String method = "public void copy(Object s, Object t, java.util.Set ignore, " + - "org.hswebframework.web.bean.Converter converter){\n" + - "try{\n\t" + - sourceName + " $$__source=(" + sourceName + ")s;\n\t" + - tartName + " $$__target=(" + tartName + ")t;\n\t" + - createCopierCode(source, target) + - "}catch(Throwable e){\n" + - "\tthrow e;" + - "\n}\n" + - "\n}"; - try { - @SuppressWarnings("all") - Proxy proxy = Proxy - .create(Copier.class, new Class[]{source, target}) - .addMethod(method); - Copier copier = proxy.newInstance(); - if (sourceIsExtendable && targetIsMap) { - copier = new ExtendableToMapCopier(copier); - } else if (sourceIsMap && targetIsExtendable) { - copier = new MapToExtendableCopier(copier); - } else if (sourceIsExtendable) { - copier = new ExtendableToBeanCopier(copier); - } - return copier; - } catch (Exception e) { - log.error("创建bean copy 代理对象失败:\n{}", method, e); - throw new UnsupportedOperationException(e.getMessage(), e); - } + return FastBeanCopierSupport.createCopier(source, target); } - private static Map createProperty(Class type) { - - List fieldNames = Arrays - .stream(type.getDeclaredFields()) - .map(Field::getName) - .collect(Collectors.toList()); - - return Stream.of(propertyUtils.getPropertyDescriptors(type)) - .filter(property -> !property - .getName() - .equals("class") && property.getReadMethod() != null && property.getWriteMethod() != null) - .map(BeanClassProperty::new) - //让字段有序 - .sorted(Comparator.comparing(property -> fieldNames.indexOf(property.name))) - .collect(Collectors.toMap(ClassProperty::getName, Function.identity(), (k, k2) -> k, LinkedHashMap::new)); - + public static void clearCache() { + FastBeanCopierSupport.clearCache(); } - private static Map createMapProperty(Map template) { - return template - .values() - .stream() - .map(classProperty -> new MapClassProperty(classProperty.name)) - .collect(Collectors.toMap(ClassProperty::getName, Function.identity(), (k, k2) -> k, LinkedHashMap::new)); + public static void clearCache(ClassLoader loader) { + FastBeanCopierSupport.clearCache(loader); } - private static String createCopierCode(Class source, Class target) { - Map sourceProperties = null; - - Map targetProperties = null; - - boolean targetIsExtendable = Extendable.class.isAssignableFrom(target); - boolean sourceIsExtendable = Extendable.class.isAssignableFrom(source); - boolean targetIsMap = Map.class.isAssignableFrom(target); - boolean sourceIsMap = Map.class.isAssignableFrom(source); - //源类型为Map - if (sourceIsMap) { - if (!targetIsMap) { - targetProperties = createProperty(target); - sourceProperties = createMapProperty(targetProperties); - - } - } else if (targetIsMap) { - sourceProperties = createProperty(source); - targetProperties = createMapProperty(sourceProperties); - } else { - targetProperties = createProperty(target); - sourceProperties = createProperty(source); - } - if (sourceProperties == null || targetProperties == null) { - throw new UnsupportedOperationException("不支持的类型,source:" + source + " target:" + target); + /** + * @deprecated 请改用 {@link FastBeanCopierSupport.DefaultConverter} + */ + @Deprecated + public static class DefaultConverter implements Converter { + DefaultConverter() { } - StringBuilder code = new StringBuilder(); - - for (ClassProperty sourceProperty : sourceProperties.values()) { - ClassProperty targetProperty = targetProperties.get(sourceProperty.getName()); - if (targetProperty == null) { - //复制到拓展对象 - if (targetIsExtendable && !sourceIsExtendable && !sourceIsMap) { - code.append("if(!ignore.contains(\"").append(sourceProperty.getName()).append("\")){\n\t"); - if (!sourceProperty.isPrimitive()) { - code.append("if($$__source.").append(sourceProperty.getReadMethod()).append("!=null){\n"); - } - code.append("\t\t((org.hswebframework.ezorm.core.Extendable)$$__target).setExtension(") - .append("\"").append(sourceProperty.name).append("\",") - .append("$$__source.").append(sourceProperty.getReadMethod()) - .append(");"); - if (!sourceProperty.isPrimitive()) { - code.append("\n\t}"); - } - code.append("\n}\n"); - } - continue; - } - code.append("if(!ignore.contains(\"").append(sourceProperty.getName()).append("\")){\n\t"); - if (!sourceProperty.isPrimitive()) { - code.append("if($$__source.").append(sourceProperty.getReadMethod()).append("!=null){\n"); - } - code.append(targetProperty.generateVar(targetProperty.getName())).append("=") - .append(sourceProperty.generateGetter(target, targetProperty.getType())) - .append(";\n"); - - if (!targetProperty.isPrimitive()) { - code.append("\tif(").append(sourceProperty.getName()).append("!=null){\n"); - } - code - .append("\t$$__target.") - .append(targetProperty.generateSetter(targetProperty.getType(), sourceProperty.getName())) - .append(";\n"); - if (!targetProperty.isPrimitive()) { - code.append("\t}\n"); - } - if (!sourceProperty.isPrimitive()) { - code.append("\t}\n"); - } - code.append("}\n"); - } - return code.toString(); - } - - static abstract class ClassProperty { - - @Getter - protected String name; - - @Getter - protected String readMethodName; - - @Getter - protected String writeMethodName; - - @Getter - protected BiFunction, Class, String> getter; - - @Getter - protected BiFunction, String, String> setter; - - @Getter - protected Class type; - - @Getter - protected Class beanType; - - public String getReadMethod() { - return readMethodName + "()"; - } - - public String generateVar(String name) { - return getTypeName().concat(" ").concat(name); - } - - public String getTypeName() { - return getTypeName(type); - } - - public String getTypeName(Class type) { - String targetTypeName = type.getName(); - if (type.isArray()) { - targetTypeName = type.getComponentType().getName() + "[]"; - } - return targetTypeName; - } - - public boolean isPrimitive() { - return isPrimitive(getType()); - } - - public boolean isPrimitive(Class type) { - return type.isPrimitive(); - } - - public boolean isWrapper() { - return isWrapper(getType()); - } - - public boolean isWrapper(Class type) { - return wrapperClassMapping.containsValue(type); - } - - protected Class getPrimitiveType(Class type) { - return wrapperClassMapping.entrySet().stream() - .filter(entry -> entry.getValue() == type) - .map(Map.Entry::getKey) - .findFirst() - .orElse(null); - } - - protected Class getWrapperType() { - return wrapperClassMapping.get(type); - } - - protected String castWrapper(String getter) { - return getWrapperType().getSimpleName().concat(".valueOf(").concat(getter).concat(")"); - } - - public BiFunction, Class, String> createGetterFunction() { - - return (targetBeanType, targetType) -> { - String getterCode = "$$__source." + getReadMethod(); - - String generic = "org.hswebframework.web.bean.FastBeanCopier.EMPTY_CLASS_ARRAY"; - Field field = ReflectionUtils.findField(targetBeanType, name); - boolean hasGeneric = false; - if (field != null) { - String[] arr = Arrays.stream(ResolvableType.forField(field) - .getGenerics()) - .map(ResolvableType::getRawClass) - .filter(Objects::nonNull) - .map(t -> t.getName().concat(".class")) - .toArray(String[]::new); - if (arr.length > 0) { - generic = "new Class[]{" + String.join(",", arr) + "}"; - hasGeneric = true; - } - } - String convert = "converter.convert((Object)(" + (isPrimitive() ? castWrapper(getterCode) : getterCode) + ")," - + getTypeName(targetType) + ".class," + generic + ")"; - StringBuilder convertCode = new StringBuilder(); - - if (targetType != getType()) { - if (isPrimitive(targetType)) { - boolean sourceIsWrapper = isWrapper(); - Class targetWrapperClass = wrapperClassMapping.get(targetType); - - Class sourcePrimitive = getPrimitiveType(getType()); - //目标字段是基本数据类型,源字段是包装器类型 - // source.getField().intValue(); - if (sourceIsWrapper) { - convertCode - .append(getterCode) - .append(".") - .append(sourcePrimitive.getName()) - .append("Value()"); - } else { - //类型不一致，调用convert转换 - convertCode.append("((").append(targetWrapperClass.getName()) - .append(")") - .append(convert) - .append(").") - .append(targetType.getName()) - .append("Value()"); - } - - } else if (isPrimitive()) { - boolean targetIsWrapper = isWrapper(targetType); - //源字段类型为基本数据类型，目标字段为包装器类型 - if (targetIsWrapper) { - convertCode.append(targetType.getName()) - .append(".valueOf(") - .append(getterCode) - .append(")"); - } else { - convertCode.append("(").append(targetType.getName()) - .append(")(") - .append(convert) - .append(")"); - } - } else { - convertCode.append("(").append(getTypeName(targetType)) - .append(")(") - .append(convert) - .append(")"); - } - } else { - if (Cloneable.class.isAssignableFrom(targetType)) { - try { - convertCode - .append("(") - .append(getTypeName()) - .append(")") - .append(getterCode) - .append(".clone()"); - } catch (Exception e) { - convertCode.append(getterCode); - } - } else { - if ((Map.class.isAssignableFrom(targetType) - || Collection.class.isAssignableFrom(type)) && hasGeneric) { - convertCode.append("(").append(getTypeName()).append(")").append(convert); - } else { - convertCode.append("(").append(getTypeName()).append(")").append(getterCode); -// convertCode.append(getterCode); - } - - } - - } -// if (!isPrimitive()) { -// return getterCode + "!=null?" + convertCode.toString() + ":null"; -// } - return convertCode.toString(); - }; - } - - public BiFunction, String, String> createSetterFunction(Function settingNameSupplier) { - return (sourceType, paramGetter) -> settingNameSupplier.apply(paramGetter); - } - - public String generateGetter(Class targetBeanType, Class targetType) { - return getGetter().apply(targetBeanType, targetType); - } - - public String generateSetter(Class targetType, String getter) { - return getSetter().apply(targetType, getter); - } - } - - static class BeanClassProperty extends ClassProperty { - public BeanClassProperty(PropertyDescriptor descriptor) { - type = descriptor.getPropertyType(); - readMethodName = descriptor.getReadMethod().getName(); - writeMethodName = descriptor.getWriteMethod().getName(); - - getter = createGetterFunction(); - setter = createSetterFunction(paramGetter -> writeMethodName + "(" + paramGetter + ")"); - name = descriptor.getName(); - beanType = descriptor.getReadMethod().getDeclaringClass(); - - } - } - - static class MapClassProperty extends ClassProperty { - public MapClassProperty(String name) { - type = Object.class; - this.name = name; - this.readMethodName = "get"; - this.writeMethodName = "put"; - - this.getter = createGetterFunction(); - this.setter = createSetterFunction(paramGetter -> "put(\"" + name + "\"," + paramGetter + ")"); - beanType = Map.class; - } - - @Override - public String getReadMethod() { - return "get(\"" + name + "\")"; - } - - @Override - public String getReadMethodName() { - return "get(\"" + name + "\")"; - } - } - - - public static final class DefaultConverter implements Converter { - private BeanFactory beanFactory = BEAN_FACTORY; public void setBeanFactory(BeanFactory beanFactory) { - this.beanFactory = beanFactory; + FastBeanCopierSupport.DEFAULT_CONVERT.setBeanFactory(beanFactory); } - public Collection newCollection(Class targetClass) { - - if (targetClass == List.class || targetClass == Collection.class) { - return new ArrayList<>(); - } else if (targetClass == ConcurrentHashMap.KeySetView.class) { - return ConcurrentHashMap.newKeySet(); - } else if (targetClass == Set.class) { - return new HashSet<>(); - } else if (targetClass == Queue.class) { - return new LinkedList<>(); - } else { - try { - return (Collection) targetClass.getConstructor().newInstance(); - } catch (Exception e) { - throw new UnsupportedOperationException("不支持的类型:" + targetClass, e); - } - } + public java.util.Collection newCollection(Class targetClass) { + return FastBeanCopierSupport.DEFAULT_CONVERT.newCollection(targetClass); } @Override - @SuppressWarnings("all") - @SneakyThrows public T convert(Object source, Class targetClass, Class[] genericType) { - if (source == null) { - return null; - } - ClassDescription target = ClassDescriptions.getDescription(targetClass); - - if (target.isEnumType()) { - if (source instanceof EnumDict) { - Object val = (T) ((EnumDict) source).getValue(); - if (targetClass.isInstance(val)) { - return ((T) val); - } - return convert(val, targetClass, genericType); - } - } - if (targetClass == String.class || targetClass == CharSequence.class) { - if (source instanceof Date) { - // TODO: 18-4-16 自定义格式 - return (T) DateFormatter.toString(((Date) source), "yyyy-MM-dd HH:mm:ss"); - } - return (T) String.valueOf(source); - } - if (targetClass == Object.class) { - return (T) source; - } - if (targetClass == Date.class) { - if (source instanceof String) { - T parsed = (T) DateFormatter.fromString((String) source); - if (parsed == null) { - return (T) converterByApache(Date.class, source); - } - return parsed; - } - if (source instanceof Number) { - return (T) new Date(((Number) source).longValue()); - } - if (source instanceof Date) { - return (T) new Date(((Date) source).getTime()); - } - } - if (target.isCollectionType()) { - Collection collection = newCollection(targetClass); - Collection sourceCollection; - if (source instanceof Collection) { - sourceCollection = (Collection) source; - } else if (source.getClass().isArray()) { - sourceCollection = new DynamicArrayList(source); - } else if (source instanceof Map) { - sourceCollection = ((Map) source).values(); - } else { - if (source instanceof String) { - String stringValue = ((String) source); - sourceCollection = Arrays.asList(stringValue.split("[,]")); - } else { - sourceCollection = Arrays.asList(source); - } - } - //转换泛型 - if (genericType != null && genericType.length > 0 && genericType[0] != Object.class) { - for (Object sourceObj : sourceCollection) { - collection.add(convert(sourceObj, genericType[0], null)); - } - } else { - collection.addAll(sourceCollection); - } - return (T) collection; - } - if (target.isEnumType()) { - if (target.isEnumDict()) { - String strVal = String.valueOf(source); - Object val = null; - for (Object anEnum : target.getEnums()) { - EnumDict dic = ((EnumDict) anEnum); - Enum e = ((Enum) anEnum); - if (dic.eq(source) || e.name().equalsIgnoreCase(strVal)) { - val = (T) anEnum; - break; - } - } - if (val == null) { - return null; - } - if (targetClass.isInstance(val)) { - return ((T) val); - } - return convert(val, targetClass, genericType); - } - String strSource = String.valueOf(source); - for (Object e : target.getEnums()) { - Enum t = ((Enum) e); - if ((t.name().equalsIgnoreCase(strSource) - || Objects.equals(String.valueOf(t.ordinal()), strSource))) { - return (T) e; - } - } - - log.warn("无法将:{}转为枚举:{}", - source, - targetClass, - new ClassCastException(source + "=>" + targetClass)); - return null; - } - //转换为数组 - if (target.isArrayType()) { - Class componentType = targetClass.getComponentType(); - - List val = convert(source, List.class, new Class[]{componentType}); - int size = val.size(); - - Object array = Array.newInstance(componentType, size); - for (int i = 0; i < size; i++) { - Array.set(array, i, val.get(i)); - } - return (T) array; - } - if (target.isNumber()) { - if (source instanceof String) { - return (T) NumberUtils.parseNumber(String.valueOf(source), (Class) targetClass); - } - if (source instanceof Date) { - source = ((Date) source).getTime(); - } - } - try { - org.apache.commons.beanutils.Converter converter = convertUtils.lookup(targetClass); - if (null != converter) { - return converter.convert(targetClass, source); - } - - //快速复制map - if (targetClass == Map.class) { - if (source instanceof Map) { - return (T) copyMap(((Map) source)); - } - if (source instanceof Collection) { - Map map = new LinkedHashMap<>(); - int i = 0; - for (Object o : ((Collection) source)) { - if (genericType.length >= 2) { - map.put(convert(i++, genericType[0], EMPTY_CLASS_ARRAY), convert(o, genericType[1], EMPTY_CLASS_ARRAY)); - } else { - map.put(i++, o); - } - } - return (T) map; - - } - ClassDescription sourType = ClassDescriptions.getDescription(source.getClass()); - return (T) copy(source, Maps.newHashMapWithExpectedSize(sourType.getFieldSize())); - } - - return copy(source, beanFactory.newInstance(targetClass), this); - } catch (Exception e) { - log.warn("复制类型{}->{}失败", targetClass, e); - throw e; - } -// return null; - } - - private Map copyMap(Map map) { - if (map instanceof TreeMap) { - return new TreeMap<>(map); - } - - if (map instanceof LinkedHashMap) { - return new LinkedHashMap<>(map); - } - - if (map instanceof ConcurrentHashMap) { - return new ConcurrentHashMap<>(map); - } - - return new HashMap<>(map); - } - - private Object converterByApache(Class targetClass, Object source) { - org.apache.commons.beanutils.Converter converter = convertUtils.lookup(targetClass); - if (null != converter) { - return converter.convert(targetClass, source); - } - return null; - } - } - - @AllArgsConstructor - public static class CacheKey { - - private final Class sourceType; - - private final Class targetType; - - @Override - public boolean equals(Object obj) { - if (!(obj instanceof CacheKey)) { - return false; - } - CacheKey target = ((CacheKey) obj); - return target.targetType == targetType && target.sourceType == sourceType; - } - - public int hashCode() { - int result = this.targetType != null ? this.targetType.hashCode() : 0; - result = 31 * result + (this.sourceType != null ? this.sourceType.hashCode() : 0); - return result; + return FastBeanCopierSupport.DEFAULT_CONVERT.convert(source, targetClass, genericType); } } } diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierBackend.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierBackend.java new file mode 100644 index 000000000..0a9e9cedb --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierBackend.java @@ -0,0 +1,12 @@ +package org.hswebframework.web.bean; + +/** + * Copier backend abstraction for FastBeanCopier. + * + * @author zhouhao + * @since 5.0.2 + */ +public interface FastBeanCopierBackend { + + Copier createCopier(Class source, Class target); +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierBackendSelector.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierBackendSelector.java new file mode 100644 index 000000000..2c60904fe --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierBackendSelector.java @@ -0,0 +1,65 @@ +package org.hswebframework.web.bean; + +import java.util.Locale; + +/** + * Selects the most suitable {@link FastBeanCopierBackend} for the current runtime. + * + * @author zhouhao + * @since 5.0.2 + */ +final class FastBeanCopierBackendSelector { + + static final String BACKEND_PROPERTY = "hsweb.fast-bean-copier.backend"; + static final String NATIVE_IMAGE_PROPERTY = "org.graalvm.nativeimage.imagecode"; + static final String NATIVE_HINT_PROPERTY = "hsweb.fast-bean-copier.native-image"; + static final String RUNTIME_CODEGEN_DISABLED_PROPERTY = "hsweb.fast-bean-copier.disable-codegen"; + + private FastBeanCopierBackendSelector() { + } + + static FastBeanCopierBackend selectDefaultBackend() { + String configured = System.getProperty(BACKEND_PROPERTY); + if (configured != null && !configured.isBlank()) { + return createBackend(configured); + } + return isRuntimeCodeGenerationDisabled() + ? new ReflectionAccessorFastBeanCopierBackend() + : new AsmAccessorFastBeanCopierBackend(); + } + + static boolean isRuntimeCodeGenerationDisabled() { + String explicit = System.getProperty(RUNTIME_CODEGEN_DISABLED_PROPERTY); + if (explicit != null) { + return Boolean.parseBoolean(explicit); + } + return isNativeImageRuntime(); + } + + static boolean isNativeImageRuntime() { + String explicit = System.getProperty(NATIVE_HINT_PROPERTY); + if (explicit != null) { + return Boolean.parseBoolean(explicit); + } + String imageCode = System.getProperty(NATIVE_IMAGE_PROPERTY); + return imageCode != null && !imageCode.isBlank(); + } + + static FastBeanCopierBackend createBackend(String name) { + String normalized = name == null ? "" : name.trim().toLowerCase(Locale.ROOT); + switch (normalized) { + case "asm": + case "asm-accessor": + return new AsmAccessorFastBeanCopierBackend(); + case "reflection": + case "reflection-accessor": + return new ReflectionAccessorFastBeanCopierBackend(); + case "reflect": + return new ReflectFastBeanCopierBackend(); + case "javassist": + return new JavassistFastBeanCopierBackend(); + default: + throw new IllegalArgumentException("Unsupported FastBeanCopier backend: " + name); + } + } +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierConverterSupport.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierConverterSupport.java new file mode 100644 index 000000000..7fd5aefa4 --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierConverterSupport.java @@ -0,0 +1,568 @@ +package org.hswebframework.web.bean; + +import com.google.common.collect.Maps; +import lombok.SneakyThrows; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.beanutils.BeanUtilsBean; +import org.apache.commons.beanutils.ConvertUtilsBean; +import org.hswebframework.utils.time.DateFormatter; +import org.hswebframework.web.dict.EnumDict; +import org.hswebframework.web.utils.DynamicArrayList; +import org.springframework.util.NumberUtils; + +import java.lang.reflect.Array; +import java.lang.reflect.Constructor; +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +@Slf4j +final class FastBeanCopierConverterSupport implements Converter { + private static final ConvertUtilsBean CONVERT_UTILS = BeanUtilsBean.getInstance().getConvertUtils(); + private static final Map, Class> PRIMITIVE_WRAPPERS = new HashMap<>(); + private static final org.apache.commons.beanutils.Converter NO_CONVERTER = new org.apache.commons.beanutils.Converter() { + @Override + public T convert(Class type, Object value) { + return null; + } + }; + private static final ClassLoaderScopedClassCache APACHE_CONVERTER_CACHE = + new ClassLoaderScopedClassCache<>(); + private static final ClassLoaderScopedClassCache> ENUM_LOOKUP_CACHE = + new ClassLoaderScopedClassCache<>(); + private static final ClassLoaderScopedClassCache BEAN_LIKE_TARGET_CACHE = + new ClassLoaderScopedClassCache<>(); + private static final ClassLoaderScopedClassCache COLLECTION_FACTORY_CACHE = + new ClassLoaderScopedClassCache<>(); + private static final Map PLAN_CACHE = new ConcurrentHashMap<>(); + + static { + PRIMITIVE_WRAPPERS.put(byte.class, Byte.class); + PRIMITIVE_WRAPPERS.put(short.class, Short.class); + PRIMITIVE_WRAPPERS.put(int.class, Integer.class); + PRIMITIVE_WRAPPERS.put(float.class, Float.class); + PRIMITIVE_WRAPPERS.put(double.class, Double.class); + PRIMITIVE_WRAPPERS.put(char.class, Character.class); + PRIMITIVE_WRAPPERS.put(boolean.class, Boolean.class); + PRIMITIVE_WRAPPERS.put(long.class, Long.class); + } + + private BeanFactory beanFactory; + + static void clearCache() { + APACHE_CONVERTER_CACHE.clear(); + ENUM_LOOKUP_CACHE.clear(); + BEAN_LIKE_TARGET_CACHE.clear(); + COLLECTION_FACTORY_CACHE.clear(); + PLAN_CACHE.clear(); + } + + static void clearCache(ClassLoader loader) { + if (loader == null) { + clearCache(); + return; + } + APACHE_CONVERTER_CACHE.clear(loader); + ENUM_LOOKUP_CACHE.clear(loader); + BEAN_LIKE_TARGET_CACHE.clear(loader); + COLLECTION_FACTORY_CACHE.clear(loader); + PLAN_CACHE.keySet().removeIf(key -> key.involves(loader)); + } + + void setBeanFactory(BeanFactory beanFactory) { + this.beanFactory = beanFactory; + } + + Collection newCollection(Class targetClass) { + return getCollectionFactory(targetClass).create(); + } + + @Override + @SuppressWarnings("all") + @SneakyThrows + public T convert(Object source, Class targetClass, Class[] genericType) { + if (source == null) { + return null; + } + return (T) getPlan(targetClass, genericType).convert(this, source); + } + + private ConversionPlan getPlan(Class targetClass, Class[] genericType) { + Class[] normalized = normalizeGenericTypes(genericType); + return PLAN_CACHE.computeIfAbsent(new PlanKey(targetClass, normalized), + key -> new ConversionPlan(key.targetClass, key.genericTypes)); + } + + private Class[] normalizeGenericTypes(Class[] genericType) { + if (genericType == null || genericType.length == 0) { + return FastBeanCopierSupport.EMPTY_CLASS_ARRAY; + } + Class[] normalized = new Class[genericType.length]; + System.arraycopy(genericType, 0, normalized, 0, genericType.length); + return normalized; + } + + private CollectionFactory getCollectionFactory(Class targetClass) { + return COLLECTION_FACTORY_CACHE.computeIfAbsent(targetClass, FastBeanCopierConverterSupport::createCollectionFactory); + } + + @SuppressWarnings("unchecked") + private static CollectionFactory createCollectionFactory(Class targetClass) { + if (targetClass == List.class || targetClass == Collection.class) { + return ArrayList::new; + } + if (targetClass == ConcurrentHashMap.KeySetView.class) { + return () -> (Collection) ConcurrentHashMap.newKeySet(); + } + if (targetClass == Set.class) { + return HashSet::new; + } + if (targetClass == Queue.class) { + return LinkedList::new; + } + try { + Constructor constructor = targetClass.getDeclaredConstructor(); + constructor.setAccessible(true); + return () -> { + try { + return (Collection) constructor.newInstance(); + } catch (Exception e) { + throw new UnsupportedOperationException("Unsupported Collection Type:" + targetClass, e); + } + }; + } catch (Exception e) { + return () -> { + throw new UnsupportedOperationException("Unsupported Collection Type:" + targetClass, e); + }; + } + } + + private Collection asCollection(Object source) { + if (source instanceof Collection) { + return (Collection) source; + } + if (source.getClass().isArray()) { + return new DynamicArrayList(source); + } + if (source instanceof Map) { + return ((Map) source).values(); + } + if (source instanceof String) { + return Arrays.asList(((String) source).split("[,]")); + } + return Collections.singletonList(source); + } + + private Collection convertToCollection(Object source, ConversionPlan plan) { + Collection collection = plan.collectionFactory.create(); + Collection sourceCollection = asCollection(source); + if (plan.elementType != null) { + for (Object sourceObj : sourceCollection) { + if (sourceObj == null || isDirectAssignable(plan.elementType, sourceObj)) { + collection.add(sourceObj); + } else { + collection.add(convert(sourceObj, plan.elementType, FastBeanCopierSupport.EMPTY_CLASS_ARRAY)); + } + } + return collection; + } + collection.addAll(sourceCollection); + return collection; + } + + private Object convertToArray(Object source, Class componentType) { + if (source.getClass().isArray() && source.getClass().getComponentType() == componentType) { + int length = Array.getLength(source); + Object array = Array.newInstance(componentType, length); + System.arraycopy(source, 0, array, 0, length); + return array; + } + Collection sourceCollection = asCollection(source); + Object array = Array.newInstance(componentType, sourceCollection.size()); + int index = 0; + for (Object value : sourceCollection) { + Array.set(array, + index++, + value == null || isDirectAssignable(componentType, value) + ? value + : convert(value, componentType, FastBeanCopierSupport.EMPTY_CLASS_ARRAY)); + } + return array; + } + + private Map convertCollectionToMap(Collection sourceCollection, ConversionPlan plan) { + Map map = new LinkedHashMap<>(Math.max((int) (sourceCollection.size() / 0.75F) + 1, 16)); + int i = 0; + for (Object o : sourceCollection) { + if (plan.mapKeyType != null && plan.mapValueType != null) { + map.put(convert(i++, plan.mapKeyType, FastBeanCopierSupport.EMPTY_CLASS_ARRAY), + convert(o, plan.mapValueType, FastBeanCopierSupport.EMPTY_CLASS_ARRAY)); + } else { + map.put(i++, o); + } + } + return map; + } + + private Map copyMap(Map map) { + if (map instanceof TreeMap) { + return new TreeMap<>(map); + } + if (map instanceof LinkedHashMap) { + return new LinkedHashMap<>(map); + } + if (map instanceof ConcurrentHashMap) { + return new ConcurrentHashMap<>(map); + } + return new HashMap<>(map); + } + + private static org.apache.commons.beanutils.Converter lookupApacheConverter(Class targetClass) { + org.apache.commons.beanutils.Converter converter = + APACHE_CONVERTER_CACHE.computeIfAbsent(targetClass, + type -> { + org.apache.commons.beanutils.Converter found = CONVERT_UTILS.lookup(type); + return found == null ? NO_CONVERTER : found; + }); + return converter == NO_CONVERTER ? null : converter; + } + + private boolean isDirectScalarAssignable(Class targetClass, Object source) { + if (source instanceof Number || source instanceof Boolean || source instanceof Character || source instanceof Enum) { + return isDirectAssignable(targetClass, source); + } + return false; + } + + private Object lookupEnum(Class targetClass, Object source) { + if (source == null) { + return null; + } + if (targetClass.isInstance(source)) { + return source; + } + if (source instanceof Map) { + Map map = (Map) source; + Object value = map.get("value"); + Object matched = lookupEnum(targetClass, value); + return matched != null ? matched : lookupEnum(targetClass, map.get("text")); + } + if (source instanceof EnumDict) { + EnumDict dict = (EnumDict) source; + Object matched = lookupEnum(targetClass, dict.getValue()); + return matched != null ? matched : lookupEnum(targetClass, dict.getText()); + } + if (source instanceof Number) { + source = ((Number) source).intValue(); + } + String key = normalizeEnumKey(source); + return ENUM_LOOKUP_CACHE + .computeIfAbsent(targetClass, this::createEnumLookup) + .get(key); + } + + private Map createEnumLookup(Class targetClass) { + ClassDescription description = ClassDescriptions.getDescription(targetClass); + Map lookup = new HashMap<>(); + for (Object obj : description.getEnums()) { + Enum value = (Enum) obj; + lookup.putIfAbsent(normalizeEnumKey(value.name()), obj); + lookup.putIfAbsent(normalizeEnumKey(value.ordinal()), obj); + if (obj instanceof EnumDict) { + EnumDict dict = (EnumDict) obj; + lookup.putIfAbsent(normalizeEnumKey(dict.getValue()), obj); + lookup.putIfAbsent(normalizeEnumKey(dict.getText()), obj); + } + } + return lookup; + } + + private String normalizeEnumKey(Object value) { + return String.valueOf(value).trim().toLowerCase(Locale.ROOT); + } + + private boolean isDirectAssignable(Class targetClass, Object source) { + if (source == null) { + return false; + } + if (targetClass.isInstance(source)) { + return true; + } + if (targetClass.isPrimitive()) { + Class wrapper = PRIMITIVE_WRAPPERS.get(targetClass); + return wrapper != null && wrapper.isInstance(source); + } + return false; + } + + private static boolean isBeanLikeTarget(ClassDescription target, Class targetClass) { + return BEAN_LIKE_TARGET_CACHE.computeIfAbsent(targetClass, + ignore -> targetClass != Object.class + && targetClass != String.class + && targetClass != CharSequence.class + && targetClass != Date.class + && targetClass != Boolean.class + && targetClass != Character.class + && targetClass != boolean.class + && targetClass != char.class + && !target.isEnumType() + && !target.isArrayType() + && !target.isCollectionType() + && !target.isNumber() + && !Map.class.isAssignableFrom(targetClass)); + } + + private Number convertNumber(Number source, Class targetClass) { + Class wrapper = targetClass.isPrimitive() ? PRIMITIVE_WRAPPERS.get(targetClass) : targetClass; + return NumberUtils.convertNumberToTargetClass(source, (Class) wrapper); + } + + private Number convertStringToNumber(String source, Class targetClass) { + String value = source.trim(); + Class wrapper = targetClass.isPrimitive() ? PRIMITIVE_WRAPPERS.get(targetClass) : targetClass; + try { + if (wrapper == Integer.class) { + return Integer.parseInt(value); + } + if (wrapper == Long.class) { + return Long.parseLong(value); + } + if (wrapper == Short.class) { + return Short.parseShort(value); + } + if (wrapper == Byte.class) { + return Byte.parseByte(value); + } + if (wrapper == Double.class) { + return Double.parseDouble(value); + } + if (wrapper == Float.class) { + return Float.parseFloat(value); + } + } catch (NumberFormatException ignore) { + // fallback to Spring NumberUtils for extended formats + } + return NumberUtils.parseNumber(value, (Class) targetClass); + } + + private Boolean convertToBoolean(Object source) { + if (source instanceof Boolean) { + return (Boolean) source; + } + if (source instanceof Number) { + return ((Number) source).intValue() != 0; + } + String value = String.valueOf(source).trim(); + if (value.isEmpty()) { + return Boolean.FALSE; + } + return "true".equalsIgnoreCase(value) + || "1".equals(value) + || "y".equalsIgnoreCase(value) + || "yes".equalsIgnoreCase(value) + || "on".equalsIgnoreCase(value); + } + + private Character convertToCharacter(Object source) { + if (source instanceof Character) { + return (Character) source; + } + if (source instanceof Number) { + return (char) ((Number) source).intValue(); + } + String value = String.valueOf(source); + return value.isEmpty() ? null : value.charAt(0); + } + + private interface CollectionFactory { + Collection create(); + } + + private final class ConversionPlan { + private final Class targetClass; + private final Class[] genericTypes; + private final ClassDescription target; + private final org.apache.commons.beanutils.Converter apacheConverter; + private final CollectionFactory collectionFactory; + private final Class elementType; + private final Class mapKeyType; + private final Class mapValueType; + private final Class componentType; + private final boolean stringLike; + private final boolean objectType; + private final boolean dateType; + private final boolean booleanType; + private final boolean characterType; + private final boolean collectionType; + private final boolean enumType; + private final boolean arrayType; + private final boolean numberType; + private final boolean mapInterfaceType; + private final boolean beanLikeTarget; + + private ConversionPlan(Class targetClass, Class[] genericTypes) { + this.targetClass = targetClass; + this.genericTypes = genericTypes; + this.target = ClassDescriptions.getDescription(targetClass); + this.stringLike = targetClass == String.class || targetClass == CharSequence.class; + this.objectType = targetClass == Object.class; + this.dateType = targetClass == Date.class; + this.booleanType = targetClass == boolean.class || targetClass == Boolean.class; + this.characterType = targetClass == char.class || targetClass == Character.class; + this.collectionType = target.isCollectionType(); + this.enumType = target.isEnumType(); + this.arrayType = target.isArrayType(); + this.numberType = target.isNumber(); + this.mapInterfaceType = targetClass == Map.class; + this.beanLikeTarget = isBeanLikeTarget(target, targetClass); + this.apacheConverter = lookupApacheConverter(targetClass); + this.collectionFactory = collectionType ? getCollectionFactory(targetClass) : null; + this.elementType = genericTypes.length > 0 && genericTypes[0] != Object.class ? genericTypes[0] : null; + this.mapKeyType = genericTypes.length >= 2 ? genericTypes[0] : null; + this.mapValueType = genericTypes.length >= 2 ? genericTypes[1] : null; + this.componentType = arrayType ? targetClass.getComponentType() : null; + } + + @SuppressWarnings("all") + private Object convert(FastBeanCopierConverterSupport support, Object source) throws Throwable { + if (support.isDirectScalarAssignable(targetClass, source)) { + return source; + } + if (enumType && source instanceof EnumDict) { + Object val = ((EnumDict) source).getValue(); + if (targetClass.isInstance(val)) { + return val; + } + Object matched = support.lookupEnum(targetClass, val); + if (matched == null) { + matched = support.lookupEnum(targetClass, ((EnumDict) source).getText()); + } + if (matched != null) { + return matched; + } + return support.convert(val, targetClass, genericTypes); + } + if (stringLike) { + if (source instanceof Date) { + return DateFormatter.toString(((Date) source), "yyyy-MM-dd HH:mm:ss"); + } + return String.valueOf(source); + } + if (objectType) { + return source; + } + if (dateType) { + if (source instanceof String) { + Object parsed = DateFormatter.fromString((String) source); + if (parsed == null) { + return apacheConverter == null ? null : apacheConverter.convert(Date.class, source); + } + return parsed; + } + if (source instanceof Number) { + return new Date(((Number) source).longValue()); + } + if (source instanceof Date) { + return new Date(((Date) source).getTime()); + } + } + if (booleanType) { + return support.convertToBoolean(source); + } + if (characterType) { + return support.convertToCharacter(source); + } + if (collectionType) { + return support.convertToCollection(source, this); + } + if (enumType) { + Object val = support.lookupEnum(targetClass, source); + if (val != null) { + if (targetClass.isInstance(val)) { + return val; + } + return support.convert(val, targetClass, genericTypes); + } + log.warn("无法将:{}转为枚举:{}", + source, + targetClass, + new ClassCastException(source + "=>" + targetClass)); + return null; + } + if (arrayType) { + return support.convertToArray(source, componentType); + } + if (numberType) { + if (source instanceof Number) { + return support.convertNumber((Number) source, targetClass); + } + if (source instanceof String) { + return support.convertStringToNumber((String) source, targetClass); + } + if (source instanceof Date) { + source = ((Date) source).getTime(); + } + } + if (beanLikeTarget && source instanceof Map) { + return FastBeanCopierSupport.copy(source, support.beanFactory.newInstance(targetClass), support); + } + try { + if (apacheConverter != null) { + return apacheConverter.convert(targetClass, source); + } + if (mapInterfaceType) { + if (source instanceof Map) { + return support.copyMap((Map) source); + } + if (source instanceof Collection) { + return support.convertCollectionToMap((Collection) source, this); + } + ClassDescription sourceType = ClassDescriptions.getDescription(source.getClass()); + return FastBeanCopierSupport.copy(source, Maps.newHashMapWithExpectedSize(sourceType.getFieldSize())); + } + return FastBeanCopierSupport.copy(source, support.beanFactory.newInstance(targetClass), support); + } catch (Throwable e) { + log.warn("Copy {} to {} failed", source, targetClass, e); + throw e; + } + } + } + + private static final class PlanKey { + private final Class targetClass; + private final Class[] genericTypes; + + private PlanKey(Class targetClass, Class[] genericTypes) { + this.targetClass = targetClass; + this.genericTypes = genericTypes; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof PlanKey)) { + return false; + } + PlanKey that = (PlanKey) obj; + return targetClass == that.targetClass && Arrays.equals(genericTypes, that.genericTypes); + } + + @Override + public int hashCode() { + return 31 * System.identityHashCode(targetClass) + Arrays.hashCode(genericTypes); + } + + private boolean involves(ClassLoader loader) { + if (FastBeanCopierSupport.isClassLoaderMatch(targetClass, loader)) { + return true; + } + for (Class genericType : genericTypes) { + if (FastBeanCopierSupport.isClassLoaderMatch(genericType, loader)) { + return true; + } + } + return false; + } + } +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierPropertySupport.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierPropertySupport.java new file mode 100644 index 000000000..5e769f244 --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierPropertySupport.java @@ -0,0 +1,336 @@ +package org.hswebframework.web.bean; + +import lombok.Getter; +import org.apache.commons.beanutils.BeanUtilsBean; +import org.apache.commons.beanutils.PropertyUtilsBean; +import org.hswebframework.ezorm.core.Extendable; +import org.springframework.core.ResolvableType; +import org.springframework.util.ReflectionUtils; + +import java.beans.PropertyDescriptor; +import java.lang.reflect.Field; +import java.util.*; +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +final class FastBeanCopierPropertySupport { + private static final PropertyUtilsBean PROPERTY_UTILS = BeanUtilsBean.getInstance().getPropertyUtils(); + + private static final Map, Class> WRAPPER_CLASS_MAPPING = new HashMap<>(); + + static { + WRAPPER_CLASS_MAPPING.put(byte.class, Byte.class); + WRAPPER_CLASS_MAPPING.put(short.class, Short.class); + WRAPPER_CLASS_MAPPING.put(int.class, Integer.class); + WRAPPER_CLASS_MAPPING.put(float.class, Float.class); + WRAPPER_CLASS_MAPPING.put(double.class, Double.class); + WRAPPER_CLASS_MAPPING.put(char.class, Character.class); + WRAPPER_CLASS_MAPPING.put(boolean.class, Boolean.class); + WRAPPER_CLASS_MAPPING.put(long.class, Long.class); + } + + private FastBeanCopierPropertySupport() { + } + + static String createCopierCode(Class source, Class target) { + Map sourceProperties = null; + Map targetProperties = null; + + boolean targetIsExtendable = Extendable.class.isAssignableFrom(target); + boolean sourceIsExtendable = Extendable.class.isAssignableFrom(source); + boolean targetIsMap = Map.class.isAssignableFrom(target); + boolean sourceIsMap = Map.class.isAssignableFrom(source); + if (sourceIsMap) { + if (!targetIsMap) { + targetProperties = createProperty(target); + sourceProperties = createMapProperty(targetProperties); + } + } else if (targetIsMap) { + sourceProperties = createProperty(source); + targetProperties = createMapProperty(sourceProperties); + } else { + targetProperties = createProperty(target); + sourceProperties = createProperty(source); + } + if (sourceProperties == null || targetProperties == null) { + throw new UnsupportedOperationException("不支持的类型,source:" + source + " target:" + target); + } + StringBuilder code = new StringBuilder(); + + for (ClassProperty sourceProperty : sourceProperties.values()) { + ClassProperty targetProperty = targetProperties.get(sourceProperty.getName()); + if (targetProperty == null) { + if (targetIsExtendable && !sourceIsExtendable && !sourceIsMap) { + code.append("if(!ignore.contains(\"").append(sourceProperty.getName()).append("\")){\n\t"); + if (!sourceProperty.isPrimitive()) { + code.append("if($$__source.").append(sourceProperty.getReadMethod()).append("!=null){\n"); + } + code.append("\t\t((org.hswebframework.ezorm.core.Extendable)$$__target).setExtension(") + .append("\"").append(sourceProperty.name).append("\",") + .append("$$__source.").append(sourceProperty.getReadMethod()) + .append(");"); + if (!sourceProperty.isPrimitive()) { + code.append("\n\t}"); + } + code.append("\n}\n"); + } + continue; + } + code.append("if(!ignore.contains(\"").append(sourceProperty.getName()).append("\")){\n\t"); + if (!sourceProperty.isPrimitive()) { + code.append("if($$__source.").append(sourceProperty.getReadMethod()).append("!=null){\n"); + } + code.append(targetProperty.generateVar(targetProperty.getName())).append("=") + .append(sourceProperty.generateGetter(target, targetProperty.getType())) + .append(";\n"); + + if (!targetProperty.isPrimitive()) { + code.append("\tif(").append(sourceProperty.getName()).append("!=null){\n"); + } + code.append("\t$$__target.") + .append(targetProperty.generateSetter(targetProperty.getType(), sourceProperty.getName())) + .append(";\n"); + if (!targetProperty.isPrimitive()) { + code.append("\t}\n"); + } + if (!sourceProperty.isPrimitive()) { + code.append("\t}\n"); + } + code.append("}\n"); + } + return code.toString(); + } + + static Map createProperty(Class type) { + List fieldNames = Arrays + .stream(type.getDeclaredFields()) + .map(Field::getName) + .collect(Collectors.toList()); + + return Stream.of(PROPERTY_UTILS.getPropertyDescriptors(type)) + .filter(property -> !property.getName().equals("class") + && property.getReadMethod() != null + && property.getWriteMethod() != null) + .map(BeanClassProperty::new) + .sorted(Comparator.comparing(property -> fieldNames.indexOf(property.name))) + .collect(Collectors.toMap(ClassProperty::getName, + Function.identity(), + (k1, k2) -> k1, + LinkedHashMap::new)); + } + + static Map createMapProperty(Map template) { + return template.values() + .stream() + .map(classProperty -> new MapClassProperty(classProperty.name)) + .collect(Collectors.toMap(ClassProperty::getName, + Function.identity(), + (k1, k2) -> k1, + LinkedHashMap::new)); + } + + abstract static class ClassProperty { + @Getter + protected String name; + + @Getter + protected String readMethodName; + + @Getter + protected String writeMethodName; + + @Getter + protected BiFunction, Class, String> getter; + + @Getter + protected BiFunction, String, String> setter; + + @Getter + protected Class type; + + @Getter + protected Class beanType; + + public String getReadMethod() { + return readMethodName + "()"; + } + + public String generateVar(String name) { + return getTypeName().concat(" ").concat(name); + } + + public String getTypeName() { + return getTypeName(type); + } + + public String getTypeName(Class type) { + String targetTypeName = type.getName(); + if (type.isArray()) { + targetTypeName = type.getComponentType().getName() + "[]"; + } + return targetTypeName; + } + + public boolean isPrimitive() { + return isPrimitive(getType()); + } + + public boolean isPrimitive(Class type) { + return type.isPrimitive(); + } + + public boolean isWrapper() { + return isWrapper(getType()); + } + + public boolean isWrapper(Class type) { + return WRAPPER_CLASS_MAPPING.containsValue(type); + } + + protected Class getPrimitiveType(Class type) { + return WRAPPER_CLASS_MAPPING.entrySet().stream() + .filter(entry -> entry.getValue() == type) + .map(Map.Entry::getKey) + .findFirst() + .orElse(null); + } + + protected Class getWrapperType() { + return WRAPPER_CLASS_MAPPING.get(type); + } + + protected String castWrapper(String getter) { + return getWrapperType().getSimpleName().concat(".valueOf(").concat(getter).concat(")"); + } + + public BiFunction, Class, String> createGetterFunction() { + return (targetBeanType, targetType) -> { + String getterCode = "$$__source." + getReadMethod(); + String generic = "org.hswebframework.web.bean.FastBeanCopierSupport.EMPTY_CLASS_ARRAY"; + Field field = ReflectionUtils.findField(targetBeanType, name); + boolean hasGeneric = false; + if (field != null) { + String[] arr = Arrays.stream(ResolvableType.forField(field) + .getGenerics()) + .map(ResolvableType::getRawClass) + .filter(Objects::nonNull) + .map(t -> t.getName().concat(".class")) + .toArray(String[]::new); + if (arr.length > 0) { + generic = "new Class[]{" + String.join(",", arr) + "}"; + hasGeneric = true; + } + } + String sourceValue = "org.hswebframework.web.bean.FastBeanCopierSupport.unwrapEnumDictValue((Object)(" + + (isPrimitive() ? castWrapper(getterCode) : getterCode) + + ")," + getTypeName(targetType) + ".class)"; + String convert = "converter.convert(" + sourceValue + "," + + getTypeName(targetType) + ".class," + generic + ")"; + StringBuilder convertCode = new StringBuilder(); + + if (targetType != getType()) { + if (isPrimitive(targetType)) { + boolean sourceIsWrapper = isWrapper(); + Class targetWrapperClass = WRAPPER_CLASS_MAPPING.get(targetType); + Class sourcePrimitive = getPrimitiveType(getType()); + if (sourceIsWrapper) { + convertCode.append(getterCode) + .append(".") + .append(sourcePrimitive.getName()) + .append("Value()"); + } else { + convertCode.append("((").append(targetWrapperClass.getName()) + .append(")") + .append(convert) + .append(").") + .append(targetType.getName()) + .append("Value()"); + } + } else if (isPrimitive()) { + boolean targetIsWrapper = isWrapper(targetType); + if (targetIsWrapper) { + convertCode.append(targetType.getName()) + .append(".valueOf(") + .append(getterCode) + .append(")"); + } else { + convertCode.append("(").append(targetType.getName()) + .append(")(") + .append(convert) + .append(")"); + } + } else { + convertCode.append("(").append(getTypeName(targetType)) + .append(")(") + .append(convert) + .append(")"); + } + } else if (Cloneable.class.isAssignableFrom(targetType)) { + try { + convertCode.append("(") + .append(getTypeName()) + .append(")") + .append(getterCode) + .append(".clone()"); + } catch (Exception e) { + convertCode.append(getterCode); + } + } else if ((Map.class.isAssignableFrom(targetType) + || Collection.class.isAssignableFrom(type)) && hasGeneric) { + convertCode.append("(").append(getTypeName()).append(")").append(convert); + } else { + convertCode.append("(").append(getTypeName()).append(")").append(getterCode); + } + return convertCode.toString(); + }; + } + + public BiFunction, String, String> createSetterFunction(Function settingNameSupplier) { + return (sourceType, paramGetter) -> settingNameSupplier.apply(paramGetter); + } + + public String generateGetter(Class targetBeanType, Class targetType) { + return getGetter().apply(targetBeanType, targetType); + } + + public String generateSetter(Class targetType, String getter) { + return getSetter().apply(targetType, getter); + } + } + + static class BeanClassProperty extends ClassProperty { + BeanClassProperty(PropertyDescriptor descriptor) { + type = descriptor.getPropertyType(); + readMethodName = descriptor.getReadMethod().getName(); + writeMethodName = descriptor.getWriteMethod().getName(); + getter = createGetterFunction(); + setter = createSetterFunction(paramGetter -> writeMethodName + "(" + paramGetter + ")"); + name = descriptor.getName(); + beanType = descriptor.getReadMethod().getDeclaringClass(); + } + } + + static class MapClassProperty extends ClassProperty { + MapClassProperty(String name) { + type = Object.class; + this.name = name; + this.readMethodName = "get"; + this.writeMethodName = "put"; + this.getter = createGetterFunction(); + this.setter = createSetterFunction(paramGetter -> "put(\"" + name + "\"," + paramGetter + ")"); + beanType = Map.class; + } + + @Override + public String getReadMethod() { + return "get(\"" + name + "\")"; + } + + @Override + public String getReadMethodName() { + return "get(\"" + name + "\")"; + } + } +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierSupport.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierSupport.java new file mode 100644 index 000000000..c7908af85 --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/FastBeanCopierSupport.java @@ -0,0 +1,337 @@ +package org.hswebframework.web.bean; + +import lombok.AllArgsConstructor; +import lombok.SneakyThrows; +import org.hswebframework.web.dict.EnumDict; +import org.springframework.util.ClassUtils; +import org.springframework.util.CollectionUtils; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Supplier; + +/** + * FastBeanCopier core support. + * + * @author zhouhao + * @since 3.0 + */ +public final class FastBeanCopierSupport { + private static final Map CACHE = new ConcurrentHashMap<>(); + private static final Map BACKEND_CACHE = new ConcurrentHashMap<>(); + /** + * 动态 classloader 也保持强缓存命中，避免弱/软引用在内存波动时触发 copier 重建。 + * 对应 classloader 的释放由 clearCache(ClassLoader) 显式管理。 + */ + private static final Map VOLATILE_CACHE = new ConcurrentHashMap<>(); + private static final ClassLoader OWNER_CLASS_LOADER = FastBeanCopierSupport.class.getClassLoader(); + private static final FastBeanCopierBackend VOLATILE_CLASS_LOADER_BACKEND = + new ReflectionAccessorFastBeanCopierBackend(); + + @SuppressWarnings("all") + public static final Class[] EMPTY_CLASS_ARRAY = new Class[0]; + + private static BeanFactory BEAN_FACTORY; + + private static FastBeanCopierBackend BACKEND; + + public static final DefaultConverter DEFAULT_CONVERT; + + public static void setBeanFactory(BeanFactory beanFactory) { + BEAN_FACTORY = beanFactory; + DEFAULT_CONVERT.setBeanFactory(beanFactory); + } + + public static BeanFactory getBeanFactory() { + return BEAN_FACTORY; + } + + public static void setBackend(FastBeanCopierBackend backend) { + BACKEND = Objects.requireNonNull(backend, "backend"); + clearCache(); + } + + public static FastBeanCopierBackend getBackend() { + return BACKEND; + } + + static FastBeanCopierBackend getEffectiveBackend(Class source, Class target) { + if (usesVolatileClassLoader(source, target)) { + return adaptBackend(BACKEND, source, target); + } + CacheKey key = createCacheKey(source, target); + return BACKEND_CACHE.computeIfAbsent(key, ignore -> adaptBackend(BACKEND, source, target)); + } + + static { + BEAN_FACTORY = new BeanFactory() { + @Override + @SneakyThrows + @SuppressWarnings("all") + public T newInstance(Class beanType) { + return beanType == Map.class ? (T) new HashMap<>() : beanType.getDeclaredConstructor().newInstance(); + } + }; + BACKEND = FastBeanCopierBackendSelector.selectDefaultBackend(); + DEFAULT_CONVERT = new DefaultConverter(); + DEFAULT_CONVERT.setBeanFactory(BEAN_FACTORY); + } + + @SuppressWarnings("all") + public static Set include(String... includeProperties) { + return new HashSet(Arrays.asList(includeProperties)) { + @Override + public boolean contains(Object o) { + return !super.contains(o); + } + }; + } + + public static Object getProperty(Object source, String key) { + if (source instanceof Map) { + return ((Map) source).get(key); + } + SingleValueMap map = new SingleValueMap<>(); + copy(source, map, include(key)); + return map.getValue(); + } + + public static T copy(S source, T target, String... ignore) { + return copy(source, target, DEFAULT_CONVERT, ignore); + } + + public static T copy(S source, Supplier target, String... ignore) { + return copy(source, target.get(), DEFAULT_CONVERT, ignore); + } + + @SneakyThrows + public static T copy(S source, Class target, String... ignore) { + return copy(source, target.getDeclaredConstructor().newInstance(), DEFAULT_CONVERT, ignore); + } + + public static T copy(S source, T target, Converter converter, String... ignore) { + return copy(source, + target, + converter, + (ignore == null || ignore.length == 0) + ? Collections.emptySet() + : new HashSet<>(Arrays.asList(ignore))); + } + + public static T copy(S source, T target, Set ignore) { + return copy(source, target, DEFAULT_CONVERT, ignore); + } + + @SuppressWarnings("all") + public static T copy(S source, T target, Converter converter, Set ignore) { + if (source instanceof Map && target instanceof Map) { + if (CollectionUtils.isEmpty(ignore)) { + ((Map) target).putAll(((Map) source)); + } else { + ((Map) source) + .forEach((k, v) -> { + if (!ignore.contains(k)) { + ((Map) target).put(k, v); + } + }); + } + return target; + } + + getCopier(source, target, true) + .copy(source, target, ignore, converter); + return target; + } + + static Class getUserClass(Object object) { + if (object instanceof Map) { + return Map.class; + } + Class type = ClassUtils.getUserClass(object); + + if (java.lang.reflect.Proxy.isProxyClass(type)) { + Class[] interfaces = type.getInterfaces(); + return interfaces[0]; + } + + return type; + } + + public static Copier getCopier(Object source, Object target, boolean autoCreate) { + Class sourceType = getUserClass(source); + Class targetType = getUserClass(target); + CacheKey key = createCacheKey(sourceType, targetType); + if (usesVolatileClassLoader(sourceType, targetType)) { + return getVolatileCopier(key, autoCreate); + } + if (autoCreate) { + return CACHE.computeIfAbsent(key, k -> createCopier(k.sourceType, k.targetType)); + } + return CACHE.get(key); + } + + private static CacheKey createCacheKey(Class source, Class target) { + return new CacheKey(source, target); + } + + public static Copier createCopier(Class source, Class target) { + return getEffectiveBackend(source, target).createCopier(source, target); + } + + static boolean usesVolatileClassLoader(Class... types) { + for (Class type : types) { + if (isVolatileClassLoaderType(type)) { + return true; + } + } + return false; + } + + static boolean isClassLoaderMatch(Class type, ClassLoader loader) { + return loader != null && getClassLoader(type) == loader; + } + + static ClassLoader getClassLoader(Class type) { + if (type == null) { + return null; + } + while (type.isArray()) { + type = type.getComponentType(); + } + return type.isPrimitive() ? null : type.getClassLoader(); + } + + public static Object unwrapEnumDictValue(Object value, Class targetType) { + if (!(value instanceof EnumDict) || targetType.isEnum()) { + return value; + } + if (Number.class.isAssignableFrom(targetType) + || (targetType.isPrimitive() && targetType != boolean.class && targetType != char.class)) { + Object enumValue = ((EnumDict) value).getValue(); + return enumValue == null ? value : enumValue; + } + return value; + } + + static void clearCache() { + CACHE.clear(); + BACKEND_CACHE.clear(); + VOLATILE_CACHE.clear(); + AccessorFastBeanCopierBackend.clearCache(); + FastBeanCopierConverterSupport.clearCache(); + ClassDescriptions.clearCache(); + } + + public static void clearCache(ClassLoader loader) { + if (loader == null) { + clearCache(); + return; + } + removeCacheEntries(CACHE, loader); + removeCacheEntries(BACKEND_CACHE, loader); + removeVolatileCacheEntries(loader); + AccessorFastBeanCopierBackend.clearCache(loader); + FastBeanCopierConverterSupport.clearCache(loader); + ClassDescriptions.clearCache(loader); + } + + private static FastBeanCopierBackend adaptBackend(FastBeanCopierBackend backend, Class source, Class target) { + if (usesVolatileClassLoader(source, target)) { + if (backend instanceof AsmAccessorFastBeanCopierBackend || backend instanceof JavassistFastBeanCopierBackend) { + return VOLATILE_CLASS_LOADER_BACKEND; + } + return backend; + } + if (!FastBeanCopierBackendSelector.isRuntimeCodeGenerationDisabled()) { + return backend; + } + if (backend instanceof AsmAccessorFastBeanCopierBackend || backend instanceof JavassistFastBeanCopierBackend) { + return new ReflectionAccessorFastBeanCopierBackend(); + } + return backend; + } + + public static final class DefaultConverter implements Converter { + private final FastBeanCopierConverterSupport support = new FastBeanCopierConverterSupport(); + + public void setBeanFactory(BeanFactory beanFactory) { + support.setBeanFactory(beanFactory); + } + + public Collection newCollection(Class targetClass) { + return support.newCollection(targetClass); + } + + @Override + public T convert(Object source, Class targetClass, Class[] genericType) { + return support.convert(source, targetClass, genericType); + } + } + + private static Copier getVolatileCopier(CacheKey key, boolean autoCreate) { + if (!autoCreate) { + return VOLATILE_CACHE.get(key); + } + return VOLATILE_CACHE.computeIfAbsent(key, ignore -> createCopier(key.sourceType, key.targetType)); + } + + private static void removeCacheEntries(Map cache, ClassLoader loader) { + cache.keySet().removeIf(key -> key.involves(loader)); + } + + private static void removeVolatileCacheEntries(ClassLoader loader) { + removeCacheEntries(VOLATILE_CACHE, loader); + } + + static boolean isVolatileClassLoaderType(Class type) { + ClassLoader loader = getClassLoader(type); + if (loader == null || loader == OWNER_CLASS_LOADER) { + return false; + } + if (OWNER_CLASS_LOADER == null) { + return true; + } + try { + return Class.forName(type.getName(), false, OWNER_CLASS_LOADER) != type; + } catch (Throwable ignore) { + return true; + } + } + + static int getStableCacheSize() { + return CACHE.size(); + } + + static int getVolatileCacheSize() { + return VOLATILE_CACHE.size(); + } + + @AllArgsConstructor + public static class CacheKey { + + private final Class sourceType; + + private final Class targetType; + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof CacheKey)) { + return false; + } + CacheKey target = ((CacheKey) obj); + return target.targetType == targetType && target.sourceType == sourceType; + } + + @Override + public int hashCode() { + int result = this.targetType != null ? this.targetType.hashCode() : 0; + result = 31 * result + (this.sourceType != null ? this.sourceType.hashCode() : 0); + return result; + } + + private boolean involves(ClassLoader loader) { + return isClassLoaderMatch(sourceType, loader) || isClassLoaderMatch(targetType, loader); + } + } + +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/JavassistFastBeanCopierBackend.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/JavassistFastBeanCopierBackend.java new file mode 100644 index 000000000..a9696dc40 --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/JavassistFastBeanCopierBackend.java @@ -0,0 +1,56 @@ +package org.hswebframework.web.bean; + +import lombok.extern.slf4j.Slf4j; +import org.hswebframework.ezorm.core.Extendable; +import org.hswebframework.web.proxy.Proxy; + +import java.util.Map; + +@Slf4j +final class JavassistFastBeanCopierBackend implements FastBeanCopierBackend { + + @Override + public Copier createCopier(Class source, Class target) { + String sourceName = source.getName(); + String targetName = target.getName(); + if (sourceName.startsWith("package ")) { + sourceName = sourceName.substring("package ".length()); + } + if (targetName.startsWith("package ")) { + targetName = targetName.substring("package ".length()); + } + boolean targetIsExtendable = Extendable.class.isAssignableFrom(target); + boolean sourceIsExtendable = Extendable.class.isAssignableFrom(source); + boolean targetIsMap = Map.class.isAssignableFrom(target); + boolean sourceIsMap = Map.class.isAssignableFrom(source); + + String method = "public void copy(Object s, Object t, java.util.Set ignore, " + + "org.hswebframework.web.bean.Converter converter){\n" + + "try{\n\t" + + sourceName + " $$__source=(" + sourceName + ")s;\n\t" + + targetName + " $$__target=(" + targetName + ")t;\n\t" + + FastBeanCopierPropertySupport.createCopierCode(source, target) + + "}catch(Throwable e){\n" + + "\tthrow e;" + + "\n}\n" + + "\n}"; + try { + @SuppressWarnings("all") + Proxy proxy = Proxy + .create(Copier.class, new Class[]{source, target}) + .addMethod(method); + Copier copier = proxy.newInstance(); + if (sourceIsExtendable && targetIsMap) { + copier = new ExtendableToMapCopier(copier); + } else if (sourceIsMap && targetIsExtendable) { + copier = new MapToExtendableCopier(copier); + } else if (sourceIsExtendable) { + copier = new ExtendableToBeanCopier(copier); + } + return copier; + } catch (Throwable e) { + log.error("create bean copy {} =>{} failed :\n{}", source, target, method, e); + throw new UnsupportedOperationException(e.getMessage(), e); + } + } +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/ReflectFastBeanCopierBackend.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/ReflectFastBeanCopierBackend.java new file mode 100644 index 000000000..04ee4c8df --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/ReflectFastBeanCopierBackend.java @@ -0,0 +1,355 @@ +package org.hswebframework.web.bean; + +import lombok.SneakyThrows; +import lombok.extern.slf4j.Slf4j; +import org.hswebframework.ezorm.core.Extendable; +import org.hswebframework.web.dict.EnumDict; +import org.springframework.core.ResolvableType; +import org.springframework.util.ReflectionUtils; + +import java.lang.reflect.Array; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.*; + +@Slf4j +final class ReflectFastBeanCopierBackend implements FastBeanCopierBackend { + + @Override + public Copier createCopier(Class source, Class target) { + try { + Copier copier = new ReflectCopier(source, target); + boolean targetIsExtendable = Extendable.class.isAssignableFrom(target); + boolean sourceIsExtendable = Extendable.class.isAssignableFrom(source); + boolean targetIsMap = Map.class.isAssignableFrom(target); + boolean sourceIsMap = Map.class.isAssignableFrom(source); + if (sourceIsExtendable && targetIsMap) { + copier = new ExtendableToMapCopier(copier); + } else if (sourceIsMap && targetIsExtendable) { + copier = new MapToExtendableCopier(copier); + } else if (sourceIsExtendable) { + copier = new ExtendableToBeanCopier(copier); + } + return copier; + } catch (Throwable e) { + log.error("create bean copy {} => {} failed", source, target, e); + throw new UnsupportedOperationException(e.getMessage(), e); + } + } + + static final class ReflectCopier implements Copier { + private final List mappings; + private final List extensionMappings; + + ReflectCopier(Class source, Class target) { + Map sourceProperties = null; + Map targetProperties = null; + + boolean targetIsExtendable = Extendable.class.isAssignableFrom(target); + boolean sourceIsExtendable = Extendable.class.isAssignableFrom(source); + boolean targetIsMap = Map.class.isAssignableFrom(target); + boolean sourceIsMap = Map.class.isAssignableFrom(source); + if (sourceIsMap) { + if (!targetIsMap) { + targetProperties = FastBeanCopierPropertySupport.createProperty(target); + sourceProperties = FastBeanCopierPropertySupport.createMapProperty(targetProperties); + } + } else if (targetIsMap) { + sourceProperties = FastBeanCopierPropertySupport.createProperty(source); + targetProperties = FastBeanCopierPropertySupport.createMapProperty(sourceProperties); + } else { + targetProperties = FastBeanCopierPropertySupport.createProperty(target); + sourceProperties = FastBeanCopierPropertySupport.createProperty(source); + } + if (sourceProperties == null || targetProperties == null) { + throw new UnsupportedOperationException("不支持的类型,source:" + source + " target:" + target); + } + + List mappings = new ArrayList<>(); + List extensionMappings = new ArrayList<>(); + for (FastBeanCopierPropertySupport.ClassProperty sourceProperty : sourceProperties.values()) { + FastBeanCopierPropertySupport.ClassProperty targetProperty = targetProperties.get(sourceProperty.getName()); + if (targetProperty == null) { + if (targetIsExtendable && !sourceIsExtendable && !sourceIsMap) { + extensionMappings.add(new ExtensionMapping(sourceProperty)); + } + continue; + } + mappings.add(PropertyMapping.of(target, sourceProperty, targetProperty)); + } + this.mappings = mappings; + this.extensionMappings = extensionMappings; + } + + @Override + public void copy(Object source, Object target, Set ignore, Converter converter) { + try { + for (PropertyMapping mapping : mappings) { + mapping.copy(source, target, ignore, converter); + } + if (!extensionMappings.isEmpty()) { + Extendable extendable = (Extendable) target; + for (ExtensionMapping mapping : extensionMappings) { + mapping.copy(source, extendable, ignore); + } + } + } catch (RuntimeException e) { + throw e; + } catch (Throwable e) { + throw new UnsupportedOperationException(e.getMessage(), e); + } + } + } + + static final class PropertyMapping { + private static final Map, Class> PRIMITIVE_WRAPPERS = new HashMap<>(); + + static { + PRIMITIVE_WRAPPERS.put(byte.class, Byte.class); + PRIMITIVE_WRAPPERS.put(short.class, Short.class); + PRIMITIVE_WRAPPERS.put(int.class, Integer.class); + PRIMITIVE_WRAPPERS.put(float.class, Float.class); + PRIMITIVE_WRAPPERS.put(double.class, Double.class); + PRIMITIVE_WRAPPERS.put(char.class, Character.class); + PRIMITIVE_WRAPPERS.put(boolean.class, Boolean.class); + PRIMITIVE_WRAPPERS.put(long.class, Long.class); + } + + private final String name; + private final ValueReader reader; + private final ValueWriter writer; + private final Class sourceType; + private final Class targetType; + private final boolean sourcePrimitive; + private final boolean targetPrimitive; + private final Class[] genericTypes; + + private PropertyMapping(String name, + ValueReader reader, + ValueWriter writer, + Class sourceType, + Class targetType, + boolean sourcePrimitive, + boolean targetPrimitive, + Class[] genericTypes) { + this.name = name; + this.reader = reader; + this.writer = writer; + this.sourceType = sourceType; + this.targetType = targetType; + this.sourcePrimitive = sourcePrimitive; + this.targetPrimitive = targetPrimitive; + this.genericTypes = genericTypes; + } + + static PropertyMapping of(Class target, + FastBeanCopierPropertySupport.ClassProperty sourceProperty, + FastBeanCopierPropertySupport.ClassProperty targetProperty) { + return new PropertyMapping(sourceProperty.getName(), + createReader(sourceProperty), + createWriter(targetProperty), + sourceProperty.getType(), + targetProperty.getType(), + sourceProperty.isPrimitive(), + targetProperty.isPrimitive(), + resolveGenericTypes(target, targetProperty)); + } + + void copy(Object source, Object target, Set ignore, Converter converter) throws Throwable { + if (ignore.contains(name)) { + return; + } + Object value = reader.read(source); + if (value == null && !sourcePrimitive) { + return; + } + Object converted = convertValue(value, converter); + if (converted == null && !targetPrimitive) { + return; + } + writer.write(target, converted); + } + + private Object convertValue(Object value, Converter converter) { + if (value == null) { + return null; + } + value = unwrapEnumDictValue(value); + if (sourceType == targetType) { + if (Cloneable.class.isAssignableFrom(targetType)) { + Object cloned = tryClone(value); + if (cloned != null) { + return cloned; + } + } + if ((Map.class.isAssignableFrom(targetType) || Collection.class.isAssignableFrom(targetType)) + && genericTypes.length > 0) { + return converter.convert(value, (Class) targetType, genericTypes); + } + return value; + } + if (targetType == Object.class) { + return value; + } + if (isDirectAssignable(targetType, value)) { + return value; + } + return converter.convert(value, (Class) targetType, genericTypes); + } + + private Object unwrapEnumDictValue(Object value) { + if (!(value instanceof EnumDict)) { + return value; + } + if (targetType.isEnum()) { + return value; + } + if (isNumberType(targetType)) { + Object enumValue = ((EnumDict) value).getValue(); + return enumValue == null ? value : enumValue; + } + return value; + } + + private static boolean isDirectAssignable(Class targetType, Object value) { + if (value == null) { + return false; + } + if (targetType.isInstance(value)) { + return true; + } + if (targetType.isPrimitive()) { + Class wrapper = PRIMITIVE_WRAPPERS.get(targetType); + return wrapper != null && wrapper.isInstance(value); + } + return false; + } + + private static boolean isNumberType(Class targetType) { + if (Number.class.isAssignableFrom(targetType)) { + return true; + } + return targetType.isPrimitive() + && targetType != boolean.class + && targetType != char.class; + } + + private static Object tryClone(Object value) { + try { + if (value.getClass().isArray()) { + int length = Array.getLength(value); + Object clone = Array.newInstance(value.getClass().getComponentType(), length); + System.arraycopy(value, 0, clone, 0, length); + return clone; + } + Method clone = value.getClass().getMethod("clone"); + ReflectionUtils.makeAccessible(clone); + return clone.invoke(value); + } catch (Throwable ignore) { + return null; + } + } + + static ValueReader createReader(FastBeanCopierPropertySupport.ClassProperty property) { + if (Map.class.isAssignableFrom(property.getBeanType())) { + return source -> ((Map) source).get(property.getName()); + } + Method method = ReflectionUtils.findMethod(property.getBeanType(), property.getReadMethodName()); + if (method == null) { + throw new IllegalStateException("Read method not found: " + property.getBeanType() + "." + property.getReadMethodName()); + } + ReflectionUtils.makeAccessible(method); + return new MethodValueReader(method); + } + + static ValueWriter createWriter(FastBeanCopierPropertySupport.ClassProperty property) { + if (Map.class.isAssignableFrom(property.getBeanType())) { + return (target, value) -> ((Map) target).put(property.getName(), value); + } + Method method = ReflectionUtils.findMethod(property.getBeanType(), property.getWriteMethodName(), property.getType()); + if (method == null) { + throw new IllegalStateException("Write method not found: " + property.getBeanType() + "." + property.getWriteMethodName()); + } + ReflectionUtils.makeAccessible(method); + return new MethodValueWriter(method); + } + + private static Class[] resolveGenericTypes(Class target, + FastBeanCopierPropertySupport.ClassProperty property) { + if (Map.class.isAssignableFrom(property.getBeanType())) { + return FastBeanCopierSupport.EMPTY_CLASS_ARRAY; + } + Field field = ReflectionUtils.findField(target, property.getName()); + if (field == null) { + field = ReflectionUtils.findField(property.getBeanType(), property.getName()); + } + if (field == null) { + return FastBeanCopierSupport.EMPTY_CLASS_ARRAY; + } + Class[] arr = Arrays.stream(ResolvableType.forField(field).getGenerics()) + .map(ResolvableType::getRawClass) + .filter(Objects::nonNull) + .toArray(Class[]::new); + return arr.length == 0 ? FastBeanCopierSupport.EMPTY_CLASS_ARRAY : arr; + } + } + + static final class ExtensionMapping { + private final String name; + private final boolean primitive; + private final ValueReader reader; + + ExtensionMapping(FastBeanCopierPropertySupport.ClassProperty property) { + this.name = property.getName(); + this.primitive = property.isPrimitive(); + this.reader = PropertyMapping.createReader(property); + } + + void copy(Object source, Extendable target, Set ignore) throws Throwable { + if (ignore.contains(name)) { + return; + } + Object value = reader.read(source); + if (value == null && !primitive) { + return; + } + target.setExtension(name, value); + } + } + + interface ValueReader { + Object read(Object source) throws Throwable; + } + + interface ValueWriter { + void write(Object target, Object value) throws Throwable; + } + + static final class MethodValueReader implements ValueReader { + private final Method method; + + MethodValueReader(Method method) { + this.method = method; + } + + @Override + @SneakyThrows + public Object read(Object source) { + return method.invoke(source); + } + } + + static final class MethodValueWriter implements ValueWriter { + private final Method method; + + MethodValueWriter(Method method) { + this.method = method; + } + + @Override + @SneakyThrows + public void write(Object target, Object value) { + method.invoke(target, value); + } + } +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/ReflectionAccessorFastBeanCopierBackend.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/ReflectionAccessorFastBeanCopierBackend.java new file mode 100644 index 000000000..6837d5f5d --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/ReflectionAccessorFastBeanCopierBackend.java @@ -0,0 +1,10 @@ +package org.hswebframework.web.bean; + +import org.hswebframework.web.bean.accessor.ReflectionBeanAccessor; + +final class ReflectionAccessorFastBeanCopierBackend extends AccessorFastBeanCopierBackend { + + ReflectionAccessorFastBeanCopierBackend() { + super(new ReflectionBeanAccessor()); + } +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/AsmBeanAccessor.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/AsmBeanAccessor.java new file mode 100644 index 000000000..edf04d767 --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/AsmBeanAccessor.java @@ -0,0 +1,1098 @@ +package org.hswebframework.web.bean.accessor; + +import lombok.SneakyThrows; +import org.hswebframework.web.bean.Copier; +import org.hswebframework.web.bean.FastBeanCopierSupport; +import org.objectweb.asm.*; +import org.springframework.core.ResolvableType; + +import java.beans.BeanInfo; +import java.beans.Introspector; +import java.beans.PropertyDescriptor; +import java.lang.invoke.MethodHandles; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.concurrent.atomic.AtomicInteger; + +public class AsmBeanAccessor implements PropertyAccessor { + + private static final String PROPERTY_READER_INTERNAL_NAME = "org/hswebframework/web/bean/accessor/PropertyReader"; + private static final String CONVERTER_PROPERTY_TRANSFER_INTERNAL_NAME = "org/hswebframework/web/bean/accessor/ConverterPropertyTransfer"; + private static final String PROPERTY_TRANSFER_INTERNAL_NAME = "org/hswebframework/web/bean/accessor/PropertyTransfer"; + private static final String PROPERTY_WRITER_INTERNAL_NAME = "org/hswebframework/web/bean/accessor/PropertyWriter"; + private static final String COPIER_INTERNAL_NAME = "org/hswebframework/web/bean/Copier"; + private static final String BEAN_CONVERTER_INTERNAL_NAME = "org/hswebframework/web/bean/Converter"; + private static final String TYPE_CONVERTER_INTERNAL_NAME = "org/hswebframework/web/bean/accessor/TypeConverter"; + private static final String RESOLVABLE_TYPE_INTERNAL_NAME = "org/springframework/core/ResolvableType"; + private static final ClassLoader ACCESSOR_CLASS_LOADER = AsmBeanAccessor.class.getClassLoader(); + + private static final AtomicInteger COUNTER = new AtomicInteger(); + private final PropertyAccessor fallback = new ReflectionBeanAccessor(); + + public Copier createDirectCopier(Class sourceClass, Class targetClass) { + if (shouldUseFallback(sourceClass, targetClass)) { + return null; + } + try { + Map sourceProperties = findWritableReadableProperties(sourceClass, true); + Map targetProperties = findWritableReadableProperties(targetClass, false); + if (sourceProperties.isEmpty() || targetProperties.isEmpty()) { + return null; + } + Map mappings = new LinkedHashMap<>(); + for (PropertyDescriptor sourceProperty : sourceProperties.values()) { + PropertyDescriptor targetProperty = targetProperties.get(sourceProperty.getName()); + if (targetProperty == null) { + continue; + } + if (!canUseDirectCopier(sourceProperty, targetProperty)) { + return null; + } + mappings.put(sourceProperty, targetProperty); + } + if (mappings.isEmpty()) { + return null; + } + byte[] bytecode = createDirectCopierCode(sourceClass, targetClass, mappings); + Class generatedClass = defineClass(bytecode); + return (Copier) generatedClass.getDeclaredConstructor().newInstance(); + } catch (Throwable e) { + return null; + } + } + + @SneakyThrows + public byte[] createReaderCode(Class clazz, String name) { + PropertyDescriptor descriptor = findPropertyDescriptor(clazz, name); + if (descriptor == null || descriptor.getReadMethod() == null) { + throw new IllegalArgumentException("Property '" + name + "' not found or not readable in class " + clazz.getName()); + } + + Method readMethod = descriptor.getReadMethod(); + String className = generateClassName(clazz.getSimpleName() + "$" + name + "$Reader"); + + ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); + cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, null, "java/lang/Object", new String[]{PROPERTY_READER_INTERNAL_NAME}); + + // 默认构造函数 + MethodVisitor constructor = cw.visitMethod(Opcodes.ACC_PUBLIC, "", "()V", null, null); + constructor.visitCode(); + constructor.visitVarInsn(Opcodes.ALOAD, 0); + constructor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "", "()V", false); + constructor.visitInsn(Opcodes.RETURN); + constructor.visitMaxs(1, 1); + constructor.visitEnd(); + + // apply方法 + MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "apply", "(Ljava/lang/Object;)Ljava/lang/Object;", null, null); + mv.visitCode(); + + // 类型转换 + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(clazz)); + + // 调用getter方法 + mv.visitMethodInsn( + readMethod.getDeclaringClass().isInterface() ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL, + Type.getInternalName(readMethod.getDeclaringClass()), + readMethod.getName(), + Type.getMethodDescriptor(readMethod), + readMethod.getDeclaringClass().isInterface() + ); + + // 处理返回值 + Class returnType = readMethod.getReturnType(); + if (returnType.isPrimitive()) { + boxPrimitive(mv, returnType); + } + + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(2, 2); + mv.visitEnd(); + + cw.visitEnd(); + + return cw.toByteArray(); + } + + /** + * 创建用于访问指定类型属性的读取器，通过生成如下代码: + * 
{@code
+     *     PropertyReader{
+     *
+     *         Object apply(Object object){
+     *             return ((MyEntity)object).getName();
+     *         }
+     *
+     *     }
+     *
+     *  }
+ * + * @param clazz 类型 + * @param name 属性名称 + * @return PropertyReader + */ + public PropertyReader createReader(Class clazz, String name) { + if (shouldUseFallback(clazz)) { + return fallback.createReader(clazz, name); + } + try { + Class generatedClass = defineClass(createReaderCode(clazz, name)); + return (PropertyReader) generatedClass.getDeclaredConstructor().newInstance(); + } catch (Exception e) { + return fallback.createReader(clazz, name); + } + } + + public byte[] createWriterCode(Class clazz, String className, PropertyDescriptor descriptor, TypeConverter converter) { + if (descriptor == null || descriptor.getWriteMethod() == null) { + throw new IllegalArgumentException("Property '" + descriptor + "' not found or not writable in class " + clazz.getName()); + } + + Method writeMethod = descriptor.getWriteMethod(); + className = className.replace(".", "/"); + ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES); + cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, null, "java/lang/Object", new String[]{PROPERTY_WRITER_INTERNAL_NAME}); + + // 添加TypeConverter字段 + FieldVisitor fv = cw.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL, "typeConverter", "L" + TYPE_CONVERTER_INTERNAL_NAME + ";", null, null); + fv.visitEnd(); + + // 处理参数值类型 + Class paramType = writeMethod.getParameterTypes()[0]; + + // 预先计算ResolvableType并添加为字段 + String resolvableTypeField = null; + if (converter != null) { + resolvableTypeField = "resolvableType"; + FieldVisitor resolvableTypeFv = cw.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL, resolvableTypeField, "L" + RESOLVABLE_TYPE_INTERNAL_NAME + ";", null, null); + resolvableTypeFv.visitEnd(); + } + + // 构造函数 - 修改为直接接受TypeConverter和ResolvableType参数 + String constructorDescriptor = converter != null ? + "(L" + TYPE_CONVERTER_INTERNAL_NAME + ";L" + RESOLVABLE_TYPE_INTERNAL_NAME + ";)V" : + "(L" + TYPE_CONVERTER_INTERNAL_NAME + ";)V"; + + MethodVisitor constructor = cw.visitMethod(Opcodes.ACC_PUBLIC, "", constructorDescriptor, null, null); + constructor.visitCode(); + constructor.visitVarInsn(Opcodes.ALOAD, 0); + constructor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "", "()V", false); + + // 设置typeConverter字段 + constructor.visitVarInsn(Opcodes.ALOAD, 0); + constructor.visitVarInsn(Opcodes.ALOAD, 1); + constructor.visitFieldInsn(Opcodes.PUTFIELD, className, "typeConverter", "L" + TYPE_CONVERTER_INTERNAL_NAME + ";"); + + // 设置ResolvableType字段（直接从构造参数获取） + if (resolvableTypeField != null) { + constructor.visitVarInsn(Opcodes.ALOAD, 0); + constructor.visitVarInsn(Opcodes.ALOAD, 2); // ResolvableType参数 + constructor.visitFieldInsn(Opcodes.PUTFIELD, className, resolvableTypeField, "L" + RESOLVABLE_TYPE_INTERNAL_NAME + ";"); + } + + constructor.visitInsn(Opcodes.RETURN); + constructor.visitMaxs(2, 3); + constructor.visitEnd(); + + // accept方法 + MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "accept", "(Ljava/lang/Object;Ljava/lang/Object;)V", null, null); + mv.visitCode(); + + // 类型转换目标对象 + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(clazz)); + + if (converter != null) { + // 生成一个优化的类型转换器，调用辅助方法来处理类型检查 + // 先生成辅助方法 + generateOptimizedConvertMethod(cw, className, paramType, resolvableTypeField); + + // 在accept方法中调用辅助方法 + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, className, "convertValue", "(Ljava/lang/Object;)Ljava/lang/Object;", false); + + // 转换为目标类型 + if (paramType.isPrimitive()) { + unboxPrimitive(mv, paramType); + } else { + mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(paramType)); + } + + // 调用setter方法 + mv.visitMethodInsn( + writeMethod.getDeclaringClass().isInterface() ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL, + Type.getInternalName(writeMethod.getDeclaringClass()), + writeMethod.getName(), + Type.getMethodDescriptor(writeMethod), + writeMethod.getDeclaringClass().isInterface() + ); + + mv.visitInsn(Opcodes.RETURN); + } else { + // 直接类型转换 + mv.visitVarInsn(Opcodes.ALOAD, 2); + if (paramType.isPrimitive()) { + unboxPrimitive(mv, paramType); + } else { + mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(paramType)); + } + + // 调用setter方法 + mv.visitMethodInsn( + writeMethod.getDeclaringClass().isInterface() ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL, + Type.getInternalName(writeMethod.getDeclaringClass()), + writeMethod.getName(), + Type.getMethodDescriptor(writeMethod), + writeMethod.getDeclaringClass().isInterface() + ); + + mv.visitInsn(Opcodes.RETURN); + } + mv.visitMaxs(5, 4); + mv.visitEnd(); + + cw.visitEnd(); + + return cw.toByteArray(); + } + + /** + * 创建用于访问指定类型属性的写入器，通过生成如下代码: + * 
{@code
+     *     PropertyWriter{
+     *
+     *         void accept(Object o, Object o2){
+     *             ((MyEntity)o).setName( (String) o2 );
+     *         }
+     *
+     *     }
+     *
+     *  }
+ * + * @param clazz 类型 + * @param name 属性名称 + * @param typeConverter 类型转换器 + * @return PropertyWriter + */ + public PropertyWriter createWriter(Class clazz, String name, TypeConverter typeConverter) { + if (shouldUseFallback(clazz)) { + return fallback.createWriter(clazz, name, typeConverter); + } + try { + PropertyDescriptor descriptor = findPropertyDescriptor(clazz, name); + byte[] bytecode = createWriterCode(clazz, + generateClassName(clazz.getSimpleName() + "$" + descriptor.getName() + "$Writer"), + descriptor, + typeConverter); + Class generatedClass = defineClass(bytecode); + + // 预先计算ResolvableType，避免在构造方法中重复计算 + if (typeConverter != null) { + ResolvableType resolvableType = ResolvableType.forMethodParameter(descriptor.getWriteMethod(), 0); + return (PropertyWriter) generatedClass.getDeclaredConstructor(TypeConverter.class, ResolvableType.class) + .newInstance(typeConverter, resolvableType); + } else { + return (PropertyWriter) generatedClass.getDeclaredConstructor(TypeConverter.class) + .newInstance(typeConverter); + } + } catch (Throwable e) { + return fallback.createWriter(clazz, name, typeConverter); + } + } + + @Override + public PropertyTransfer createTransfer(Class sourceClass, + String sourceName, + boolean sourcePrimitive, + Class targetClass, + String targetName) { + if (shouldUseFallback(sourceClass, targetClass)) { + return fallback.createTransfer(sourceClass, sourceName, sourcePrimitive, targetClass, targetName); + } + try { + PropertyDescriptor sourceDescriptor = findPropertyDescriptor(sourceClass, sourceName); + PropertyDescriptor targetDescriptor = findPropertyDescriptor(targetClass, targetName); + if (sourceDescriptor == null + || sourceDescriptor.getReadMethod() == null + || targetDescriptor == null + || targetDescriptor.getWriteMethod() == null) { + return null; + } + byte[] bytecode = createTransferCode(sourceClass, + sourceDescriptor, + sourcePrimitive, + targetClass, + targetDescriptor); + Class generatedClass = defineClass(bytecode); + return (PropertyTransfer) generatedClass.getDeclaredConstructor().newInstance(); + } catch (Throwable e) { + return fallback.createTransfer(sourceClass, sourceName, sourcePrimitive, targetClass, targetName); + } + } + + @Override + public ConverterPropertyTransfer createConverterTransfer(Class sourceClass, + String sourceName, + boolean sourcePrimitive, + Class targetClass, + String targetName, + boolean allowDirectAssignment) { + if (shouldUseFallback(sourceClass, targetClass)) { + return fallback.createConverterTransfer(sourceClass, + sourceName, + sourcePrimitive, + targetClass, + targetName, + allowDirectAssignment); + } + try { + PropertyDescriptor sourceDescriptor = findPropertyDescriptor(sourceClass, sourceName); + PropertyDescriptor targetDescriptor = findPropertyDescriptor(targetClass, targetName); + if (sourceDescriptor == null + || sourceDescriptor.getReadMethod() == null + || targetDescriptor == null + || targetDescriptor.getWriteMethod() == null) { + return null; + } + byte[] bytecode = createConverterTransferCode(sourceClass, + sourceDescriptor, + sourcePrimitive, + targetClass, + targetDescriptor, + allowDirectAssignment); + Class generatedClass = defineClass(bytecode); + Class[] genericTypes = resolveGenericTypes( + ResolvableType.forMethodParameter(targetDescriptor.getWriteMethod(), 0, targetClass) + ); + return (ConverterPropertyTransfer) generatedClass.getDeclaredConstructor(Class[].class) + .newInstance((Object) genericTypes); + } catch (Throwable e) { + return fallback.createConverterTransfer(sourceClass, + sourceName, + sourcePrimitive, + targetClass, + targetName, + allowDirectAssignment); + } + } + + public byte[] createTransferCode(Class sourceClass, + PropertyDescriptor sourceDescriptor, + boolean sourcePrimitive, + Class targetClass, + PropertyDescriptor targetDescriptor) { + if (sourceDescriptor == null || sourceDescriptor.getReadMethod() == null) { + throw new IllegalArgumentException("Property '" + sourceDescriptor + "' not found or not readable in class " + sourceClass.getName()); + } + if (targetDescriptor == null || targetDescriptor.getWriteMethod() == null) { + throw new IllegalArgumentException("Property '" + targetDescriptor + "' not found or not writable in class " + targetClass.getName()); + } + + Method readMethod = sourceDescriptor.getReadMethod(); + Method writeMethod = targetDescriptor.getWriteMethod(); + Class readType = readMethod.getReturnType(); + Class targetParamType = writeMethod.getParameterTypes()[0]; + String className = generateClassName(sourceClass.getSimpleName() + + "$" + sourceDescriptor.getName() + + "$To$" + + targetClass.getSimpleName() + + "$" + targetDescriptor.getName() + + "$Transfer"); + + ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS); + cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, null, "java/lang/Object", new String[]{PROPERTY_TRANSFER_INTERNAL_NAME}); + + MethodVisitor constructor = cw.visitMethod(Opcodes.ACC_PUBLIC, "", "()V", null, null); + constructor.visitCode(); + constructor.visitVarInsn(Opcodes.ALOAD, 0); + constructor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "", "()V", false); + constructor.visitInsn(Opcodes.RETURN); + constructor.visitMaxs(1, 1); + constructor.visitEnd(); + + MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "transfer", "(Ljava/lang/Object;Ljava/lang/Object;)V", null, null); + mv.visitCode(); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(sourceClass)); + mv.visitMethodInsn(readMethod.getDeclaringClass().isInterface() ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL, + Type.getInternalName(readMethod.getDeclaringClass()), + readMethod.getName(), + Type.getMethodDescriptor(readMethod), + readMethod.getDeclaringClass().isInterface()); + + Label returnLabel = new Label(); + if (readType.isPrimitive()) { + mv.visitVarInsn(getStoreOpcode(readType), 3); + mv.visitVarInsn(Opcodes.ALOAD, 2); + mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(targetClass)); + mv.visitVarInsn(getLoadOpcode(readType), 3); + adaptPrimitiveValueForTarget(mv, readType, targetParamType); + } else { + mv.visitVarInsn(Opcodes.ASTORE, 3); + if (!sourcePrimitive) { + mv.visitVarInsn(Opcodes.ALOAD, 3); + mv.visitJumpInsn(Opcodes.IFNULL, returnLabel); + } + mv.visitVarInsn(Opcodes.ALOAD, 2); + mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(targetClass)); + mv.visitVarInsn(Opcodes.ALOAD, 3); + adaptReferenceValueForTarget(mv, targetParamType); + } + + mv.visitMethodInsn(writeMethod.getDeclaringClass().isInterface() ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL, + Type.getInternalName(writeMethod.getDeclaringClass()), + writeMethod.getName(), + Type.getMethodDescriptor(writeMethod), + writeMethod.getDeclaringClass().isInterface()); + mv.visitLabel(returnLabel); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + cw.visitEnd(); + return cw.toByteArray(); + } + + public byte[] createDirectCopierCode(Class sourceClass, + Class targetClass, + Map mappings) { + String className = generateClassName(sourceClass.getSimpleName() + + "$To$" + + targetClass.getSimpleName() + + "$DirectCopier"); + ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS); + cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, null, "java/lang/Object", new String[]{COPIER_INTERNAL_NAME}); + + MethodVisitor constructor = cw.visitMethod(Opcodes.ACC_PUBLIC, "", "()V", null, null); + constructor.visitCode(); + constructor.visitVarInsn(Opcodes.ALOAD, 0); + constructor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "", "()V", false); + constructor.visitInsn(Opcodes.RETURN); + constructor.visitMaxs(1, 1); + constructor.visitEnd(); + + MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, + "copy", + "(Ljava/lang/Object;Ljava/lang/Object;Ljava/util/Set;L" + BEAN_CONVERTER_INTERNAL_NAME + ";)V", + null, + null); + mv.visitCode(); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(sourceClass)); + mv.visitVarInsn(Opcodes.ASTORE, 5); + mv.visitVarInsn(Opcodes.ALOAD, 2); + mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(targetClass)); + mv.visitVarInsn(Opcodes.ASTORE, 6); + + Label withIgnore = new Label(); + Label end = new Label(); + mv.visitVarInsn(Opcodes.ALOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/util/Set", "isEmpty", "()Z", true); + mv.visitJumpInsn(Opcodes.IFEQ, withIgnore); + for (Map.Entry entry : mappings.entrySet()) { + generateDirectCopyStatement(mv, sourceClass, targetClass, entry.getKey(), entry.getValue(), false); + } + mv.visitJumpInsn(Opcodes.GOTO, end); + + mv.visitLabel(withIgnore); + for (Map.Entry entry : mappings.entrySet()) { + String name = entry.getKey().getName(); + Label next = new Label(); + mv.visitVarInsn(Opcodes.ALOAD, 3); + mv.visitLdcInsn(name); + mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/util/Set", "contains", "(Ljava/lang/Object;)Z", true); + mv.visitJumpInsn(Opcodes.IFNE, next); + generateDirectCopyStatement(mv, sourceClass, targetClass, entry.getKey(), entry.getValue(), true); + mv.visitLabel(next); + } + mv.visitLabel(end); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + cw.visitEnd(); + return cw.toByteArray(); + } + + public byte[] createConverterTransferCode(Class sourceClass, + PropertyDescriptor sourceDescriptor, + boolean sourcePrimitive, + Class targetClass, + PropertyDescriptor targetDescriptor, + boolean allowDirectAssignment) { + if (sourceDescriptor == null || sourceDescriptor.getReadMethod() == null) { + throw new IllegalArgumentException("Property '" + sourceDescriptor + "' not found or not readable in class " + sourceClass.getName()); + } + if (targetDescriptor == null || targetDescriptor.getWriteMethod() == null) { + throw new IllegalArgumentException("Property '" + targetDescriptor + "' not found or not writable in class " + targetClass.getName()); + } + + Method readMethod = sourceDescriptor.getReadMethod(); + Method writeMethod = targetDescriptor.getWriteMethod(); + Class readType = readMethod.getReturnType(); + Class targetParamType = writeMethod.getParameterTypes()[0]; + String className = generateClassName(sourceClass.getSimpleName() + + "$" + sourceDescriptor.getName() + + "$To$" + + targetClass.getSimpleName() + + "$" + targetDescriptor.getName() + + "$ConvertingTransfer"); + + ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS); + cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, null, "java/lang/Object", new String[]{CONVERTER_PROPERTY_TRANSFER_INTERNAL_NAME}); + FieldVisitor genericTypesField = cw.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL, + "genericTypes", + "[Ljava/lang/Class;", + null, + null); + genericTypesField.visitEnd(); + + MethodVisitor constructor = cw.visitMethod(Opcodes.ACC_PUBLIC, + "", + "([Ljava/lang/Class;)V", + null, + null); + constructor.visitCode(); + constructor.visitVarInsn(Opcodes.ALOAD, 0); + constructor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "", "()V", false); + constructor.visitVarInsn(Opcodes.ALOAD, 0); + constructor.visitVarInsn(Opcodes.ALOAD, 1); + constructor.visitFieldInsn(Opcodes.PUTFIELD, className, "genericTypes", "[Ljava/lang/Class;"); + constructor.visitInsn(Opcodes.RETURN); + constructor.visitMaxs(2, 2); + constructor.visitEnd(); + + generateTransferConvertMethod(cw, + className, + targetParamType, + allowDirectAssignment, + isNumberType(targetParamType)); + + MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, + "transfer", + "(Ljava/lang/Object;Ljava/lang/Object;L" + BEAN_CONVERTER_INTERNAL_NAME + ";)V", + null, + null); + mv.visitCode(); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(sourceClass)); + mv.visitMethodInsn(readMethod.getDeclaringClass().isInterface() ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL, + Type.getInternalName(readMethod.getDeclaringClass()), + readMethod.getName(), + Type.getMethodDescriptor(readMethod), + readMethod.getDeclaringClass().isInterface()); + + if (readType.isPrimitive()) { + boxPrimitive(mv, readType); + } + mv.visitVarInsn(Opcodes.ASTORE, 4); + + Label returnLabel = new Label(); + if (!sourcePrimitive) { + mv.visitVarInsn(Opcodes.ALOAD, 4); + mv.visitJumpInsn(Opcodes.IFNULL, returnLabel); + } + + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 4); + mv.visitVarInsn(Opcodes.ALOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, + className, + "convertValue", + "(Ljava/lang/Object;L" + BEAN_CONVERTER_INTERNAL_NAME + ";)Ljava/lang/Object;", + false); + mv.visitVarInsn(Opcodes.ASTORE, 4); + + if (!targetParamType.isPrimitive()) { + mv.visitVarInsn(Opcodes.ALOAD, 4); + mv.visitJumpInsn(Opcodes.IFNULL, returnLabel); + } + + mv.visitVarInsn(Opcodes.ALOAD, 2); + mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(targetClass)); + mv.visitVarInsn(Opcodes.ALOAD, 4); + adaptReferenceValueForTarget(mv, targetParamType); + mv.visitMethodInsn(writeMethod.getDeclaringClass().isInterface() ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL, + Type.getInternalName(writeMethod.getDeclaringClass()), + writeMethod.getName(), + Type.getMethodDescriptor(writeMethod), + writeMethod.getDeclaringClass().isInterface()); + mv.visitLabel(returnLabel); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + cw.visitEnd(); + return cw.toByteArray(); + } + + private PropertyDescriptor findPropertyDescriptor(Class clazz, String name) { + try { + BeanInfo beanInfo = Introspector.getBeanInfo(clazz); + for (PropertyDescriptor pd : beanInfo.getPropertyDescriptors()) { + if (name.equals(pd.getName())) { + return pd; + } + } + return null; + } catch (Exception e) { + throw new RuntimeException("Failed to find property descriptor for " + clazz.getName() + "." + name, e); + } + } + + private Map findWritableReadableProperties(Class clazz, boolean source) throws Exception { + BeanInfo beanInfo = Introspector.getBeanInfo(clazz); + Map properties = new LinkedHashMap<>(); + for (PropertyDescriptor property : beanInfo.getPropertyDescriptors()) { + if ("class".equals(property.getName())) { + continue; + } + if (source) { + if (property.getReadMethod() == null) { + continue; + } + } else if (property.getWriteMethod() == null) { + continue; + } + properties.put(property.getName(), property); + } + return properties; + } + + private String generateClassName(String prefix) { + return "org/hswebframework/web/bean/accessor/" + prefix + "$" + COUNTER.incrementAndGet(); + } + + private boolean canUseDirectCopier(PropertyDescriptor sourceProperty, PropertyDescriptor targetProperty) { + Method readMethod = sourceProperty.getReadMethod(); + Method writeMethod = targetProperty.getWriteMethod(); + if (readMethod == null || writeMethod == null) { + return false; + } + if (!Modifier.isPublic(readMethod.getModifiers()) || !Modifier.isPublic(writeMethod.getModifiers())) { + return false; + } + Class sourceType = readMethod.getReturnType(); + Class targetType = writeMethod.getParameterTypes()[0]; + return isDirectCompatible(sourceType, targetType); + } + + private boolean isDirectCompatible(Class sourceType, Class targetType) { + if (sourceType == targetType) { + return true; + } + if (sourceType.isPrimitive()) { + return getWrapperType(sourceType) == targetType || targetType == Object.class; + } + if (targetType.isPrimitive()) { + return getWrapperType(targetType) == sourceType; + } + return targetType.isAssignableFrom(sourceType); + } + + private boolean shouldClone(Class sourceType, Class targetType) { + return sourceType == targetType + && sourceType.isArray(); + } + + private void generateDirectCopyStatement(MethodVisitor mv, + Class sourceClass, + Class targetClass, + PropertyDescriptor sourceDescriptor, + PropertyDescriptor targetDescriptor, + boolean ignoreBranch) { + Method readMethod = sourceDescriptor.getReadMethod(); + Method writeMethod = targetDescriptor.getWriteMethod(); + Class sourceType = readMethod.getReturnType(); + Class targetType = writeMethod.getParameterTypes()[0]; + Label skip = new Label(); + + if (sourceType.isPrimitive()) { + mv.visitVarInsn(Opcodes.ALOAD, 6); + mv.visitVarInsn(Opcodes.ALOAD, 5); + mv.visitMethodInsn(readMethod.getDeclaringClass().isInterface() ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL, + Type.getInternalName(readMethod.getDeclaringClass()), + readMethod.getName(), + Type.getMethodDescriptor(readMethod), + readMethod.getDeclaringClass().isInterface()); + adaptPrimitiveValueForTarget(mv, sourceType, targetType); + mv.visitMethodInsn(writeMethod.getDeclaringClass().isInterface() ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL, + Type.getInternalName(writeMethod.getDeclaringClass()), + writeMethod.getName(), + Type.getMethodDescriptor(writeMethod), + writeMethod.getDeclaringClass().isInterface()); + return; + } + + mv.visitVarInsn(Opcodes.ALOAD, 5); + mv.visitMethodInsn(readMethod.getDeclaringClass().isInterface() ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL, + Type.getInternalName(readMethod.getDeclaringClass()), + readMethod.getName(), + Type.getMethodDescriptor(readMethod), + readMethod.getDeclaringClass().isInterface()); + mv.visitVarInsn(Opcodes.ASTORE, 7); + Label continueLabel = new Label(); + mv.visitVarInsn(Opcodes.ALOAD, 7); + mv.visitJumpInsn(Opcodes.IFNONNULL, continueLabel); + mv.visitJumpInsn(Opcodes.GOTO, skip); + mv.visitLabel(continueLabel); + + mv.visitVarInsn(Opcodes.ALOAD, 6); + if (shouldClone(sourceType, targetType)) { + mv.visitVarInsn(Opcodes.ALOAD, 7); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, + Type.getInternalName(AsmBeanAccessor.class), + "cloneValue", + "(Ljava/lang/Object;)Ljava/lang/Object;", + false); + } else { + mv.visitVarInsn(Opcodes.ALOAD, 7); + } + adaptReferenceValueForTarget(mv, targetType); + mv.visitMethodInsn(writeMethod.getDeclaringClass().isInterface() ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL, + Type.getInternalName(writeMethod.getDeclaringClass()), + writeMethod.getName(), + Type.getMethodDescriptor(writeMethod), + writeMethod.getDeclaringClass().isInterface()); + mv.visitLabel(skip); + } + + @SneakyThrows + private Class defineClass(byte[] bytes) { + // 使用 MethodHandles.Lookup 来定义类，这是 Java 17 推荐的方式 + MethodHandles.Lookup lookup = MethodHandles.lookup(); + return lookup.defineClass(bytes); + } + + @SneakyThrows + private Class defineClass(String className, byte[] bytes) { + // 对于复杂的字节码，使用类加载器来定义类 + ClassLoader classLoader = this.getClass().getClassLoader(); + java.lang.reflect.Method defineClassMethod = ClassLoader.class.getDeclaredMethod( + "defineClass", String.class, byte[].class, int.class, int.class); + defineClassMethod.setAccessible(true); + return (Class) defineClassMethod.invoke(classLoader, className.replace('/', '.'), bytes, 0, bytes.length); + } + + private void adaptPrimitiveValueForTarget(MethodVisitor mv, Class sourceType, Class targetType) { + if (targetType.isPrimitive()) { + return; + } + boxPrimitive(mv, sourceType); + if (targetType != Object.class) { + mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(targetType)); + } + } + + private void adaptReferenceValueForTarget(MethodVisitor mv, Class targetType) { + if (targetType.isPrimitive()) { + unboxPrimitive(mv, targetType); + return; + } + if (targetType != Object.class) { + mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(targetType)); + } + } + + private int getStoreOpcode(Class type) { + if (type == long.class) { + return Opcodes.LSTORE; + } + if (type == float.class) { + return Opcodes.FSTORE; + } + if (type == double.class) { + return Opcodes.DSTORE; + } + return Opcodes.ISTORE; + } + + private int getLoadOpcode(Class type) { + if (type == long.class) { + return Opcodes.LLOAD; + } + if (type == float.class) { + return Opcodes.FLOAD; + } + if (type == double.class) { + return Opcodes.DLOAD; + } + return Opcodes.ILOAD; + } + + private void boxPrimitive(MethodVisitor mv, Class primitiveType) { + if (primitiveType == boolean.class) { + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Boolean", "valueOf", "(Z)Ljava/lang/Boolean;", false); + } else if (primitiveType == byte.class) { + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Byte", "valueOf", "(B)Ljava/lang/Byte;", false); + } else if (primitiveType == short.class) { + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Short", "valueOf", "(S)Ljava/lang/Short;", false); + } else if (primitiveType == int.class) { + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Integer", "valueOf", "(I)Ljava/lang/Integer;", false); + } else if (primitiveType == long.class) { + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Long", "valueOf", "(J)Ljava/lang/Long;", false); + } else if (primitiveType == float.class) { + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Float", "valueOf", "(F)Ljava/lang/Float;", false); + } else if (primitiveType == double.class) { + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Double", "valueOf", "(D)Ljava/lang/Double;", false); + } else if (primitiveType == char.class) { + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Character", "valueOf", "(C)Ljava/lang/Character;", false); + } + } + + private void unboxPrimitive(MethodVisitor mv, Class primitiveType) { + if (primitiveType == boolean.class) { + mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Boolean"); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z", false); + } else if (primitiveType == byte.class) { + mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Number"); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Number", "byteValue", "()B", false); + } else if (primitiveType == short.class) { + mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Number"); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Number", "shortValue", "()S", false); + } else if (primitiveType == int.class) { + mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Number"); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Number", "intValue", "()I", false); + } else if (primitiveType == long.class) { + mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Number"); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Number", "longValue", "()J", false); + } else if (primitiveType == float.class) { + mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Number"); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Number", "floatValue", "()F", false); + } else if (primitiveType == double.class) { + mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Number"); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Number", "doubleValue", "()D", false); + } else if (primitiveType == char.class) { + mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Character"); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Character", "charValue", "()C", false); + } + } + + private Class getWrapperType(Class primitiveType) { + if (primitiveType == boolean.class) { + return Boolean.class; + } else if (primitiveType == byte.class) { + return Byte.class; + } else if (primitiveType == short.class) { + return Short.class; + } else if (primitiveType == int.class) { + return Integer.class; + } else if (primitiveType == long.class) { + return Long.class; + } else if (primitiveType == float.class) { + return Float.class; + } else if (primitiveType == double.class) { + return Double.class; + } else if (primitiveType == char.class) { + return Character.class; + } + return primitiveType; + } + + public static Object cloneValue(Object value) { + if (value == null) { + return null; + } + try { + if (value.getClass().isArray()) { + int length = java.lang.reflect.Array.getLength(value); + Object clone = java.lang.reflect.Array.newInstance(value.getClass().getComponentType(), length); + System.arraycopy(value, 0, clone, 0, length); + return clone; + } + Method clone = value.getClass().getMethod("clone"); + clone.setAccessible(true); + return clone.invoke(value); + } catch (Throwable ignore) { + return value; + } + } + + private void generateTransferConvertMethod(ClassWriter cw, + String className, + Class paramType, + boolean allowDirectAssignment, + boolean enumDictToNumber) { + MethodVisitor convertMv = cw.visitMethod(Opcodes.ACC_PRIVATE, + "convertValue", + "(Ljava/lang/Object;L" + BEAN_CONVERTER_INTERNAL_NAME + ";)Ljava/lang/Object;", + null, + null); + convertMv.visitCode(); + + Label convertLabel = new Label(); + + if (enumDictToNumber) { + convertMv.visitVarInsn(Opcodes.ALOAD, 1); + convertMv.visitTypeInsn(Opcodes.INSTANCEOF, "org/hswebframework/web/dict/EnumDict"); + Label skipEnumDictUnwrapLabel = new Label(); + convertMv.visitJumpInsn(Opcodes.IFEQ, skipEnumDictUnwrapLabel); + + convertMv.visitVarInsn(Opcodes.ALOAD, 1); + convertMv.visitTypeInsn(Opcodes.CHECKCAST, "org/hswebframework/web/dict/EnumDict"); + convertMv.visitMethodInsn(Opcodes.INVOKEINTERFACE, + "org/hswebframework/web/dict/EnumDict", + "getValue", + "()Ljava/lang/Object;", + true); + convertMv.visitVarInsn(Opcodes.ASTORE, 3); + convertMv.visitVarInsn(Opcodes.ALOAD, 3); + Label skipNullEnumValueLabel = new Label(); + convertMv.visitJumpInsn(Opcodes.IFNULL, skipNullEnumValueLabel); + convertMv.visitVarInsn(Opcodes.ALOAD, 3); + convertMv.visitVarInsn(Opcodes.ASTORE, 1); + convertMv.visitLabel(skipNullEnumValueLabel); + convertMv.visitLabel(skipEnumDictUnwrapLabel); + } + + if (allowDirectAssignment) { + convertMv.visitVarInsn(Opcodes.ALOAD, 1); + if (paramType.isPrimitive()) { + Class wrapperType = getWrapperType(paramType); + convertMv.visitTypeInsn(Opcodes.INSTANCEOF, Type.getInternalName(wrapperType)); + } else { + convertMv.visitTypeInsn(Opcodes.INSTANCEOF, Type.getInternalName(paramType)); + } + convertMv.visitJumpInsn(Opcodes.IFEQ, convertLabel); + convertMv.visitVarInsn(Opcodes.ALOAD, 1); + convertMv.visitInsn(Opcodes.ARETURN); + } + + convertMv.visitLabel(convertLabel); + convertMv.visitVarInsn(Opcodes.ALOAD, 2); + convertMv.visitVarInsn(Opcodes.ALOAD, 1); + convertMv.visitLdcInsn(Type.getType(paramType)); + convertMv.visitVarInsn(Opcodes.ALOAD, 0); + convertMv.visitFieldInsn(Opcodes.GETFIELD, className, "genericTypes", "[Ljava/lang/Class;"); + convertMv.visitMethodInsn(Opcodes.INVOKEINTERFACE, + BEAN_CONVERTER_INTERNAL_NAME, + "convert", + "(Ljava/lang/Object;Ljava/lang/Class;[Ljava/lang/Class;)Ljava/lang/Object;", + true); + convertMv.visitInsn(Opcodes.ARETURN); + convertMv.visitMaxs(0, 0); + convertMv.visitEnd(); + } + + private static boolean isNumberType(Class targetType) { + return Number.class.isAssignableFrom(targetType) + || (targetType.isPrimitive() && targetType != boolean.class && targetType != char.class); + } + + private static Class[] resolveGenericTypes(ResolvableType type) { + Class[] arr = java.util.Arrays.stream(type.getGenerics()) + .map(ResolvableType::getRawClass) + .filter(java.util.Objects::nonNull) + .toArray(Class[]::new); + return arr.length == 0 ? FastBeanCopierSupport.EMPTY_CLASS_ARRAY : arr; + } + + private boolean shouldUseFallback(Class... types) { + java.util.Map> names = new java.util.HashMap<>(); + for (Class type : types) { + Class actualType = normalizeType(type); + if (actualType.isPrimitive()) { + continue; + } + Class exists = names.putIfAbsent(actualType.getName(), actualType); + if (exists != null && exists != actualType) { + return true; + } + if (!isTypeVisible(actualType)) { + return true; + } + } + return false; + } + + private Class normalizeType(Class type) { + while (type.isArray()) { + type = type.getComponentType(); + } + return type; + } + + private boolean isTypeVisible(Class type) { + ClassLoader loader = type.getClassLoader(); + if (loader == null || loader == ACCESSOR_CLASS_LOADER) { + return true; + } + try { + return Class.forName(type.getName(), false, ACCESSOR_CLASS_LOADER) == type; + } catch (Throwable ignore) { + return false; + } + } + + /** + * 生成优化的类型转换方法 + */ + private void generateOptimizedConvertMethod(ClassWriter cw, String className, Class paramType, String resolvableTypeField) { + MethodVisitor convertMv = cw.visitMethod(Opcodes.ACC_PRIVATE, "convertValue", "(Ljava/lang/Object;)Ljava/lang/Object;", null, null); + convertMv.visitCode(); + + // 检查值是否为null + convertMv.visitVarInsn(Opcodes.ALOAD, 1); + Label nullLabel = new Label(); + convertMv.visitJumpInsn(Opcodes.IFNULL, nullLabel); + + // 类型检查 + convertMv.visitVarInsn(Opcodes.ALOAD, 1); + + if (paramType.isPrimitive()) { + // 基本类型需要检查对应的包装类型 + Class wrapperType = getWrapperType(paramType); + convertMv.visitTypeInsn(Opcodes.INSTANCEOF, Type.getInternalName(wrapperType)); + Label convertLabel = new Label(); + convertMv.visitJumpInsn(Opcodes.IFEQ, convertLabel); + + // 类型一致，直接返回 + convertMv.visitVarInsn(Opcodes.ALOAD, 1); + convertMv.visitInsn(Opcodes.ARETURN); + + // 类型不一致，需要转换 + convertMv.visitLabel(convertLabel); + } else { + // 对象类型直接检查 + convertMv.visitTypeInsn(Opcodes.INSTANCEOF, Type.getInternalName(paramType)); + Label convertLabel = new Label(); + convertMv.visitJumpInsn(Opcodes.IFEQ, convertLabel); + + // 类型一致，直接返回 + convertMv.visitVarInsn(Opcodes.ALOAD, 1); + convertMv.visitInsn(Opcodes.ARETURN); + + // 类型不一致，需要转换 + convertMv.visitLabel(convertLabel); + } + + // 调用TypeConverter进行转换 + convertMv.visitVarInsn(Opcodes.ALOAD, 0); + convertMv.visitFieldInsn(Opcodes.GETFIELD, className, "typeConverter", "L" + TYPE_CONVERTER_INTERNAL_NAME + ";"); + convertMv.visitVarInsn(Opcodes.ALOAD, 1); + + // 使用预先计算的ResolvableType字段 + convertMv.visitVarInsn(Opcodes.ALOAD, 0); + convertMv.visitFieldInsn(Opcodes.GETFIELD, className, resolvableTypeField, "L" + RESOLVABLE_TYPE_INTERNAL_NAME + ";"); + + convertMv.visitMethodInsn(Opcodes.INVOKEINTERFACE, TYPE_CONVERTER_INTERNAL_NAME, "convert", "(Ljava/lang/Object;L" + RESOLVABLE_TYPE_INTERNAL_NAME + ";)Ljava/lang/Object;", true); + convertMv.visitInsn(Opcodes.ARETURN); + + // 处理null值的情况 + convertMv.visitLabel(nullLabel); + convertMv.visitVarInsn(Opcodes.ALOAD, 0); + convertMv.visitFieldInsn(Opcodes.GETFIELD, className, "typeConverter", "L" + TYPE_CONVERTER_INTERNAL_NAME + ";"); + convertMv.visitInsn(Opcodes.ACONST_NULL); + convertMv.visitVarInsn(Opcodes.ALOAD, 0); + convertMv.visitFieldInsn(Opcodes.GETFIELD, className, resolvableTypeField, "L" + RESOLVABLE_TYPE_INTERNAL_NAME + ";"); + convertMv.visitMethodInsn(Opcodes.INVOKEINTERFACE, TYPE_CONVERTER_INTERNAL_NAME, "convert", "(Ljava/lang/Object;L" + RESOLVABLE_TYPE_INTERNAL_NAME + ";)Ljava/lang/Object;", true); + convertMv.visitInsn(Opcodes.ARETURN); + + convertMv.visitMaxs(4, 2); + convertMv.visitEnd(); + } +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/BeanAccessor.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/BeanAccessor.java new file mode 100644 index 000000000..90e595a77 --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/BeanAccessor.java @@ -0,0 +1,12 @@ +package org.hswebframework.web.bean.accessor; + +import java.util.function.BiPredicate; +import java.util.function.Predicate; + +public interface BeanAccessor { + + Object get(Object source, String property); + + void set(Object source, String property, Object value); + Object copy(Object source, Object target, BiPredicate filter); +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/ConverterPropertyTransfer.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/ConverterPropertyTransfer.java new file mode 100644 index 000000000..f45b757f8 --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/ConverterPropertyTransfer.java @@ -0,0 +1,15 @@ +package org.hswebframework.web.bean.accessor; + +import org.hswebframework.web.bean.Converter; + +/** + * 带类型转换的属性级 transfer。 + * + * @author zhouhao + * @since 5.0.2 + */ +@FunctionalInterface +public interface ConverterPropertyTransfer { + + void transfer(Object source, Object target, Converter converter); +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/PropertyAccessor.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/PropertyAccessor.java new file mode 100644 index 000000000..431356bf3 --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/PropertyAccessor.java @@ -0,0 +1,31 @@ +package org.hswebframework.web.bean.accessor; + +/** + * 属性访问器工厂，用于为指定属性创建 reader/writer。 + * + * @author zhouhao + * @since 5.0.2 + */ +public interface PropertyAccessor { + + PropertyReader createReader(Class clazz, String name); + + PropertyWriter createWriter(Class clazz, String name, TypeConverter typeConverter); + + default PropertyTransfer createTransfer(Class sourceClass, + String sourceName, + boolean sourcePrimitive, + Class targetClass, + String targetName) { + return null; + } + + default ConverterPropertyTransfer createConverterTransfer(Class sourceClass, + String sourceName, + boolean sourcePrimitive, + Class targetClass, + String targetName, + boolean allowDirectAssignment) { + return null; + } +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/PropertyReader.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/PropertyReader.java new file mode 100644 index 000000000..c1ccaeb06 --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/PropertyReader.java @@ -0,0 +1,17 @@ +package org.hswebframework.web.bean.accessor; + +import java.util.function.BiFunction; +import java.util.function.Function; + +/** + * 属性读取接口,用于获取一个对象中的属性 + * + * @author zhouhao + * @since 5.0.1 + */ +public interface PropertyReader extends Function { + + + Object apply(Object object); + +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/PropertyTransfer.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/PropertyTransfer.java new file mode 100644 index 000000000..b444542cd --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/PropertyTransfer.java @@ -0,0 +1,13 @@ +package org.hswebframework.web.bean.accessor; + +/** + * 属性级 transfer，用于直接将 source 属性复制到 target 属性。 + * + * @author zhouhao + * @since 5.0.2 + */ +@FunctionalInterface +public interface PropertyTransfer { + + void transfer(Object source, Object target); +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/PropertyWriter.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/PropertyWriter.java new file mode 100644 index 000000000..7ecb8736c --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/PropertyWriter.java @@ -0,0 +1,16 @@ +package org.hswebframework.web.bean.accessor; + +import reactor.function.Consumer3; + +import java.util.function.BiConsumer; + +/** + * 属性修改接口,用于修改一个对象中的属性 + * + * @author zhouhao + * @since 5.0.1 + */ +public interface PropertyWriter extends BiConsumer { + @Override + void accept(Object o, Object o2); +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/ReflectionBeanAccessor.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/ReflectionBeanAccessor.java new file mode 100644 index 000000000..fb1ec0541 --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/ReflectionBeanAccessor.java @@ -0,0 +1,519 @@ +package org.hswebframework.web.bean.accessor; + +import lombok.SneakyThrows; +import org.hswebframework.web.bean.Converter; +import org.hswebframework.web.dict.EnumDict; +import org.springframework.core.ResolvableType; + +import java.beans.BeanInfo; +import java.beans.Introspector; +import java.beans.PropertyDescriptor; +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodHandles; +import java.lang.invoke.VarHandle; +import java.lang.reflect.Field; +import java.lang.reflect.Method; + +/** + * 基于反射的Bean属性访问器 + *

+ * 智能选择访问策略： + *

    + *
  • 如果有getter/setter方法，使用MethodHandle（高性能）
    • + *
  • 如果没有getter/setter方法，使用VarHandle直接访问字段
    • + *
+ * + * @author AI Assistant + */ +public class ReflectionBeanAccessor implements PropertyAccessor { + + private static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup(); + + /** + * 创建属性读取器 + * + * @param clazz 目标类 + * @param name 属性名称 + * @return PropertyReader + */ + public PropertyReader createReader(Class clazz, String name) { + return createReaderInternal(clazz, name); + } + + /** + * 创建属性写入器 + * + * @param clazz 目标类 + * @param name 属性名称 + * @param typeConverter 类型转换器 + * @return PropertyWriter + */ + public PropertyWriter createWriter(Class clazz, String name, TypeConverter typeConverter) { + return createWriterInternal(clazz, name, typeConverter); + } + + @Override + public PropertyTransfer createTransfer(Class sourceClass, + String sourceName, + boolean sourcePrimitive, + Class targetClass, + String targetName) { + try { + PropertyDescriptor sourceDescriptor = findPropertyDescriptor(sourceClass, sourceName); + PropertyDescriptor targetDescriptor = findPropertyDescriptor(targetClass, targetName); + if (sourceDescriptor == null + || sourceDescriptor.getReadMethod() == null + || targetDescriptor == null + || targetDescriptor.getWriteMethod() == null) { + return null; + } + MethodHandle getter = LOOKUP.unreflect(sourceDescriptor.getReadMethod()); + MethodHandle setter = LOOKUP.unreflect(targetDescriptor.getWriteMethod()); + return new MethodHandlePropertyTransfer(getter, setter, sourcePrimitive); + } catch (Exception e) { + return null; + } + } + + @Override + public ConverterPropertyTransfer createConverterTransfer(Class sourceClass, + String sourceName, + boolean sourcePrimitive, + Class targetClass, + String targetName, + boolean allowDirectAssignment) { + try { + PropertyDescriptor sourceDescriptor = findPropertyDescriptor(sourceClass, sourceName); + PropertyDescriptor targetDescriptor = findPropertyDescriptor(targetClass, targetName); + if (sourceDescriptor == null + || sourceDescriptor.getReadMethod() == null + || targetDescriptor == null + || targetDescriptor.getWriteMethod() == null) { + return null; + } + Method setter = targetDescriptor.getWriteMethod(); + MethodHandle getter = LOOKUP.unreflect(sourceDescriptor.getReadMethod()); + MethodHandle writer = LOOKUP.unreflect(setter); + ResolvableType targetType = ResolvableType.forMethodParameter(setter, 0, targetClass); + Class[] genericTypes = resolveGenericTypes(targetType); + return new MethodHandleConverterPropertyTransfer(getter, + writer, + sourcePrimitive, + targetType.toClass(), + genericTypes, + allowDirectAssignment); + } catch (Exception e) { + return null; + } + } + + /** + * 内部方法：创建PropertyReader实例 + */ + private PropertyReader createReaderInternal(Class clazz, String name) { + try { + // 1. 首先尝试查找getter方法 + PropertyDescriptor descriptor = findPropertyDescriptor(clazz, name); + if (descriptor != null && descriptor.getReadMethod() != null) { + // 使用MethodHandle访问getter方法 + Method getter = descriptor.getReadMethod(); + MethodHandle methodHandle = LOOKUP.unreflect(getter); + return new MethodHandlePropertyReader(methodHandle); + } + + // 2. 如果没有getter方法，尝试使用VarHandle直接访问字段 + Field field = findField(clazz, name); + if (field != null) { + field.setAccessible(true); + try { + // 尝试使用提升权限的lookup访问私有字段 + MethodHandles.Lookup privateLookup = MethodHandles.privateLookupIn(clazz, LOOKUP); + VarHandle varHandle = privateLookup.unreflectVarHandle(field); + return new VarHandlePropertyReader(varHandle); + } catch (Exception e) { + // 如果VarHandle访问失败，回退到传统反射 + return new ReflectionFieldPropertyReader(field); + } + } + + throw new IllegalArgumentException("Property '" + name + "' not found or not readable in class " + clazz.getName()); + + } catch (Exception e) { + throw new RuntimeException("Failed to create PropertyReader for " + clazz.getName() + "." + name, e); + } + } + + /** + * 内部方法：创建PropertyWriter实例 + */ + private PropertyWriter createWriterInternal(Class clazz, String name, TypeConverter typeConverter) { + try { + // 1. 首先尝试查找setter方法 + PropertyDescriptor descriptor = findPropertyDescriptor(clazz, name); + if (descriptor != null && descriptor.getWriteMethod() != null) { + // 使用MethodHandle访问setter方法 + Method setter = descriptor.getWriteMethod(); + MethodHandle methodHandle = LOOKUP.unreflect(setter); + return new MethodHandlePropertyWriter(methodHandle, + ResolvableType.forMethodParameter(setter, 0, clazz), + typeConverter); + } + + // 2. 如果没有setter方法，尝试使用VarHandle直接访问字段 + Field field = findField(clazz, name); + if (field != null) { + field.setAccessible(true); + try { + // 尝试使用提升权限的lookup访问私有字段 + MethodHandles.Lookup privateLookup = MethodHandles.privateLookupIn(clazz, LOOKUP); + VarHandle varHandle = privateLookup.unreflectVarHandle(field); + return new VarHandlePropertyWriter(varHandle, field, typeConverter); + } catch (Exception e) { + // 如果VarHandle访问失败，回退到传统反射 + return new ReflectionFieldPropertyWriter(field, typeConverter); + } + } + + throw new IllegalArgumentException("Property '" + name + "' not found or not writable in class " + clazz.getName()); + + } catch (Exception e) { + throw new RuntimeException("Failed to create PropertyWriter for " + clazz.getName() + "." + name, e); + } + } + + /** + * 查找属性描述符 + */ + private PropertyDescriptor findPropertyDescriptor(Class clazz, String name) { + try { + BeanInfo beanInfo = Introspector.getBeanInfo(clazz); + PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors(); + for (PropertyDescriptor descriptor : descriptors) { + if (name.equals(descriptor.getName())) { + return descriptor; + } + } + } catch (Exception e) { + // 忽略异常，返回null + } + return null; + } + + /** + * 查找字段 + */ + private Field findField(Class clazz, String name) { + Class currentClass = clazz; + while (currentClass != null) { + try { + return currentClass.getDeclaredField(name); + } catch (NoSuchFieldException e) { + currentClass = currentClass.getSuperclass(); + } + } + return null; + } + + /** + * 基于MethodHandle的PropertyReader实现 + */ + private record MethodHandlePropertyReader(MethodHandle methodHandle) implements PropertyReader { + + @Override + public Object apply(Object target) { + try { + return methodHandle.invoke(target); + } catch (Throwable e) { + throw new RuntimeException("Failed to read property", e); + } + } + } + + /** + * 基于VarHandle的PropertyReader实现 + */ + private record VarHandlePropertyReader(VarHandle varHandle) implements PropertyReader { + + @Override + public Object apply(Object target) { + try { + return varHandle.get(target); + } catch (Exception e) { + throw new RuntimeException("Failed to read property", e); + } + } + } + + private static class MethodHandlePropertyTransfer implements PropertyTransfer { + private final MethodHandle reader; + private final MethodHandle writer; + private final boolean sourcePrimitive; + + private MethodHandlePropertyTransfer(MethodHandle reader, MethodHandle writer, boolean sourcePrimitive) { + this.reader = reader; + this.writer = writer; + this.sourcePrimitive = sourcePrimitive; + } + + @Override + @SneakyThrows + public void transfer(Object source, Object target) { + Object value = reader.invoke(source); + if (value == null && !sourcePrimitive) { + return; + } + writer.invoke(target, value); + } + } + + private static class MethodHandleConverterPropertyTransfer implements ConverterPropertyTransfer { + private final MethodHandle reader; + private final MethodHandle writer; + private final boolean sourcePrimitive; + private final boolean targetPrimitive; + private final boolean allowDirectAssignment; + private final Class targetType; + private final Class[] genericTypes; + + private MethodHandleConverterPropertyTransfer(MethodHandle reader, + MethodHandle writer, + boolean sourcePrimitive, + Class targetType, + Class[] genericTypes, + boolean allowDirectAssignment) { + this.reader = reader; + this.writer = writer; + this.sourcePrimitive = sourcePrimitive; + this.targetPrimitive = targetType.isPrimitive(); + this.allowDirectAssignment = allowDirectAssignment; + this.targetType = targetType; + this.genericTypes = genericTypes; + } + + @Override + @SneakyThrows + public void transfer(Object source, Object target, Converter converter) { + Object value = reader.invoke(source); + if (value == null && !sourcePrimitive) { + return; + } + if (value instanceof EnumDict && isNumberType(targetType)) { + Object enumValue = ((EnumDict) value).getValue(); + if (enumValue != null) { + value = enumValue; + } + } + if (!allowDirectAssignment || !isDirectAssignable(value)) { + value = converter.convert(value, targetType, genericTypes); + } + if (value == null && !targetPrimitive) { + return; + } + writer.invoke(target, value); + } + + private boolean isDirectAssignable(Object value) { + if (value == null) { + return false; + } + if (targetPrimitive) { + return resolveWrapperType(targetType).isInstance(value); + } + return targetType.isInstance(value); + } + } + + private static boolean isNumberType(Class targetType) { + return Number.class.isAssignableFrom(targetType) + || (targetType.isPrimitive() && targetType != boolean.class && targetType != char.class); + } + + private static Class[] resolveGenericTypes(ResolvableType type) { + Class[] arr = java.util.Arrays.stream(type.getGenerics()) + .map(ResolvableType::getRawClass) + .filter(java.util.Objects::nonNull) + .toArray(Class[]::new); + return arr.length == 0 ? org.hswebframework.web.bean.FastBeanCopierSupport.EMPTY_CLASS_ARRAY : arr; + } + + /** + * 基于MethodHandle的PropertyWriter实现 + */ + private static class MethodHandlePropertyWriter implements PropertyWriter { + private final MethodHandle methodHandle; + private final Class paramType; + private final TypeConverter typeConverter; + private final ResolvableType resolvableType; + + public MethodHandlePropertyWriter(MethodHandle methodHandle, ResolvableType type, TypeConverter typeConverter) { + this.methodHandle = methodHandle; + this.paramType = type.toClass(); + this.resolvableType = type; + this.typeConverter = typeConverter; + } + + @Override + @SneakyThrows + public void accept(Object target, Object value) { + + methodHandle.invoke(target, convertValue(value)); + + } + + private Object convertValue(Object value) { + if (value == null) { + return value; + } + if (paramType.isPrimitive()) { + Class wrapperType = resolveWrapperType(paramType); + if (wrapperType.isInstance(value)) { + return value; + } + } else if (paramType.isInstance(value)) { + return value; + } + if (typeConverter == null) { + return value; + } + return typeConverter.convert(value, resolvableType); + } + + } + + /** + * 基于VarHandle的PropertyWriter实现 + */ + private static class VarHandlePropertyWriter implements PropertyWriter { + private final VarHandle varHandle; + private final Field field; + private final ResolvableType resolvableType; + private final TypeConverter typeConverter; + + public VarHandlePropertyWriter(VarHandle varHandle, Field field, TypeConverter typeConverter) { + this.varHandle = varHandle; + this.field = field; + this.typeConverter = typeConverter; + this.resolvableType = ResolvableType.forField(field); + } + + @Override + public void accept(Object target, Object value) { + try { + Object convertedValue = convertValue(value); + varHandle.set(target, convertedValue); + } catch (Exception e) { + throw new RuntimeException("Failed to write property", e); + } + } + + private Object convertValue(Object value) { + if (value == null) { + return value; + } + if (field.getType().isPrimitive()) { + Class wrapperType = resolveWrapperType(field.getType()); + if (wrapperType.isInstance(value)) { + return value; + } + } else if (field.getType().isInstance(value)) { + return value; + } + if (typeConverter == null) { + return value; + } + return typeConverter.convert(value, resolvableType); + } + + } + + /** + * 基于传统反射的PropertyReader实现（VarHandle的后备方案） + */ + private static class ReflectionFieldPropertyReader implements PropertyReader { + private final Field field; + + public ReflectionFieldPropertyReader(Field field) { + this.field = field; + } + + @Override + public Object apply(Object target) { + try { + return field.get(target); + } catch (Exception e) { + throw new RuntimeException("Failed to read field", e); + } + } + } + + /** + * 基于传统反射的PropertyWriter实现（VarHandle的后备方案） + */ + private static class ReflectionFieldPropertyWriter implements PropertyWriter { + private final Field field; + private final ResolvableType fieldType; + private final TypeConverter typeConverter; + + public ReflectionFieldPropertyWriter(Field field, TypeConverter typeConverter) { + this.field = field; + this.fieldType = ResolvableType.forField(field); + this.typeConverter = typeConverter; + } + + @Override + @SneakyThrows + public void accept(Object target, Object value) { + + Object convertedValue = convertValue(value); + field.set(target, convertedValue); + + } + + private Object convertValue(Object value) { + if (value == null) { + return null; + } + if (field.getType().isPrimitive()) { + Class wrapperType = resolveWrapperType(field.getType()); + if (wrapperType.isInstance(value)) { + return value; + } + } else if (field.getType().isInstance(value)) { + return value; + } + if (typeConverter == null) { + return value; + } + return typeConverter.convert(value, fieldType); + } + + } + + private static Class resolveWrapperType(Class primitiveType) { + if (primitiveType == boolean.class) { + return Boolean.class; + } + if (primitiveType == byte.class) { + return Byte.class; + } + if (primitiveType == short.class) { + return Short.class; + } + if (primitiveType == int.class) { + return Integer.class; + } + if (primitiveType == long.class) { + return Long.class; + } + if (primitiveType == float.class) { + return Float.class; + } + if (primitiveType == double.class) { + return Double.class; + } + if (primitiveType == char.class) { + return Character.class; + } + return primitiveType; + } +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/SmartTypeConverter.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/SmartTypeConverter.java new file mode 100644 index 000000000..ed1d1d718 --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/SmartTypeConverter.java @@ -0,0 +1,357 @@ +package org.hswebframework.web.bean.accessor; + +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.beanutils.BeanUtilsBean; +import org.apache.commons.beanutils.ConvertUtilsBean; +import org.hswebframework.utils.time.DateFormatter; +import org.hswebframework.web.bean.ClassDescription; +import org.hswebframework.web.bean.ClassDescriptions; +import org.hswebframework.web.bean.FastBeanCopier; +import org.hswebframework.web.dict.EnumDict; +import org.hswebframework.web.utils.DynamicArrayList; +import org.springframework.core.ResolvableType; +import org.springframework.util.NumberUtils; + +import java.lang.reflect.Array; +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +/** + * 智能类型转换器，基于FastBeanCopier的DefaultConverter实现 + * + * @author zhouhao + * @since 5.0.1 + */ +@Slf4j +public class SmartTypeConverter implements TypeConverter { + + static final DateFormatter FORMATTER = Objects.requireNonNull( + DateFormatter.getFormatter("2025-07-05 10:49:32") + ); + + + public static final SmartTypeConverter INSTANCE = new SmartTypeConverter(); + + private static final ConvertUtilsBean convertUtils = BeanUtilsBean.getInstance().getConvertUtils(); + + @Override + public Object convert(Object source, ResolvableType type) { + if (source == null) { + return null; + } + + Class targetClass = type.toClass(); + if (targetClass == Object.class) { + return source; + } + + ClassDescription target = ClassDescriptions.getDescription(targetClass); + + // 处理枚举类型 + if (target.isEnumType()) { + return convertToEnum(source, target, type); + } + + // 处理基本类型转换 + if (targetClass == String.class) { + return convertToString(source); + } + + // 处理数字类型 + if (target.isNumber()) { + return convertToNumber(source, targetClass); + } + + // 处理Map类型 + if (target.isMapType()) { + return convertToMap(source, type); + } + + // 处理集合类型 + if (target.isCollectionType()) { + return convertToCollection(source, type); + } + + // 处理数组类型 + if (target.isArrayType()) { + return convertToArray(source, targetClass); + } + + if (targetClass == Date.class) { + return convertToDate(source); + } + + org.apache.commons.beanutils.Converter converter = convertUtils.lookup(targetClass); + if (converter != null) { + return converter.convert(targetClass, source); + } + // 处理Bean类型 + return convertToBean(source, targetClass); + } + + /** + * 转换为枚举类型 + */ + private Object convertToEnum(Object source, ClassDescription target, ResolvableType type) { + // 处理源对象本身为EnumDict的情况 + if (source instanceof EnumDict) { + Object val = ((EnumDict) source).getValue(); + if (target.getType().isInstance(val)) { + return val; + } + + return convert(val, type); + } + + String strVal = String.valueOf(source); + Object result = null; + + // 如果是EnumDict类型 + if (target.isEnumDict()) { + for (Object anEnum : target.getEnums()) { + EnumDict dic = (EnumDict) anEnum; + Enum e = (Enum) anEnum; + if (dic.eq(source) || e.name().equalsIgnoreCase(strVal)) { + result = anEnum; + break; + } + } + } else { + // 普通枚举类型 + for (Object e : target.getEnums()) { + Enum enumValue = (Enum) e; + if (enumValue.name().equalsIgnoreCase(strVal) || + Objects.equals(String.valueOf(enumValue.ordinal()), strVal)) { + result = e; + break; + } + } + } + + if (result == null) { + log.warn("can not converter: {} to:{}", source, type); + return null; + } + + if (type.toClass().isInstance(result)) { + return result; + } + + return convert(result,type); + } + + /** + * 转换为字符串类型 + */ + private String convertToString(Object source) { + if (source instanceof Date date) { + return FORMATTER.toString(date); + } + return String.valueOf(source); + } + + /** + * 转换为日期类型 + */ + private Date convertToDate(Object source) { + if (source instanceof String str) { + var parser = DateFormatter.getFormatter(str); + if (parser != null) { + return parser.format(str); + } + // 如果解析失败，尝试使用Apache Commons BeanUtils转换 + return convertByApache(Date.class, source); + } + + if (source instanceof Number) { + return new Date(((Number) source).longValue()); + } + + if (source instanceof Date) { + return new Date(((Date) source).getTime()); + } + + return null; + } + + /** + * 转换为集合类型 + */ + private Collection convertToCollection(Object source, ResolvableType type) { + var collection = createNewCollection(type.toClass()); + var sourceCollection = toSourceCollection(source); + var genericTypes = type.getGenerics(); + // 转换泛型元素 + if (genericTypes.length > 0 && genericTypes[0].toClass() != Object.class) { + for (Object sourceObj : sourceCollection) { + collection.add(convert(sourceObj, genericTypes[0])); + } + } else { + collection.addAll(sourceCollection); + } + + return collection; + } + + /** + * 创建新的集合实例 + */ + @SuppressWarnings("all") + private Collection createNewCollection(Class targetClass) { + if (targetClass == List.class) { + return new ArrayList<>(); + } else if (targetClass == ConcurrentHashMap.KeySetView.class) { + return ConcurrentHashMap.newKeySet(); + } else if (targetClass == Set.class) { + return new HashSet<>(); + } else if (targetClass == Queue.class) { + return new LinkedList<>(); + } else { + try { + return (Collection) targetClass.getDeclaredConstructor().newInstance(); + } catch (Throwable e) { + throw new UnsupportedOperationException("Unsupported Collection Type:" + targetClass, e); + } + } + } + + /** + * 将源对象转换为Collection + */ + private Collection toSourceCollection(Object source) { + if (source instanceof Collection) { + return (Collection) source; + } else if (source.getClass().isArray()) { + return new DynamicArrayList<>(source); + } else if (source instanceof Map) { + return ((Map) source).values(); + } else if (source instanceof String str) { + return Arrays.asList(str.split(",")); + } else { + return List.of(source); + } + } + + /** + * 转换为数组类型 + */ + private Object convertToArray(Object source, Class targetClass) { + var componentType = targetClass.getComponentType(); + var list = (List) convert(source, ResolvableType.forClassWithGenerics(List.class, componentType)); + int size = list.size(); + + var array = Array.newInstance(componentType, size); + for (int i = 0; i < size; i++) { + Array.set(array, i, list.get(i)); + } + return array; + } + + /** + * 转换为数字类型 + */ + private Object convertToNumber(Object source, Class targetClass) { + if (source instanceof String str) { + return NumberUtils.parseNumber(str, (Class) targetClass); + } + if (source instanceof Date) { + source = ((Date) source).getTime(); + } + return convertByApache(targetClass, source); + } + + /** + * 转换为Map类型 + */ + private Object convertToMap(Object source, ResolvableType type) { + Class targetClass = type.toClass(); + + if (source instanceof Map) { + return copyMap((Map) source, targetClass); + } + + if (source instanceof Collection) { + Map map = createNewMap(targetClass); + int i = 0; + for (Object obj : (Collection) source) { + Object key = i++; + Object value = obj; + + ResolvableType[] generics = type.getGenerics(); + if (generics.length >= 2) { + key = convert(key, generics[0]); + value = convert(value, generics[1]); + } + + map.put(key, value); + } + return map; + } + + // 将Bean转换为Map + return FastBeanCopier.copy(source, createNewMap(targetClass)); + } + + /** + * 创建新的Map实例 + */ + private Map createNewMap(Class targetClass) { + if (targetClass == TreeMap.class) { + return new TreeMap<>(); + } + if (targetClass == LinkedHashMap.class) { + return new LinkedHashMap<>(); + } + if (targetClass == ConcurrentHashMap.class) { + return new ConcurrentHashMap<>(); + } + if (targetClass == Map.class) { + return new HashMap<>(); + } + + // 尝试创建指定类型的Map + try { + return (Map) targetClass.getDeclaredConstructor().newInstance(); + } catch (Throwable e) { + // 如果无法创建，返回默认的HashMap + return new HashMap<>(); + } + } + + /** + * 复制Map + */ + private Map copyMap(Map map, Class targetClass) { + Map result = createNewMap(targetClass); + result.putAll(map); + return result; + } + + /** + * 转换为Bean类型 + */ + private Object convertToBean(Object source, Class targetClass) { + try { + Object target = targetClass.getDeclaredConstructor().newInstance(); + return FastBeanCopier.copy(source, target); + } catch (Throwable e) { + log.warn("Copy {} to {} failed", source, targetClass, e); + throw new RuntimeException("Convert to bean failed", e); + } + } + + /** + * 使用Apache Commons BeanUtils进行转换 + */ + private T convertByApache(Class targetClass, Object source) { + try { + org.apache.commons.beanutils.Converter converter = convertUtils.lookup(targetClass); + if (converter != null) { + return converter.convert(targetClass, source); + } + } catch (Exception e) { + log.warn("Apache converter failed for {} to {}", source, targetClass, e); + } + return null; + } +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/TypeConverter.java b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/TypeConverter.java new file mode 100644 index 000000000..ee9d87dda --- /dev/null +++ b/hsweb-core/src/main/java/org/hswebframework/web/bean/accessor/TypeConverter.java @@ -0,0 +1,19 @@ +package org.hswebframework.web.bean.accessor; + +import org.springframework.core.ResolvableType; + +/** + * 类型转换器，用于转换类型 + * + * @author zhouhao + * @since 5.0.1 + */ +public interface TypeConverter { + + static TypeConverter instance() { + return SmartTypeConverter.INSTANCE; + } + + Object convert(Object source, ResolvableType type); + +} diff --git a/hsweb-core/src/main/java/org/hswebframework/web/proxy/Proxy.java b/hsweb-core/src/main/java/org/hswebframework/web/proxy/Proxy.java index 254d47b9d..53fc9ca3b 100644 --- a/hsweb-core/src/main/java/org/hswebframework/web/proxy/Proxy.java +++ b/hsweb-core/src/main/java/org/hswebframework/web/proxy/Proxy.java @@ -123,7 +123,7 @@ public Proxy(Class superClass, Class[] classPaths, String... classPathStri if (classPaths != null) { for (Class classPath : classPaths) { if (classPath.getClassLoader() != null && - classPath.getClassLoader() != this.getClass().getClassLoader()) { + classPath.getClassLoader() != this.getClass().getClassLoader()) { loaders.add(classPath.getClassLoader()); } } @@ -184,12 +184,12 @@ public static MemberValue createMemberValue(Object value, ConstPool constPool) { } else if (value instanceof Object[]) { Object[] arr = ((Object[]) value); ArrayMemberValue arrayMemberValue = new ArrayMemberValue( - new ClassMemberValue(arr[0].getClass().getName(), constPool), constPool); + new ClassMemberValue(arr[0].getClass().getName(), constPool), constPool); arrayMemberValue.setValue( - Arrays - .stream(arr) - .map(o -> createMemberValue(o, constPool)) - .toArray(MemberValue[]::new)); + Arrays + .stream(arr) + .map(o -> createMemberValue(o, constPool)) + .toArray(MemberValue[]::new)); memberValue = arrayMemberValue; } diff --git a/hsweb-core/src/test/java/org/hswebframework/web/bean/FastBeanCopierBenchmarkSummary.md b/hsweb-core/src/test/java/org/hswebframework/web/bean/FastBeanCopierBenchmarkSummary.md new file mode 100644 index 000000000..b486004b6 --- /dev/null +++ b/hsweb-core/src/test/java/org/hswebframework/web/bean/FastBeanCopierBenchmarkSummary.md @@ -0,0 +1,233 @@ +# FastBeanCopier Benchmark Summary + +> 更新时间：2026-05-31 + +## 本轮实现摘要 + +本轮围绕默认 backend、缓存命中稳定性、跨 classloader 健壮性继续收口： + +- 默认 backend 切换为 `asm-accessor` +- 增加 `FastBeanCopierBackendSelector` +- 支持通过 `hsweb.fast-bean-copier.backend` 显式指定 backend +- 支持 native-image / disable-codegen 环境探测与 runtime backend 自动降级 +- 动态 classloader 场景统一回退到 `reflection-accessor` +- 热点缓存从 weak/soft 策略收口为**强命中优先** + - volatile copier cache 改为强缓存 + - `ClassDescriptions` / converter 子缓存改为按 classloader 分段的强缓存 + - `GenericKey` 泛型缓存改为强缓存 +- 对外暴露 `FastBeanCopier.clearCache()` / `clearCache(ClassLoader)` + +## 功能与健壮性验证 + +单元测试： + +```bash +mvn -pl hsweb-core -am -Dtest=FastBeanCopierSupportTest,FastBeanCopierTest -Dsurefire.failIfNoSpecifiedTests=false test +``` + +当前结果： + +- Tests run: `33` +- Failures: `0` +- Errors: `0` +- Skipped: `0` + +已覆盖/验证： + +- 默认 JVM 环境优先选择 `asm-accessor` +- native hint 环境优先选择 `reflection-accessor` +- backend 显式 override 生效 +- native / disable-codegen 下 effective backend 自动降级 +- 跨 classloader 复制兼容 +- 动态 classloader 使用 volatile cache + reflection fallback +- `clearCache(ClassLoader)` 可回收动态 loader 关联缓存并重建 copier +- 复杂对象 copy、异构 map -> bean、转换密集场景、集合密集场景、嵌套对象场景、extendable 场景兼容 + +## JMH 验证 + +执行命令： + +```bash +mvn -pl hsweb-core -q \ + -Dexec.classpathScope=test \ + -Dexec.mainClass=org.hswebframework.web.bean.FastBeanCopierJmhRunner \ + org.codehaus.mojo:exec-maven-plugin:3.5.0:java +``` + +结果文件： + +- `hsweb-core/target/jmh-results/fast-bean-copier.json` + +说明： + +- 当前这条命令在仓库内可以稳定跑通 **非 fork** JMH（当前 Runner 默认不显式设置 forks，沿用 benchmark 的 `@Fork(1)` 会受 `exec-maven-plugin` classpath 影响，见下文“已知限制”） +- 因此当前 JMH 结果适合做**同一进程内相对对比**，不应当作为跨环境绝对值结论 + +## 代表性结果（当前代码状态） + +单位：`us/op`，越小越好。 + +### simple bean -> bean + +- asm-accessor: `0.100` +- javassist: `0.102` +- reflection-accessor: `0.331` +- reflect: `0.573` + +### complex bean -> bean + +- javassist: `5.547` +- asm-accessor: `6.495` +- reflection-accessor: `8.125` +- reflect: `8.911` + +### bean -> map + +- asm-accessor: `0.908` +- reflection-accessor: `1.127` +- javassist: `1.851` +- reflect: `2.006` + +### heterogeneous map -> bean + +- asm-accessor: `7.429` +- reflection-accessor: `7.730` +- javassist: `8.426` +- reflect: `8.953` + +### conversion-heavy map -> bean + +- asm-accessor: `9.530` +- javassist: `9.785` +- reflection-accessor: `9.974` +- reflect: `11.011` + +### collection-heavy map -> bean + +- asm-accessor: `0.857` +- reflection-accessor: `0.889` +- javassist: `1.333` +- reflect: `1.530` + +### nested-heavy map -> bean + +- asm-accessor: `1.177` +- reflection-accessor: `1.241` +- javassist: `1.917` +- reflect: `1.995` + +### nested-only map -> bean + +- reflection-accessor: `0.811` +- asm-accessor: `0.832` +- javassist: `1.081` +- reflect: `1.254` + +### bean -> extendable + +- asm-accessor: `1.075` +- javassist: `1.128` +- reflection-accessor: `1.203` +- reflect: `1.511` + +### extendable -> map + +- reflection-accessor: `1.069` +- asm-accessor: `1.076` +- javassist: `1.128` +- reflect: `1.212` + +## 当前结论 + +### 1. 默认 backend 使用 `asm-accessor` 是合理的 + +从当前单测内场景 benchmark 与 JMH 一致看： + +- `simple bean -> bean`：`asm-accessor` 与 `javassist` 基本持平，略优 +- `bean -> map`、`heterogeneous map -> bean`、`conversion-heavy map -> bean`、`collection-heavy map -> bean`、`nested-heavy map -> bean`、`bean -> extendable`：`asm-accessor` 最优或并列最优 +- 仅 `complex bean -> bean` 单项上 `javassist` 仍领先，当前约 `1.17x` + +综合真实使用面，`asm-accessor` 仍是更合理的默认 backend。 + +### 2. 当前缓存策略更符合“性能优先” + +本轮关键变化不是单纯“多加缓存”，而是把原先容易因 GC 触发重建的缓存收口为： + +- 稳定 classloader：强缓存 +- 动态 classloader：强缓存命中 + `clearCache(ClassLoader)` 显式释放 + +这样做的收益： + +- 避免 weak/soft value 在内存波动下触发 copier / converter / enum lookup / class description 重建 +- 减少热路径吞吐抖动和尾延迟抖动 + +代价： + +- 如果宿主持续创建大量动态 classloader、又不调用 `clearCache(ClassLoader)`，缓存会增长 + +当前这个取舍更符合 FastBeanCopier 的定位：**优先稳定命中性能**。 + +### 3. 健壮性整体达标，但“受限反射环境”仍有边界 + +当前已验证： + +1. 普通 JVM：默认 `asm-accessor` +2. native-image / disable-codegen：自动降级到 `reflection-accessor` +3. 跨 classloader：动态 loader 下不再尝试 runtime codegen backend + +但仍需注意： + +- `FastBeanCopierConverterSupport#createCollectionFactory` 仍使用 `constructor.setAccessible(true)` +- `ReflectionBeanAccessor`、`AsmBeanAccessor` 也仍存在 `setAccessible(true)` / private access 路径 + +因此： + +- **codegen backend 已经规避 native / 动态 loader 风险** +- 但要宣称“完整 native image 适配完成”仍然证据不足 +- 当前更准确的结论应是：**native / 受限环境下已有稳定 fallback 基础，但还不是完整 AOT/Native 最终态** + +## 已知限制 + +### 1. forked JMH 仍不可直接用于当前 exec 运行方式 + +尝试： + +```bash +mvn -pl hsweb-core -q \ + -Dexec.classpathScope=test \ + -Dexec.mainClass=org.hswebframework.web.bean.FastBeanCopierJmhRunner \ + -Dhsweb.fast-bean-copier.jmh.include=copySimpleBean \ + -Dhsweb.fast-bean-copier.jmh.forks=1 \ + org.codehaus.mojo:exec-maven-plugin:3.5.0:java +``` + +会出现： + +- `ClassNotFoundException: org.openjdk.jmh.runner.ForkedMain` + +因此当前仓库内可信 JMH 证据仍然是： + +- `forks=0 / non-forked` 相对对比结果 + +### 2. 动态 classloader 缓存释放依赖显式清理 + +这是当前为保证命中性能做的主动取舍。 + +适合： + +- 常规应用 +- 少量动态 loader +- 宿主可在卸载插件/脚本/隔离模块时显式 `clearCache(loader)` + +不适合： + +- 极高频、大量、不可控动态 classloader 且宿主无法感知卸载时机的场景 + +## 后续优化建议 + +1. 修复 forked JMH 的 classpath，拿到更强的基准证据 +2. 继续减少受限环境下的 `setAccessible(true)` 依赖 +3. 若后续确实需要 native image 正式支持，补充： + - 反射 metadata + - AOT/static copier SPI + - 更严格的 native smoke test diff --git a/hsweb-core/src/test/java/org/hswebframework/web/bean/FastBeanCopierJmhBenchmark.java b/hsweb-core/src/test/java/org/hswebframework/web/bean/FastBeanCopierJmhBenchmark.java new file mode 100644 index 000000000..c7995d098 --- /dev/null +++ b/hsweb-core/src/test/java/org/hswebframework/web/bean/FastBeanCopierJmhBenchmark.java @@ -0,0 +1,550 @@ +package org.hswebframework.web.bean; + +import org.hswebframework.ezorm.core.DefaultExtendable; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.TearDown; +import org.openjdk.jmh.annotations.Threads; +import org.openjdk.jmh.annotations.Warmup; +import org.openjdk.jmh.infra.Blackhole; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Date; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@Warmup(iterations = 2, time = 300, timeUnit = TimeUnit.MILLISECONDS) +@Measurement(iterations = 3, time = 300, timeUnit = TimeUnit.MILLISECONDS) +@Threads(1) +@Fork(1) +public class FastBeanCopierJmhBenchmark { + + @Benchmark + public void copySimpleBean(BenchmarkState state, Blackhole blackhole) { + blackhole.consume(FastBeanCopierSupport.copy(state.simpleSource, new SimpleTarget())); + } + + @Benchmark + public void copyComplexBean(BenchmarkState state, Blackhole blackhole) { + blackhole.consume(FastBeanCopierSupport.copy(state.complexSource, new Target())); + } + + @Benchmark + public void copyBeanToMap(BenchmarkState state, Blackhole blackhole) { + blackhole.consume(FastBeanCopierSupport.copy(state.complexSource, new HashMap<>())); + } + + @Benchmark + public void copyHeterogeneousMapToBean(BenchmarkState state, Blackhole blackhole) { + blackhole.consume(FastBeanCopierSupport.copy(state.heterogeneousMap, new Target())); + } + + @Benchmark + public void copyConversionHeavyMapToBean(BenchmarkState state, Blackhole blackhole) { + blackhole.consume(FastBeanCopierSupport.copy(state.conversionHeavyMap, new Target())); + } + + @Benchmark + public void copyCollectionHeavyMapToBean(BenchmarkState state, Blackhole blackhole) { + blackhole.consume(FastBeanCopierSupport.copy(state.collectionHeavyMap, new Target())); + } + + @Benchmark + public void copyNestedHeavyMapToBean(BenchmarkState state, Blackhole blackhole) { + blackhole.consume(FastBeanCopierSupport.copy(state.nestedHeavyMap, new Target())); + } + + @Benchmark + public void copyNestedHeavyMapToBeanOnly(BenchmarkState state, Blackhole blackhole) { + blackhole.consume(FastBeanCopierSupport.copy(state.nestedOnlyMap, new NestedOnlyTarget())); + } + + @Benchmark + public void copyBeanToExtendable(BenchmarkState state, Blackhole blackhole) { + blackhole.consume(FastBeanCopierSupport.copy(state.complexSource, new BenchmarkExtendableEntity())); + } + + @Benchmark + public void copyExtendableToMap(BenchmarkState state, Blackhole blackhole) { + blackhole.consume(FastBeanCopierSupport.copy(state.extendableSource, new HashMap<>())); + } + + @State(Scope.Thread) + public static class BenchmarkState { + @Param({"javassist", "reflect", "reflection-accessor", "asm-accessor"}) + public String backend; + + private FastBeanCopierBackend originalBackend; + private SimpleSource simpleSource; + private Source complexSource; + private Map heterogeneousMap; + private Map conversionHeavyMap; + private Map collectionHeavyMap; + private Map nestedHeavyMap; + private Map nestedOnlyMap; + private BenchmarkExtendableEntity extendableSource; + + @Setup(Level.Trial) + public void setup() { + originalBackend = FastBeanCopierSupport.getBackend(); + FastBeanCopierSupport.setBackend(createBackend(backend)); + FastBeanCopierSupport.clearCache(); + + simpleSource = createSimpleSource(); + complexSource = createComplexSource(); + heterogeneousMap = createHeterogeneousMap(); + conversionHeavyMap = createConversionHeavyMap(); + collectionHeavyMap = createCollectionHeavyMap(); + nestedHeavyMap = createNestedHeavyMap(); + nestedOnlyMap = createNestedOnlyMap(); + extendableSource = FastBeanCopierSupport.copy(complexSource, new BenchmarkExtendableEntity()); + + warmupCache(); + } + + @TearDown(Level.Trial) + public void teardown() { + FastBeanCopierSupport.setBackend(originalBackend); + } + + private void warmupCache() { + FastBeanCopierSupport.copy(simpleSource, new SimpleTarget()); + FastBeanCopierSupport.copy(complexSource, new Target()); + FastBeanCopierSupport.copy(complexSource, new HashMap<>()); + FastBeanCopierSupport.copy(heterogeneousMap, new Target()); + FastBeanCopierSupport.copy(conversionHeavyMap, new Target()); + FastBeanCopierSupport.copy(collectionHeavyMap, new Target()); + FastBeanCopierSupport.copy(nestedHeavyMap, new Target()); + FastBeanCopierSupport.copy(nestedOnlyMap, new NestedOnlyTarget()); + FastBeanCopierSupport.copy(complexSource, new BenchmarkExtendableEntity()); + FastBeanCopierSupport.copy(extendableSource, new HashMap<>()); + } + + private FastBeanCopierBackend createBackend(String backend) { + if ("reflect".equalsIgnoreCase(backend)) { + return new ReflectFastBeanCopierBackend(); + } + if ("reflection-accessor".equalsIgnoreCase(backend)) { + return new ReflectionAccessorFastBeanCopierBackend(); + } + if ("asm-accessor".equalsIgnoreCase(backend)) { + return new AsmAccessorFastBeanCopierBackend(); + } + return new JavassistFastBeanCopierBackend(); + } + + private SimpleSource createSimpleSource() { + SimpleSource source = new SimpleSource(); + source.setName("simple-benchmark"); + source.setAge(18); + source.setEnabled(true); + source.setScore(88L); + source.setCreated(new Date(1715040000000L)); + return source; + } + + private Source createComplexSource() { + Source source = new Source(); + source.setName("benchmark"); + source.setIds(new String[]{"1", "2", "3"}); + source.setBoy(false); + source.setBoy2(true); + source.setBoy3(true); + source.setAge(100); + source.setAge2(2); + source.setAge3(3); + source.setDeleteTime(new Date(1715040000000L)); + source.setCreateTime(new Date(1715043600000L)); + source.setUpdateTime("2024-05-07 10:20:30"); + source.setNestObject(new NestObject("nest-1", 10, "1234567")); + source.setNestObjects(Arrays.asList( + new NestObject("nest-a", 1, "1234567"), + new NestObject("nest-b", 2, "1234567") + )); + Map nestedMap = new LinkedHashMap<>(); + nestedMap.put("name", "map-nest"); + nestedMap.put("age", 11); + source.setNestObject2(nestedMap); + source.setNestObject3(new NestObject("nest-3", 12, "1234567")); + source.setColor(Color.RED); + source.setColor2("RED"); + source.setColor3(Color.BLUE.getValue()); + source.setArr(Arrays.asList("2", "3")); + source.setArr4(Arrays.asList("4", "5")); + source.setArr2(new String[]{"6", "7"}); + source.setArr3(new String[]{"8", "9"}); + source.setArr5(new String[]{"10", "11"}); + source.setArr6(new String[]{"12", "13"}); + source.setArr7(new int[]{14, 15}); + source.setArr8(new int[]{16, 17}); + source.setColors(new Color[]{Color.BLUE, Color.RED}); + source.setSource("source-field"); + source.setTarget("target-field"); + return source; + } + + private Map createHeterogeneousMap() { + Map map = new LinkedHashMap<>(); + map.put("name", "heterogeneous"); + map.put("ids", Arrays.asList("1", "2", "3")); + map.put("boy", "true"); + map.put("boy2", Boolean.FALSE); + map.put("boy3", 1); + map.put("age", "123"); + map.put("age2", 456L); + map.put("age3", 789); + map.put("deleteTime", "2024-05-07 10:20:30"); + map.put("createTime", new Date(1715043600000L)); + map.put("updateTime", "2024-05-08 11:30:40"); + map.put("nestObject", new LinkedHashMap() {{ + put("name", "map-nest-1"); + put("age", "18"); + put("password", "1234567"); + }}); + map.put("nestObject2", new LinkedHashMap() {{ + put("name", "map-nest-2"); + put("age", 19); + }}); + map.put("nestObject3", new LinkedHashMap() {{ + put("name", "map-nest-3"); + put("age", 20); + put("password", "7654321"); + }}); + List> nestObjects = new ArrayList<>(); + nestObjects.add(new LinkedHashMap() {{ + put("name", "list-nest-1"); + put("age", "21"); + put("password", "1234567"); + }}); + nestObjects.add(new LinkedHashMap() {{ + put("name", "list-nest-2"); + put("age", 22); + put("password", "7654321"); + }}); + map.put("nestObjects", nestObjects); + map.put("color", Color.RED); + map.put("color2", "RED"); + map.put("color3", Color.BLUE.getValue()); + map.put("arr", Arrays.asList("31", "32")); + map.put("arr2", Arrays.asList("33", "34")); + map.put("arr3", new String[]{"35", "36"}); + map.put("arr4", Arrays.asList("37", "38")); + map.put("arr7", new int[]{39, 40}); + map.put("arr8", Arrays.asList("41", "42")); + map.put("colors", Arrays.asList("BLUE", "RED")); + return map; + } + + private Map createConversionHeavyMap() { + Map map = new LinkedHashMap<>(); + map.put("name", 123456); + map.put("ids", "alpha,beta,gamma"); + map.put("boy", "true"); + map.put("boy2", 1); + map.put("boy3", false); + map.put("age", "2048"); + map.put("age2", 4096L); + map.put("age3", 8192); + map.put("deleteTime", "2024-05-07 10:20:30"); + map.put("createTime", new Date(1715043600000L)); + map.put("updateTime", "2024-05-08 11:30:40"); + map.put("nestObject", new LinkedHashMap() {{ + put("name", 1001); + put("age", "28"); + put("password", "1234567"); + }}); + map.put("nestObject2", new LinkedHashMap() {{ + put("name", "map-nest-2"); + put("age", "29"); + }}); + map.put("nestObject3", new LinkedHashMap() {{ + put("name", "map-nest-3"); + put("age", 30); + put("password", "7654321"); + }}); + map.put("nestObjects", Arrays.asList( + new LinkedHashMap() {{ + put("name", "list-nest-1"); + put("age", "31"); + put("password", "1234567"); + }}, + new LinkedHashMap() {{ + put("name", "list-nest-2"); + put("age", 32); + put("password", "7654321"); + }} + )); + map.put("color", Color.RED); + map.put("color2", Color.RED.getText()); + map.put("color3", "BLUE"); + map.put("arr", "51,52"); + map.put("arr2", new String[]{"53", "54"}); + map.put("arr3", Arrays.asList("55", "56")); + map.put("arr4", new String[]{"57", "58"}); + map.put("arr7", Arrays.asList("59", "60")); + map.put("arr8", new int[]{61, 62}); + map.put("colors", new String[]{"BLUE", "RED"}); + return map; + } + + private Map createCollectionHeavyMap() { + Map map = new LinkedHashMap<>(); + map.put("name", "collection-heavy"); + map.put("ids", Arrays.asList("alpha", "beta")); + map.put("arr", new String[]{"1", "2"}); + map.put("arr2", Arrays.asList("3", "4")); + map.put("arr3", Arrays.asList(5, 6)); + map.put("arr4", Arrays.asList(7, 8)); + map.put("arr7", new long[]{9L, 10L}); + map.put("arr8", Arrays.asList(11, 12)); + map.put("colors", new Color[]{Color.BLUE, Color.RED}); + return map; + } + + private Map createNestedHeavyMap() { + Map map = new LinkedHashMap<>(); + map.put("name", "nested-heavy"); + map.put("nestObject", new LinkedHashMap() {{ + put("name", "nest-root"); + put("age", "31"); + put("password", "1234567"); + }}); + map.put("nestObject2", new LinkedHashMap() {{ + put("name", "nest-map"); + put("age", 32); + }}); + map.put("nestObject3", new LinkedHashMap() {{ + put("name", "nest-tail"); + put("age", "33"); + put("password", "7654321"); + }}); + map.put("nestObjects", Arrays.asList( + new LinkedHashMap() {{ + put("name", "nest-list-1"); + put("age", "34"); + put("password", "1234567"); + }}, + new LinkedHashMap() {{ + put("name", "nest-list-2"); + put("age", 35); + put("password", "7654321"); + }}, + new LinkedHashMap() {{ + put("name", "nest-list-3"); + put("age", "36"); + put("password", "1357246"); + }} + )); + map.put("color2", "红色"); + map.put("color3", "BLUE"); + return map; + } + + private Map createNestedOnlyMap() { + Map map = new LinkedHashMap<>(); + map.put("nestObject", new LinkedHashMap() {{ + put("name", "nest-root"); + put("age", "31"); + put("password", "1234567"); + }}); + map.put("nestObject2", new LinkedHashMap() {{ + put("name", "nest-map"); + put("age", 32); + }}); + map.put("nestObject3", new LinkedHashMap() {{ + put("name", "nest-tail"); + put("age", "33"); + put("password", "7654321"); + }}); + map.put("nestObjects", Arrays.asList( + new LinkedHashMap() {{ + put("name", "nest-list-1"); + put("age", "34"); + put("password", "1234567"); + }}, + new LinkedHashMap() {{ + put("name", "nest-list-2"); + put("age", 35); + put("password", "7654321"); + }}, + new LinkedHashMap() {{ + put("name", "nest-list-3"); + put("age", "36"); + put("password", "1357246"); + }} + )); + return map; + } + } + + public static class SimpleSource { + private String name; + private int age; + private boolean enabled; + private long score; + private Date created; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + public boolean isEnabled() { + return enabled; + } + + public void setEnabled(boolean enabled) { + this.enabled = enabled; + } + + public long getScore() { + return score; + } + + public void setScore(long score) { + this.score = score; + } + + public Date getCreated() { + return created; + } + + public void setCreated(Date created) { + this.created = created; + } + } + + public static class SimpleTarget { + private String name; + private int age; + private boolean enabled; + private long score; + private Date created; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + public boolean isEnabled() { + return enabled; + } + + public void setEnabled(boolean enabled) { + this.enabled = enabled; + } + + public long getScore() { + return score; + } + + public void setScore(long score) { + this.score = score; + } + + public Date getCreated() { + return created; + } + + public void setCreated(Date created) { + this.created = created; + } + } + + public static class BenchmarkExtendableEntity extends DefaultExtendable { + private String name; + private boolean boy2; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public boolean isBoy2() { + return boy2; + } + + public void setBoy2(boolean boy2) { + this.boy2 = boy2; + } + } + + public static class NestedOnlyTarget { + private NestObject nestObject; + private NestObject nestObject2; + private Map nestObject3; + private List> nestObjects; + + public NestObject getNestObject() { + return nestObject; + } + + public void setNestObject(NestObject nestObject) { + this.nestObject = nestObject; + } + + public NestObject getNestObject2() { + return nestObject2; + } + + public void setNestObject2(NestObject nestObject2) { + this.nestObject2 = nestObject2; + } + + public Map getNestObject3() { + return nestObject3; + } + + public void setNestObject3(Map nestObject3) { + this.nestObject3 = nestObject3; + } + + public List> getNestObjects() { + return nestObjects; + } + + public void setNestObjects(List> nestObjects) { + this.nestObjects = nestObjects; + } + } +} diff --git a/hsweb-core/src/test/java/org/hswebframework/web/bean/FastBeanCopierJmhRunner.java b/hsweb-core/src/test/java/org/hswebframework/web/bean/FastBeanCopierJmhRunner.java new file mode 100644 index 000000000..23ad2f917 --- /dev/null +++ b/hsweb-core/src/test/java/org/hswebframework/web/bean/FastBeanCopierJmhRunner.java @@ -0,0 +1,42 @@ +package org.hswebframework.web.bean; + +import org.openjdk.jmh.results.format.ResultFormatType; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.ChainedOptionsBuilder; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; + +public class FastBeanCopierJmhRunner { + + static final String INCLUDE_PROPERTY = "hsweb.fast-bean-copier.jmh.include"; + static final String FORKS_PROPERTY = "hsweb.fast-bean-copier.jmh.forks"; + + public static void main(String[] args) throws RunnerException, IOException { + Path moduleDir = Files.exists(Paths.get("hsweb-core", "pom.xml")) + ? Paths.get("hsweb-core") + : Paths.get("."); + Path resultDir = moduleDir.resolve("target").resolve("jmh-results"); + Files.createDirectories(resultDir); + Path resultFile = resultDir.resolve("fast-bean-copier.json"); + + ChainedOptionsBuilder builder = new OptionsBuilder() + .include(System.getProperty(INCLUDE_PROPERTY, FastBeanCopierJmhBenchmark.class.getSimpleName())) + .result(resultFile.toString()) + .resultFormat(ResultFormatType.JSON); + + int forks = Integer.getInteger(FORKS_PROPERTY, -1); + if (forks >= 0) { + builder.forks(forks); + } + + Options options = builder.build(); + + new Runner(options).run(); + } +} diff --git a/hsweb-core/src/test/java/org/hswebframework/web/bean/FastBeanCopierSupportTest.java b/hsweb-core/src/test/java/org/hswebframework/web/bean/FastBeanCopierSupportTest.java new file mode 100644 index 000000000..6f61b400a --- /dev/null +++ b/hsweb-core/src/test/java/org/hswebframework/web/bean/FastBeanCopierSupportTest.java @@ -0,0 +1,1124 @@ +package org.hswebframework.web.bean; + +import org.junit.Assert; +import org.junit.Test; +import org.springframework.util.ClassUtils; + +import java.io.File; +import java.io.IOException; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Arrays; +import java.util.Collections; +import java.util.Date; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.function.Consumer; +import java.util.function.Supplier; + +public class FastBeanCopierSupportTest { + + @Test + public void testSupportCopy() { + Source source = new Source(); + source.setName("support"); + source.setAge(18); + source.setColor(Color.RED); + + Target target = FastBeanCopierSupport.copy(source, new Target()); + Target facadeTarget = FastBeanCopier.copy(source, new Target()); + + Assert.assertEquals(facadeTarget.getName(), target.getName()); + Assert.assertEquals(facadeTarget.getAge(), target.getAge()); + Assert.assertEquals(facadeTarget.getColor(), target.getColor()); + Assert.assertEquals(facadeTarget.getColor2(), target.getColor2()); + } + + @Test + public void testSupportGetProperty() { + Source source = new Source(); + source.setAge(20); + + Assert.assertEquals(20, FastBeanCopierSupport.getProperty(source, "age")); + } + + @Test + public void testFacadeDelegatesToSupport() { + Source source = new Source(); + Target target = new Target(); + + Assert.assertNotSame(FastBeanCopierSupport.DEFAULT_CONVERT, FastBeanCopier.DEFAULT_CONVERT); + Assert.assertEquals( + FastBeanCopierSupport.DEFAULT_CONVERT.convert("123", Integer.class, FastBeanCopierSupport.EMPTY_CLASS_ARRAY), + FastBeanCopier.DEFAULT_CONVERT.convert("123", Integer.class, FastBeanCopier.EMPTY_CLASS_ARRAY) + ); + Assert.assertSame(FastBeanCopierSupport.getBackend(), FastBeanCopier.getBackend()); + Assert.assertTrue(FastBeanCopierSupport.getBackend() instanceof AsmAccessorFastBeanCopierBackend); + Assert.assertSame( + FastBeanCopierSupport.getCopier(source, target, true), + FastBeanCopier.getCopier(source, target, true) + ); + } + + +@Test +public void testDefaultBackendSelectorPrefersAsmOnJvm() { + System.clearProperty(FastBeanCopierBackendSelector.BACKEND_PROPERTY); + System.clearProperty(FastBeanCopierBackendSelector.NATIVE_HINT_PROPERTY); + System.clearProperty(FastBeanCopierBackendSelector.NATIVE_IMAGE_PROPERTY); + + FastBeanCopierBackend backend = FastBeanCopierBackendSelector.selectDefaultBackend(); + Assert.assertTrue(backend instanceof AsmAccessorFastBeanCopierBackend); +} + +@Test +public void testDefaultBackendSelectorFallsBackToReflectionForNativeHint() { + String previous = System.getProperty(FastBeanCopierBackendSelector.NATIVE_HINT_PROPERTY); + System.setProperty(FastBeanCopierBackendSelector.NATIVE_HINT_PROPERTY, "true"); + try { + FastBeanCopierBackend backend = FastBeanCopierBackendSelector.selectDefaultBackend(); + Assert.assertTrue(backend instanceof ReflectionAccessorFastBeanCopierBackend); + } finally { + if (previous == null) { + System.clearProperty(FastBeanCopierBackendSelector.NATIVE_HINT_PROPERTY); + } else { + System.setProperty(FastBeanCopierBackendSelector.NATIVE_HINT_PROPERTY, previous); + } + } +} + +@Test +public void testBackendSelectorSupportsExplicitOverride() { + String previous = System.getProperty(FastBeanCopierBackendSelector.BACKEND_PROPERTY); + System.setProperty(FastBeanCopierBackendSelector.BACKEND_PROPERTY, "javassist"); + try { + FastBeanCopierBackend backend = FastBeanCopierBackendSelector.selectDefaultBackend(); + Assert.assertTrue(backend instanceof JavassistFastBeanCopierBackend); + } finally { + if (previous == null) { + System.clearProperty(FastBeanCopierBackendSelector.BACKEND_PROPERTY); + } else { + System.setProperty(FastBeanCopierBackendSelector.BACKEND_PROPERTY, previous); + } + } +} + + @Test + public void testDefaultConverterSupportsGenericCollectionAndMapConversion() { + java.util.List list = FastBeanCopierSupport.DEFAULT_CONVERT.convert( + java.util.Arrays.asList("1", "2", "3"), + java.util.List.class, + new Class[]{Integer.class} + ); + Assert.assertEquals(java.util.Arrays.asList(1, 2, 3), list); + + java.util.Map map = FastBeanCopierSupport.DEFAULT_CONVERT.convert( + java.util.Arrays.asList("alpha", "beta"), + java.util.Map.class, + new Class[]{Integer.class, String.class} + ); + Assert.assertEquals("alpha", map.get(0)); + Assert.assertEquals("beta", map.get(1)); + + java.util.List second = FastBeanCopierSupport.DEFAULT_CONVERT.convert( + new String[]{"4", "5"}, + java.util.List.class, + new Class[]{Integer.class} + ); + Assert.assertEquals(java.util.Arrays.asList(4, 5), second); + } + + @Test + public void testAdditionalBackendCompatibility() { + FastBeanCopierBackend original = FastBeanCopierSupport.getBackend(); + try { + for (BackendCase backendCase : additionalBackends()) { + FastBeanCopierSupport.setBackend(backendCase.backend); + assertBackendCompatibility(backendCase.name); + } + } finally { + FastBeanCopierSupport.setBackend(original); + } + } + + @Test + public void testJavassistBackendCompatibility() { + FastBeanCopierBackend original = FastBeanCopierSupport.getBackend(); + try { + FastBeanCopierSupport.setBackend(new JavassistFastBeanCopierBackend()); + assertBackendCompatibility("javassist"); + } finally { + FastBeanCopierSupport.setBackend(original); + } + } + + @Test + public void testAccessorDirectTransferPreservesNullSkipSemantics() { + FastBeanCopierBackend original = FastBeanCopierSupport.getBackend(); + try { + List backends = Arrays.asList( + new BackendCase("reflection-accessor", new ReflectionAccessorFastBeanCopierBackend()), + new BackendCase("asm-accessor", new AsmAccessorFastBeanCopierBackend()) + ); + for (BackendCase backendCase : backends) { + FastBeanCopierSupport.setBackend(backendCase.backend); + Source source = new Source(); + source.setName(null); + source.setAge(33); + + Target target = new Target(); + target.setName("keep-me"); + target.setAge(1); + + FastBeanCopierSupport.copy(source, target); + + Assert.assertEquals(backendCase.name, "keep-me", target.getName()); + Assert.assertEquals(backendCase.name, 33, target.getAge()); + } + } finally { + FastBeanCopierSupport.setBackend(original); + } + } + + @Test + public void testCrossClassLoaderCompatibility() { + FastBeanCopierBackend original = FastBeanCopierSupport.getBackend(); + try { + for (BackendCase backendCase : benchmarkBackends()) { + FastBeanCopierSupport.setBackend(backendCase.backend); + assertCrossClassLoaderCompatibility(backendCase.name); + } + } finally { + FastBeanCopierSupport.setBackend(original); + } + } + + @Test + public void testDynamicClassLoaderUsesVolatileCacheAndReflectionFallback() throws Exception { + FastBeanCopierBackend original = FastBeanCopierSupport.getBackend(); + try (URLClassLoader loader = createTestClassLoader()) { + FastBeanCopierSupport.setBackend(new AsmAccessorFastBeanCopierBackend()); + FastBeanCopierSupport.clearCache(); + + Class sourceClass = loader.loadClass(Source.class.getName()); + Class targetClass = loader.loadClass(Target.class.getName()); + + Assert.assertTrue(FastBeanCopierSupport.usesVolatileClassLoader(sourceClass, targetClass)); + Assert.assertTrue(FastBeanCopierSupport.getEffectiveBackend(sourceClass, targetClass) + instanceof ReflectionAccessorFastBeanCopierBackend); + + Object source = sourceClass.getDeclaredConstructor().newInstance(); + FastBeanCopier.copy(createCrossClassLoaderSourceMap(), source); + Object target = targetClass.getDeclaredConstructor().newInstance(); + + Copier copier1 = FastBeanCopierSupport.getCopier(source, target, true); + Copier copier2 = FastBeanCopierSupport.getCopier(source, target, true); + + Assert.assertSame(copier1, copier2); + Assert.assertEquals(0, FastBeanCopierSupport.getStableCacheSize()); + Assert.assertEquals(2, FastBeanCopierSupport.getVolatileCacheSize()); + + FastBeanCopier.copy(source, target); + Map copied = FastBeanCopier.copy(target, new HashMap<>()); + Assert.assertEquals("cross-loader", copied.get("name")); + Assert.assertEquals(24, copied.get("age")); + } finally { + FastBeanCopierSupport.setBackend(original); + FastBeanCopierSupport.clearCache(); + } + } + + @Test + public void testClearCacheByClassLoaderRecreatesVolatileCopier() throws Exception { + FastBeanCopierBackend original = FastBeanCopierSupport.getBackend(); + try (URLClassLoader loader = createTestClassLoader()) { + FastBeanCopierSupport.setBackend(new AsmAccessorFastBeanCopierBackend()); + FastBeanCopierSupport.clearCache(); + + Class sourceClass = loader.loadClass(Source.class.getName()); + Class targetClass = loader.loadClass(Target.class.getName()); + Object source = sourceClass.getDeclaredConstructor().newInstance(); + Object target = targetClass.getDeclaredConstructor().newInstance(); + FastBeanCopier.copy(createCrossClassLoaderSourceMap(), source); + + Copier first = FastBeanCopierSupport.getCopier(source, target, true); + Assert.assertEquals(0, FastBeanCopierSupport.getStableCacheSize()); + Assert.assertEquals(2, FastBeanCopierSupport.getVolatileCacheSize()); + + FastBeanCopierSupport.clearCache(loader); + + Assert.assertEquals(0, FastBeanCopierSupport.getVolatileCacheSize()); + + Copier second = FastBeanCopierSupport.getCopier(source, target, true); + Assert.assertNotSame(first, second); + } finally { + FastBeanCopierSupport.setBackend(original); + FastBeanCopierSupport.clearCache(); + } + } + + @Test + public void testClearCacheByClassLoader() throws Exception { + FastBeanCopierBackend original = FastBeanCopierSupport.getBackend(); + try (URLClassLoader loader = createTestClassLoader()) { + FastBeanCopierSupport.setBackend(new ReflectionAccessorFastBeanCopierBackend()); + FastBeanCopierSupport.clearCache(); + + Class sourceClass = loader.loadClass(Source.class.getName()); + Class targetClass = loader.loadClass(Target.class.getName()); + Object source = sourceClass.getDeclaredConstructor().newInstance(); + Object target = targetClass.getDeclaredConstructor().newInstance(); + FastBeanCopier.copy(createCrossClassLoaderSourceMap(), source); + + FastBeanCopierSupport.getCopier(source, target, true); + FastBeanCopierSupport.DEFAULT_CONVERT.convert(Collections.singletonMap("name", "loader"), + targetClass, + FastBeanCopierSupport.EMPTY_CLASS_ARRAY); + + Assert.assertTrue(FastBeanCopierSupport.getVolatileCacheSize() > 0); + + FastBeanCopier.clearCache(loader); + + Assert.assertEquals(0, FastBeanCopierSupport.getVolatileCacheSize()); + + Copier recreated = FastBeanCopierSupport.getCopier(source, target, true); + Assert.assertNotNull(recreated); + } finally { + FastBeanCopierSupport.setBackend(original); + FastBeanCopierSupport.clearCache(); + } + } + + @Test + public void testAdditionalBackendComplexConversionCompatibility() { + FastBeanCopierBackend original = FastBeanCopierSupport.getBackend(); + try { + for (BackendCase backendCase : benchmarkBackends()) { + FastBeanCopierSupport.setBackend(backendCase.backend); + Target fromBean = FastBeanCopierSupport.copy(createComplexBenchmarkSource(), new Target()); + assertTargetCopied(createComplexBenchmarkSource(), fromBean); + + Target fromMap = FastBeanCopierSupport.copy(createHeterogeneousBenchmarkMap(), new Target()); + Assert.assertEquals(backendCase.name, "heterogeneous-benchmark", fromMap.getName()); + Assert.assertEquals(backendCase.name, Boolean.TRUE, fromMap.getBoy()); + Assert.assertFalse(backendCase.name, fromMap.isBoy2()); + Assert.assertEquals(backendCase.name, "1", fromMap.getBoy3()); + Assert.assertEquals(backendCase.name, 123, fromMap.getAge()); + Assert.assertEquals(backendCase.name, 456, fromMap.getAge2()); + Assert.assertEquals(backendCase.name, Color.BLUE, fromMap.getColor3()); + Assert.assertArrayEquals(backendCase.name, new long[]{39L, 40L}, fromMap.getArr7()); + assertNumberListEquals(backendCase.name, Arrays.asList(41, 42), fromMap.getArr8()); + Assert.assertNotNull(backendCase.name, fromMap.getNestObject()); + Assert.assertEquals(backendCase.name, "map-nest-1", fromMap.getNestObject().getName()); + } + } finally { + FastBeanCopierSupport.setBackend(original); + } + } + + @Test + public void testAdditionalBackendConversionHeavyMapCompatibility() { + FastBeanCopierBackend original = FastBeanCopierSupport.getBackend(); + try { + for (BackendCase backendCase : benchmarkBackends()) { + FastBeanCopierSupport.setBackend(backendCase.backend); + Target target = FastBeanCopierSupport.copy(createConversionHeavyBenchmarkMap(), new Target()); + Assert.assertEquals(backendCase.name, "123456", target.getName()); + Assert.assertArrayEquals(backendCase.name, new String[]{"alpha", "beta", "gamma"}, target.getIds()); + Assert.assertEquals(backendCase.name, Boolean.TRUE, target.getBoy()); + Assert.assertTrue(backendCase.name, target.isBoy2()); + Assert.assertEquals(backendCase.name, "false", target.getBoy3()); + Assert.assertEquals(backendCase.name, 2048, target.getAge()); + Assert.assertEquals(backendCase.name, 4096, target.getAge2()); + Assert.assertEquals(backendCase.name, "8192", target.getAge3()); + Assert.assertEquals(backendCase.name, 1, target.getColor()); + Assert.assertEquals(backendCase.name, Color.RED, target.getColor2()); + Assert.assertEquals(backendCase.name, Color.BLUE, target.getColor3()); + Assert.assertArrayEquals(backendCase.name, new String[]{"51", "52"}, target.getArr()); + Assert.assertArrayEquals(backendCase.name, new long[]{59L, 60L}, target.getArr7()); + assertNumberListEquals(backendCase.name, Arrays.asList(61, 62), target.getArr8()); + } + } finally { + FastBeanCopierSupport.setBackend(original); + } + } + + @Test + public void testAdditionalBackendCollectionHeavyMapCompatibility() { + FastBeanCopierBackend original = FastBeanCopierSupport.getBackend(); + try { + for (BackendCase backendCase : benchmarkBackends()) { + FastBeanCopierSupport.setBackend(backendCase.backend); + Target target = FastBeanCopierSupport.copy(createCollectionHeavyBenchmarkMap(), new Target()); + Assert.assertEquals(backendCase.name, "collection-heavy", target.getName()); + Assert.assertArrayEquals(backendCase.name, new String[]{"alpha", "beta"}, target.getIds()); + Assert.assertArrayEquals(backendCase.name, new String[]{"1", "2"}, target.getArr()); + Assert.assertEquals(backendCase.name, Arrays.asList("3", "4"), target.getArr2()); + Assert.assertArrayEquals(backendCase.name, new Integer[]{5, 6}, target.getArr3()); + Assert.assertArrayEquals(backendCase.name, new Integer[]{7, 8}, target.getArr4()); + Assert.assertArrayEquals(backendCase.name, new long[]{9L, 10L}, target.getArr7()); + assertNumberListEquals(backendCase.name, Arrays.asList(11, 12), target.getArr8()); + Assert.assertArrayEquals(backendCase.name, new Color[]{Color.BLUE, Color.RED}, target.getColors()); + } + } finally { + FastBeanCopierSupport.setBackend(original); + } + } + + @Test + public void testAdditionalBackendNestedHeavyMapCompatibility() { + FastBeanCopierBackend original = FastBeanCopierSupport.getBackend(); + try { + for (BackendCase backendCase : benchmarkBackends()) { + FastBeanCopierSupport.setBackend(backendCase.backend); + Target target = FastBeanCopierSupport.copy(createNestedHeavyBenchmarkMap(), new Target()); + Assert.assertEquals(backendCase.name, "nested-heavy", target.getName()); + Assert.assertNotNull(backendCase.name, target.getNestObject()); + Assert.assertEquals(backendCase.name, "nest-root", target.getNestObject().getName()); + Assert.assertEquals(backendCase.name, 31, target.getNestObject().getAge()); + Assert.assertNotNull(backendCase.name, target.getNestObject2()); + Assert.assertEquals(backendCase.name, "nest-map", target.getNestObject2().getName()); + Assert.assertEquals(backendCase.name, 32, target.getNestObject2().getAge()); + Assert.assertNotNull(backendCase.name, target.getNestObject3()); + Assert.assertEquals(backendCase.name, "nest-tail", String.valueOf(target.getNestObject3().get("name"))); + Assert.assertNotNull(backendCase.name, target.getNestObjects()); + Assert.assertEquals(backendCase.name, 3, target.getNestObjects().size()); + } + } finally { + FastBeanCopierSupport.setBackend(original); + } + } + + @Test + public void testBackendPerformanceComparison() { + Source source = createBenchmarkSource(); + int warmup = 5_000; + int iterations = 50_000; + + FastBeanCopierBackend original = FastBeanCopierSupport.getBackend(); + try { + List backends = benchmarkBackends(); + Map round1 = benchmarkBackends(backends, source, warmup, iterations); + List reversed = Arrays.asList( + backends.get(3), + backends.get(2), + backends.get(1), + backends.get(0) + ); + Map round2 = benchmarkBackends(reversed, source, warmup, iterations); + Map average = average(round1, round2); + BenchmarkResult javassist = average.get("javassist"); + + System.out.println("\n=== FastBeanCopier backend 性能对比 ==="); + System.out.println("预热次数: " + warmup + ", 正式迭代: " + iterations); + System.out.println("-- round1"); + round1.values().forEach(this::printBenchmark); + System.out.println("-- round2"); + round2.values().forEach(this::printBenchmark); + System.out.println("-- average"); + average.values().forEach(this::printBenchmark); + for (BenchmarkResult result : average.values()) { + if ("javassist".equals(result.name)) { + continue; + } + System.out.println("cached ratio (" + result.name + "/javassist): " + formatRatio(result.cachedWarmNanos, javassist.cachedWarmNanos)); + System.out.println("support ratio (" + result.name + "/javassist): " + formatRatio(result.supportWarmNanos, javassist.supportWarmNanos)); + System.out.println("cold create ratio (" + result.name + "/javassist): " + formatRatio(result.backendColdNanos, javassist.backendColdNanos)); + System.out.println("cold first copy ratio (" + result.name + "/javassist): " + formatRatio(result.supportColdNanos, javassist.supportColdNanos)); + } + + for (BenchmarkResult result : average.values()) { + Assert.assertTrue(result.cachedWarmNanos > 0); + Assert.assertTrue(result.supportWarmNanos > 0); + } + } finally { + FastBeanCopierSupport.setBackend(original); + } + } + + @Test + public void testBackendPerformanceAcrossScenarios() { + int warmup = 3_000; + int iterations = 20_000; + + FastBeanCopierBackend original = FastBeanCopierSupport.getBackend(); + try { + System.out.println("\n=== FastBeanCopier 多场景性能对比 ==="); + System.out.println("预热次数: " + warmup + ", 正式迭代: " + iterations); + for (BenchmarkScenario scenario : benchmarkScenarios()) { + System.out.println("-- scenario: " + scenario.name); + Map results = benchmarkScenarioBackends(scenario, warmup, iterations); + results.values().forEach(this::printScenarioBenchmark); + BenchmarkResult baseline = results.get("javassist"); + for (ScenarioBenchmarkResult result : results.values()) { + if ("javassist".equals(result.name)) { + continue; + } + System.out.println("cached ratio (" + result.name + "/javassist): " + formatRatio(result.cachedWarmNanos, baseline.cachedWarmNanos)); + System.out.println("support ratio (" + result.name + "/javassist): " + formatRatio(result.supportWarmNanos, baseline.supportWarmNanos)); + } + } + } finally { + FastBeanCopierSupport.setBackend(original); + } + } + + private long runCachedCopierBenchmark(Source source, Copier copier, int iterations) { + long start = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + copier.copy(source, new Target(), Collections.emptySet(), FastBeanCopierSupport.DEFAULT_CONVERT); + } + return System.nanoTime() - start; + } + + private long runSupportBenchmark(Source source, int iterations) { + long start = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + FastBeanCopierSupport.copy(source, new Target()); + } + return System.nanoTime() - start; + } + + private long runCachedCopierBenchmark(Object source, Supplier targetSupplier, Copier copier, int iterations) { + long start = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + copier.copy(source, targetSupplier.get(), Collections.emptySet(), FastBeanCopierSupport.DEFAULT_CONVERT); + } + return System.nanoTime() - start; + } + + private long runSupportBenchmark(Object source, Supplier targetSupplier, int iterations) { + long start = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + FastBeanCopierSupport.copy(source, targetSupplier.get()); + } + return System.nanoTime() - start; + } + + private long runBackendColdBenchmark(Source source, FastBeanCopierBackend backend) { + long start = System.nanoTime(); + Copier copier = backend.createCopier(Source.class, Target.class); + copier.copy(source, new Target(), Collections.emptySet(), FastBeanCopierSupport.DEFAULT_CONVERT); + return System.nanoTime() - start; + } + + private long runSupportColdBenchmark(Source source) { + FastBeanCopierSupport.clearCache(); + long start = System.nanoTime(); + FastBeanCopierSupport.copy(source, new Target()); + return System.nanoTime() - start; + } + + private BenchmarkResult benchmarkBackend(String name, + FastBeanCopierBackend backend, + Source source, + int warmup, + int iterations) { + FastBeanCopierSupport.setBackend(backend); + FastBeanCopierSupport.clearCache(); + Copier cachedCopier = FastBeanCopierSupport.getCopier(source, new Target(), true); + for (int i = 0; i < warmup; i++) { + cachedCopier.copy(source, new Target(), Collections.emptySet(), FastBeanCopierSupport.DEFAULT_CONVERT); + FastBeanCopierSupport.copy(source, new Target()); + } + return new BenchmarkResult(name, + runCachedCopierBenchmark(source, cachedCopier, iterations), + runSupportBenchmark(source, iterations), + runBackendColdBenchmark(source, backend), + runSupportColdBenchmark(source)); + } + + private Map benchmarkBackends(List backends, + Source source, + int warmup, + int iterations) { + Map results = new LinkedHashMap<>(); + for (BackendCase backend : backends) { + results.put(backend.name, benchmarkBackend(backend.name, backend.backend, source, warmup, iterations)); + } + return results; + } + + private Map benchmarkScenarioBackends(BenchmarkScenario scenario, + int warmup, + int iterations) { + Map results = new LinkedHashMap<>(); + for (BackendCase backend : benchmarkBackends()) { + FastBeanCopierSupport.setBackend(backend.backend); + FastBeanCopierSupport.clearCache(); + Object source = scenario.sourceSupplier.get(); + Object warmupTarget = scenario.targetSupplier.get(); + Copier copier = FastBeanCopierSupport.getCopier(source, warmupTarget, true); + for (int i = 0; i < warmup; i++) { + Object cachedResult = scenario.targetSupplier.get(); + copier.copy(source, + cachedResult, + Collections.emptySet(), + FastBeanCopierSupport.DEFAULT_CONVERT); + scenario.resultChecker.accept(cachedResult); + Object supportResult = FastBeanCopierSupport.copy(source, scenario.targetSupplier.get()); + scenario.resultChecker.accept(supportResult); + } + long cached = runCachedCopierBenchmark(source, scenario.targetSupplier, copier, iterations); + long support = runSupportBenchmark(source, scenario.targetSupplier, iterations); + results.put(backend.name, new ScenarioBenchmarkResult(scenario.name, backend.name, cached, support)); + } + return results; + } + + private Map average(Map first, + Map second) { + Map average = new LinkedHashMap<>(); + for (Map.Entry entry : first.entrySet()) { + average.put(entry.getKey(), BenchmarkResult.average(entry.getKey(), entry.getValue(), second.get(entry.getKey()))); + } + return average; + } + + private void printBenchmark(BenchmarkResult result) { + System.out.println(String.format(Locale.ROOT, + "%-18s cached=%8.2fms support=%8.2fms coldCreate=%8.3fms coldFirstCopy=%8.3fms", + result.name, + result.cachedWarmNanos / 1_000_000.0, + result.supportWarmNanos / 1_000_000.0, + result.backendColdNanos / 1_000_000.0, + result.supportColdNanos / 1_000_000.0)); + } + + private void printScenarioBenchmark(ScenarioBenchmarkResult result) { + System.out.println(String.format(Locale.ROOT, + "%-18s cached=%8.2fms support=%8.2fms", + result.name, + result.cachedWarmNanos / 1_000_000.0, + result.supportWarmNanos / 1_000_000.0)); + } + + private String formatRatio(long value, long base) { + return String.format(Locale.ROOT, "%.2fx", (double) value / (double) base); + } + + private void assertBackendCompatibility(String backendName) { + Source source = createBenchmarkSource(); + source.setIds(new String[]{"1", "2"}); + source.setArr2(new String[]{"1", "2"}); + source.setArr7(new int[]{1, 2}); + source.setColors(new Color[]{Color.BLUE, Color.RED}); + + Target target = FastBeanCopier.copy(source, new Target()); + assertTargetCopied(source, target); + Assert.assertArrayEquals(backendName, source.getIds(), target.getIds()); + Assert.assertNotSame(backendName, source.getIds(), target.getIds()); + Assert.assertArrayEquals(backendName, source.getColors(), target.getColors()); + Assert.assertNotSame(backendName, source.getColors(), target.getColors()); + + Map map = FastBeanCopier.copy(source, new HashMap<>()); + Assert.assertEquals(backendName, source.getName(), map.get("name")); + Assert.assertEquals(backendName, source.getAge(), map.get("age")); + + FastBeanCopierTest.ExtendableEntity extendable = FastBeanCopier.copy(source, new FastBeanCopierTest.ExtendableEntity()); + Assert.assertEquals(backendName, source.getName(), extendable.getName()); + Assert.assertEquals(backendName, source.getAge(), extendable.getExtension("age")); + Assert.assertEquals(backendName, source.getColor(), extendable.getExtension("color")); + } + + private void assertCrossClassLoaderCompatibility(String backendName) { + FastBeanCopierSupport.clearCache(); + try (URLClassLoader loader = createTestClassLoader()) { + Class sourceClass = loader.loadClass(Source.class.getName()); + Class targetClass = loader.loadClass(Target.class.getName()); + + Assert.assertNotSame(backendName, sourceClass, Source.class); + Assert.assertNotSame(backendName, targetClass, Target.class); + + Object source = sourceClass.getDeclaredConstructor().newInstance(); + FastBeanCopier.copy(createCrossClassLoaderSourceMap(), source); + + Map copiedFromSource = FastBeanCopier.copy(source, new HashMap<>()); + Assert.assertEquals(backendName, "cross-loader", copiedFromSource.get("name")); + Assert.assertEquals(backendName, 24, copiedFromSource.get("age")); + Assert.assertEquals(backendName, "RED", String.valueOf(copiedFromSource.get("color"))); + + Object target = targetClass.getDeclaredConstructor().newInstance(); + FastBeanCopier.copy(source, target); + + Map copiedFromTarget = FastBeanCopier.copy(target, new HashMap<>()); + Assert.assertEquals(backendName, "cross-loader", copiedFromTarget.get("name")); + Assert.assertEquals(backendName, 24, copiedFromTarget.get("age")); + Assert.assertEquals(backendName, "RED", String.valueOf(copiedFromTarget.get("color2"))); + Assert.assertEquals(backendName, "BLUE", String.valueOf(copiedFromTarget.get("color3"))); + + loader.close(); + Map copiedAfterClose = FastBeanCopier.copy(source, new HashMap<>()); + Assert.assertEquals(backendName, "cross-loader", copiedAfterClose.get("name")); + Assert.assertEquals(backendName, 24, copiedAfterClose.get("age")); + } catch (Exception e) { + throw new AssertionError("Cross classloader compatibility failed for backend: " + backendName, e); + } finally { + FastBeanCopierSupport.clearCache(); + } + } + + private Map createCrossClassLoaderSourceMap() { + Map values = new HashMap<>(); + values.put("name", "cross-loader"); + values.put("age", 24); + values.put("age2", 7); + values.put("color", "RED"); + values.put("color2", "红色"); + values.put("color3", Color.BLUE.getValue()); + values.put("arr7", new int[]{1, 2}); + values.put("arr8", new int[]{1, 2}); + return values; + } + + private URLClassLoader createTestClassLoader() throws IOException { + URL classes = new File("target/test-classes").getAbsoluteFile().toURI().toURL(); + return new URLClassLoader(new URL[]{classes}, ClassUtils.getDefaultClassLoader()) { + @Override + protected Class loadClass(String name, boolean resolve) throws ClassNotFoundException { + try { + Class type = loadSelfClass(name); + if (type != null) { + if (resolve) { + resolveClass(type); + } + return type; + } + } catch (Throwable ignore) { + // ignore + } + return super.loadClass(name, resolve); + } + + synchronized Class loadSelfClass(String name) throws ClassNotFoundException { + Class type = findLoadedClass(name); + if (type == null) { + type = findClass(name); + resolveClass(type); + } + return type; + } + + @Override + public Enumeration getResources(String name) throws IOException { + return findResources(name); + } + + @Override + public URL getResource(String name) { + return findResource(name); + } + }; + } + + private List additionalBackends() { + return Arrays.asList( + new BackendCase("reflect", new ReflectFastBeanCopierBackend()), + new BackendCase("reflection-accessor", new ReflectionAccessorFastBeanCopierBackend()), + new BackendCase("asm-accessor", new AsmAccessorFastBeanCopierBackend()) + ); + } + + private List benchmarkBackends() { + return Arrays.asList( + new BackendCase("javassist", new JavassistFastBeanCopierBackend()), + new BackendCase("reflect", new ReflectFastBeanCopierBackend()), + new BackendCase("reflection-accessor", new ReflectionAccessorFastBeanCopierBackend()), + new BackendCase("asm-accessor", new AsmAccessorFastBeanCopierBackend()) + ); + } + + private void assertTargetCopied(Source source, Target target) { + Assert.assertEquals(source.getName(), target.getName()); + Assert.assertEquals(source.getAge(), target.getAge()); + Assert.assertEquals(source.getAge2().intValue(), target.getAge2()); + Assert.assertEquals(source.getColor().getValue().intValue(), target.getColor()); + Assert.assertEquals(source.getColor(), target.getColor2()); + Assert.assertEquals(Color.BLUE, target.getColor3()); + Assert.assertArrayEquals(Arrays.stream(source.getArr7()).asLongStream().toArray(), target.getArr7()); + assertNumberListEquals("source", Arrays.stream(source.getArr8()).boxed().toList(), target.getArr8()); + } + + private void assertNumberListEquals(String message, List expected, List actual) { + Assert.assertNotNull(message, actual); + Assert.assertEquals(message, expected.size(), actual.size()); + for (int i = 0; i < expected.size(); i++) { + Object actualValue = actual.get(i); + int normalized = actualValue instanceof Number + ? ((Number) actualValue).intValue() + : Integer.parseInt(String.valueOf(actualValue)); + Assert.assertEquals(message + "[" + i + "]", + expected.get(i).intValue(), + normalized); + } + } + + private Source createBenchmarkSource() { + Source source = new Source(); + source.setName("benchmark"); + source.setAge(18); + source.setAge2(20); + source.setColor(Color.RED); + source.setColor2("红色"); + source.setColor3(Color.BLUE.getValue()); + source.setArr7(new int[]{1, 2}); + source.setArr8(new int[]{1, 2}); + return source; + } + + private Source createComplexBenchmarkSource() { + Source source = new Source(); + source.setName("complex-benchmark"); + source.setIds(new String[]{"11", "12", "13"}); + source.setBoy(true); + source.setBoy2(false); + source.setBoy3(true); + source.setAge(36); + source.setAge2(40); + source.setAge3(41); + source.setColor(Color.RED); + source.setColor2("RED"); + source.setColor3(Color.BLUE.getValue()); + source.setNestObject(new NestObject("nest-complex", 18, "1234567")); + source.setNestObject2(new LinkedHashMap<>()); + source.getNestObject2().put("name", "nest-map"); + source.getNestObject2().put("age", 19); + source.setNestObject3(new NestObject("nest-tail", 20, "7654321")); + source.setNestObjects(Arrays.asList( + new NestObject("nest-list-1", 21, "1234567"), + new NestObject("nest-list-2", 22, "7654321") + )); + source.setArr(Arrays.asList("1", "2", "3")); + source.setArr2(new String[]{"4", "5", "6"}); + source.setArr3(new String[]{"7", "8", "9"}); + source.setArr4(Arrays.asList("10", "11", "12")); + source.setArr5(new String[]{"13", "14"}); + source.setArr6(new String[]{"15", "16"}); + source.setArr7(new int[]{17, 18}); + source.setArr8(new int[]{19, 20}); + source.setColors(new Color[]{Color.BLUE, Color.RED}); + return source; + } + + private Map createHeterogeneousBenchmarkMap() { + Map map = new LinkedHashMap<>(); + map.put("name", "heterogeneous-benchmark"); + map.put("ids", Arrays.asList("101", "102", "103")); + map.put("boy", "true"); + map.put("boy2", Boolean.FALSE); + map.put("boy3", 1); + map.put("age", "123"); + map.put("age2", 456L); + map.put("age3", 789); + map.put("deleteTime", "2024-05-07 10:20:30"); + map.put("createTime", "2024-05-08 11:30:40"); + map.put("updateTime", "2024-05-09 12:40:50"); + map.put("nestObject", new LinkedHashMap() {{ + put("name", "map-nest-1"); + put("age", "18"); + put("password", "1234567"); + }}); + map.put("nestObject2", new LinkedHashMap() {{ + put("name", "map-nest-2"); + put("age", 19); + }}); + map.put("nestObject3", new LinkedHashMap() {{ + put("name", "map-nest-3"); + put("age", 20); + put("password", "7654321"); + }}); + map.put("nestObjects", Arrays.asList( + new LinkedHashMap() {{ + put("name", "list-nest-1"); + put("age", "21"); + put("password", "1234567"); + }}, + new LinkedHashMap() {{ + put("name", "list-nest-2"); + put("age", 22); + put("password", "7654321"); + }} + )); + map.put("color", Color.RED); + map.put("color2", "RED"); + map.put("color3", Color.BLUE.getValue()); + map.put("arr", Arrays.asList("31", "32")); + map.put("arr2", Arrays.asList("33", "34")); + map.put("arr3", new String[]{"35", "36"}); + map.put("arr4", Arrays.asList("37", "38")); + map.put("arr7", new int[]{39, 40}); + map.put("arr8", Arrays.asList("41", "42")); + map.put("colors", Arrays.asList("BLUE", "RED")); + return map; + } + + private Map createConversionHeavyBenchmarkMap() { + Map map = new LinkedHashMap<>(); + map.put("name", 123456); + map.put("ids", "alpha,beta,gamma"); + map.put("boy", "true"); + map.put("boy2", 1); + map.put("boy3", false); + map.put("age", "2048"); + map.put("age2", 4096L); + map.put("age3", 8192); + map.put("deleteTime", "2024-05-07 10:20:30"); + map.put("createTime", new Date(1715043600000L)); + map.put("updateTime", "2024-05-08 11:30:40"); + map.put("nestObject", new LinkedHashMap() {{ + put("name", 1001); + put("age", "28"); + put("password", "1234567"); + }}); + map.put("nestObject2", new LinkedHashMap() {{ + put("name", "map-nest-2"); + put("age", "29"); + }}); + map.put("nestObject3", new LinkedHashMap() {{ + put("name", "map-nest-3"); + put("age", 30); + put("password", "7654321"); + }}); + map.put("nestObjects", Arrays.asList( + new LinkedHashMap() {{ + put("name", "list-nest-1"); + put("age", "31"); + put("password", "1234567"); + }}, + new LinkedHashMap() {{ + put("name", "list-nest-2"); + put("age", 32); + put("password", "7654321"); + }} + )); + map.put("color", Color.RED); + map.put("color2", Color.RED.getText()); + map.put("color3", "BLUE"); + map.put("arr", "51,52"); + map.put("arr2", new String[]{"53", "54"}); + map.put("arr3", Arrays.asList("55", "56")); + map.put("arr4", new String[]{"57", "58"}); + map.put("arr7", Arrays.asList("59", "60")); + map.put("arr8", new int[]{61, 62}); + map.put("colors", new String[]{"BLUE", "RED"}); + return map; + } + + private Map createCollectionHeavyBenchmarkMap() { + Map map = new LinkedHashMap<>(); + map.put("name", "collection-heavy"); + map.put("ids", Arrays.asList("alpha", "beta")); + map.put("arr", new String[]{"1", "2"}); + map.put("arr2", Arrays.asList("3", "4")); + map.put("arr3", Arrays.asList(5, 6)); + map.put("arr4", Arrays.asList(7, 8)); + map.put("arr7", new long[]{9L, 10L}); + map.put("arr8", Arrays.asList(11, 12)); + map.put("colors", new Color[]{Color.BLUE, Color.RED}); + return map; + } + + private Map createNestedHeavyBenchmarkMap() { + Map map = new LinkedHashMap<>(); + map.put("name", "nested-heavy"); + map.put("nestObject", new LinkedHashMap() {{ + put("name", "nest-root"); + put("age", "31"); + put("password", "1234567"); + }}); + map.put("nestObject2", new LinkedHashMap() {{ + put("name", "nest-map"); + put("age", 32); + }}); + map.put("nestObject3", new LinkedHashMap() {{ + put("name", "nest-tail"); + put("age", "33"); + put("password", "7654321"); + }}); + map.put("nestObjects", Arrays.asList( + new LinkedHashMap() {{ + put("name", "nest-list-1"); + put("age", "34"); + put("password", "1234567"); + }}, + new LinkedHashMap() {{ + put("name", "nest-list-2"); + put("age", 35); + put("password", "7654321"); + }}, + new LinkedHashMap() {{ + put("name", "nest-list-3"); + put("age", "36"); + put("password", "1357246"); + }} + )); + map.put("color2", "红色"); + map.put("color3", "BLUE"); + return map; + } + + private List benchmarkScenarios() { + return Arrays.asList( + new BenchmarkScenario("simple-bean->bean", + () -> { + FastBeanCopierJmhBenchmark.SimpleSource source = new FastBeanCopierJmhBenchmark.SimpleSource(); + source.setName("simple-benchmark"); + source.setAge(18); + source.setEnabled(true); + source.setScore(88L); + source.setCreated(new java.util.Date(1715040000000L)); + return source; + }, + FastBeanCopierJmhBenchmark.SimpleTarget::new, + result -> Assert.assertNotNull(((FastBeanCopierJmhBenchmark.SimpleTarget) result).getName())), + new BenchmarkScenario("complex-bean->bean", + this::createComplexBenchmarkSource, + Target::new, + result -> assertTargetCopied(createComplexBenchmarkSource(), (Target) result)), + new BenchmarkScenario("heterogeneous-map->bean", + this::createHeterogeneousBenchmarkMap, + Target::new, + result -> { + Target target = (Target) result; + Assert.assertEquals("heterogeneous-benchmark", target.getName()); + Assert.assertEquals(Boolean.TRUE, target.getBoy()); + Assert.assertFalse(target.isBoy2()); + Assert.assertEquals("1", target.getBoy3()); + Assert.assertEquals(123, target.getAge()); + Assert.assertEquals(456, target.getAge2()); + Assert.assertEquals(Color.BLUE, target.getColor3()); + Assert.assertArrayEquals(new long[]{39L, 40L}, target.getArr7()); + assertNumberListEquals("heterogeneous-map->bean", Arrays.asList(41, 42), target.getArr8()); + }), + new BenchmarkScenario("conversion-heavy-map->bean", + this::createConversionHeavyBenchmarkMap, + Target::new, + result -> { + Target target = (Target) result; + Assert.assertEquals("123456", target.getName()); + Assert.assertArrayEquals(new String[]{"alpha", "beta", "gamma"}, target.getIds()); + Assert.assertEquals(Boolean.TRUE, target.getBoy()); + Assert.assertTrue(target.isBoy2()); + Assert.assertEquals("false", target.getBoy3()); + Assert.assertEquals(2048, target.getAge()); + Assert.assertEquals(4096, target.getAge2()); + Assert.assertEquals("8192", target.getAge3()); + Assert.assertEquals(1, target.getColor()); + Assert.assertEquals(Color.RED, target.getColor2()); + Assert.assertEquals(Color.BLUE, target.getColor3()); + Assert.assertArrayEquals(new String[]{"51", "52"}, target.getArr()); + Assert.assertArrayEquals(new long[]{59L, 60L}, target.getArr7()); + assertNumberListEquals("conversion-heavy-map->bean", Arrays.asList(61, 62), target.getArr8()); + }), + new BenchmarkScenario("collection-heavy-map->bean", + this::createCollectionHeavyBenchmarkMap, + Target::new, + result -> { + Target target = (Target) result; + Assert.assertEquals("collection-heavy", target.getName()); + Assert.assertArrayEquals(new String[]{"alpha", "beta"}, target.getIds()); + Assert.assertArrayEquals(new String[]{"1", "2"}, target.getArr()); + Assert.assertEquals(Arrays.asList("3", "4"), target.getArr2()); + Assert.assertArrayEquals(new Integer[]{5, 6}, target.getArr3()); + Assert.assertArrayEquals(new Integer[]{7, 8}, target.getArr4()); + Assert.assertArrayEquals(new long[]{9L, 10L}, target.getArr7()); + assertNumberListEquals("collection-heavy-map->bean", Arrays.asList(11, 12), target.getArr8()); + Assert.assertArrayEquals(new Color[]{Color.BLUE, Color.RED}, target.getColors()); + }), + new BenchmarkScenario("nested-heavy-map->bean", + this::createNestedHeavyBenchmarkMap, + Target::new, + result -> { + Target target = (Target) result; + Assert.assertEquals("nested-heavy", target.getName()); + Assert.assertNotNull(target.getNestObject()); + Assert.assertEquals("nest-root", target.getNestObject().getName()); + Assert.assertEquals(31, target.getNestObject().getAge()); + Assert.assertNotNull(target.getNestObject2()); + Assert.assertEquals("nest-map", target.getNestObject2().getName()); + Assert.assertEquals(32, target.getNestObject2().getAge()); + Assert.assertNotNull(target.getNestObject3()); + Assert.assertEquals("nest-tail", String.valueOf(target.getNestObject3().get("name"))); + Assert.assertNotNull(target.getNestObjects()); + Assert.assertEquals(3, target.getNestObjects().size()); + }), + new BenchmarkScenario("complex-bean->map", + this::createComplexBenchmarkSource, + HashMap::new, + result -> { + Map map = (Map) result; + Assert.assertEquals("complex-benchmark", map.get("name")); + Assert.assertEquals(36, map.get("age")); + Assert.assertEquals("RED", String.valueOf(map.get("color2"))); + }) + ); + } + + static class BenchmarkResult { + final String name; + final long cachedWarmNanos; + final long supportWarmNanos; + final long backendColdNanos; + final long supportColdNanos; + + BenchmarkResult(String name, + long cachedWarmNanos, + long supportWarmNanos, + long backendColdNanos, + long supportColdNanos) { + this.name = name; + this.cachedWarmNanos = cachedWarmNanos; + this.supportWarmNanos = supportWarmNanos; + this.backendColdNanos = backendColdNanos; + this.supportColdNanos = supportColdNanos; + } + + static BenchmarkResult average(String name, BenchmarkResult first, BenchmarkResult second) { + return new BenchmarkResult(name, + (first.cachedWarmNanos + second.cachedWarmNanos) / 2, + (first.supportWarmNanos + second.supportWarmNanos) / 2, + (first.backendColdNanos + second.backendColdNanos) / 2, + (first.supportColdNanos + second.supportColdNanos) / 2); + } + } + + static class ScenarioBenchmarkResult extends BenchmarkResult { + private final String scenario; + + ScenarioBenchmarkResult(String scenario, String name, long cachedWarmNanos, long supportWarmNanos) { + super(name, cachedWarmNanos, supportWarmNanos, 0, 0); + this.scenario = scenario; + } + } + + static class BackendCase { + private final String name; + private final FastBeanCopierBackend backend; + + BackendCase(String name, FastBeanCopierBackend backend) { + this.name = name; + this.backend = backend; + } + } + + static class BenchmarkScenario { + private final String name; + private final Supplier sourceSupplier; + private final Supplier targetSupplier; + private final Consumer resultChecker; + + BenchmarkScenario(String name, + Supplier sourceSupplier, + Supplier targetSupplier, + Consumer resultChecker) { + this.name = name; + this.sourceSupplier = sourceSupplier; + this.targetSupplier = targetSupplier; + this.resultChecker = resultChecker; + } + } +} diff --git a/hsweb-core/src/test/java/org/hswebframework/web/bean/accessor/AsmBeanAccessorTest.java b/hsweb-core/src/test/java/org/hswebframework/web/bean/accessor/AsmBeanAccessorTest.java new file mode 100644 index 000000000..8c90fd859 --- /dev/null +++ b/hsweb-core/src/test/java/org/hswebframework/web/bean/accessor/AsmBeanAccessorTest.java @@ -0,0 +1,1313 @@ +package org.hswebframework.web.bean.accessor; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.BeforeEach; +import org.springframework.core.ResolvableType; + +import java.beans.PropertyDescriptor; +import java.io.IOException; +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodHandles; +import java.lang.invoke.MethodType; +import java.lang.reflect.Method; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.BiConsumer; + +import static org.junit.jupiter.api.Assertions.*; + +public class AsmBeanAccessorTest { + + private AsmBeanAccessor accessor; + + @BeforeEach + void setUp() { + accessor = new AsmBeanAccessor(); + } + + @Test + void testCreateReader() { + // 测试读取字符串属性 + PropertyReader nameReader = accessor.createReader(TestEntity.class, "name"); + assertNotNull(nameReader); + + TestEntity entity = new TestEntity(); + entity.setName("测试名称"); + + Object result = nameReader.apply(entity); + assertEquals("测试名称", result); + } + + @Test + void testCreateReader_PrimitiveTypes() { + // 测试读取基本类型 + PropertyReader ageReader = accessor.createReader(TestEntity.class, "age"); + PropertyReader activeReader = accessor.createReader(TestEntity.class, "active"); + + TestEntity entity = new TestEntity(); + entity.setAge(25); + entity.setActive(true); + + Object age = ageReader.apply(entity); + Object active = activeReader.apply(entity); + + assertEquals(25, age); + assertEquals(true, active); + assertTrue(age instanceof Integer); + assertTrue(active instanceof Boolean); + } + + @Test + void testCreateWriter() { + // 测试写入字符串属性 + PropertyWriter nameWriter = accessor.createWriter(TestEntity.class, "name", null); + assertNotNull(nameWriter); + + TestEntity entity = new TestEntity(); + nameWriter.accept(entity, "新名称"); + + assertEquals("新名称", entity.getName()); + } + + @Test + void testCreateWriter_PrimitiveTypes() { + // 测试写入基本类型 + PropertyWriter ageWriter = accessor.createWriter(TestEntity.class, "age", null); + PropertyWriter activeWriter = accessor.createWriter(TestEntity.class, "active", null); + + TestEntity entity = new TestEntity(); + ageWriter.accept(entity, 30); + activeWriter.accept(entity, false); + + assertEquals(30, entity.getAge()); + assertEquals(false, entity.isActive()); + } + + @Test + void testCreateWriter_WithTypeConverter() { + // 测试带类型转换器的写入 + TypeConverter converter = new TypeConverter() { + @Override + public Object convert(Object source, ResolvableType type) { + if (source instanceof String && (type.getRawClass() == int.class || type.getRawClass() == Integer.class)) { + return Integer.parseInt((String) source); + } + return source; + } + }; + + PropertyWriter ageWriter = accessor.createWriter(TestEntity.class, "age", converter); + + TestEntity entity = new TestEntity(); + ageWriter.accept(entity, "35"); + + assertEquals(35, entity.getAge()); + } + + @Test + void testCreateWriter_NumberConversion() { + // 测试数字类型的自动转换 + PropertyWriter ageWriter = accessor.createWriter(TestEntity.class, "age", null); + PropertyWriter salaryWriter = accessor.createWriter(TestEntity.class, "salary", null); + + TestEntity entity = new TestEntity(); + + // 测试不同数字类型的转换 + ageWriter.accept(entity, 25L); // Long -> int + salaryWriter.accept(entity, 50000.0f); // float -> double + + assertEquals(25, entity.getAge()); + assertEquals(50000.0, entity.getSalary(), 0.001); + } + + + @Test + void testInvalidProperty() { + // 测试不存在的属性 + assertThrows(RuntimeException.class, () -> { + accessor.createReader(TestEntity.class, "nonExistentProperty"); + }); + + assertThrows(RuntimeException.class, () -> { + accessor.createWriter(TestEntity.class, "nonExistentProperty", null); + }); + } + + @Test + void testReadOnlyProperty() { + // 测试只读属性 + PropertyReader reader = accessor.createReader(TestEntity.class, "readOnlyProperty"); + + TestEntity entity = new TestEntity(); + Object result = reader.apply(entity); + assertEquals("只读属性", result); + + // 尝试创建写入器应该失败 + assertThrows(RuntimeException.class, () -> { + accessor.createWriter(TestEntity.class, "readOnlyProperty", null); + }); + } + + @Test + void testWriteOnlyProperty() { + // 测试只写属性 + PropertyWriter writer = accessor.createWriter(TestEntity.class, "writeOnlyProperty", null); + + TestEntity entity = new TestEntity(); + writer.accept(entity, "写入值"); + + assertEquals("写入值", entity.getWriteOnlyValue()); + + // 尝试创建读取器应该失败 + assertThrows(RuntimeException.class, () -> { + accessor.createReader(TestEntity.class, "writeOnlyProperty"); + }); + } + + @Test + void testComplexObject() { + // 测试复杂对象属性 + PropertyReader addressReader = accessor.createReader(TestEntity.class, "address"); + PropertyWriter addressWriter = accessor.createWriter(TestEntity.class, "address", null); + + TestEntity entity = new TestEntity(); + Address address = new Address(); + address.setStreet("测试街道"); + address.setCity("测试城市"); + + addressWriter.accept(entity, address); + Object result = addressReader.apply(entity); + + assertTrue(result instanceof Address); + Address resultAddress = (Address) result; + assertEquals("测试街道", resultAddress.getStreet()); + assertEquals("测试城市", resultAddress.getCity()); + } + + @Test + void testPerformance() { + System.out.println("\n=== 性能测试结果 (执行1000000次读写操作) ==="); + + try { + // 创建带有TypeConverter的访问器来测试优化路径 + PropertyReader nameReader = accessor.createReader(TestEntity.class, "name"); + PropertyWriter nameWriter = accessor.createWriter(TestEntity.class, "name", new TypeConverter() { + @Override + public Object convert(Object source, ResolvableType type) { + // 简单的类型转换，确保走优化路径 + return source; + } + }); + + TestEntity entity = new TestEntity(); + entity.setName("测试"); + + // 预热 + for (int i = 0; i < 100000; i++) { + nameReader.apply(entity); + nameWriter.accept(entity, "warm_" + i); + } + + // 测试ASM访问器 + long asmStart = System.nanoTime(); + for (int i = 0; i < 1000000; i++) { + String result = (String) nameReader.apply(entity); + nameWriter.accept(entity, result); + } + long asmEnd = System.nanoTime(); + + // 测试直接方法调用 + long directStart = System.nanoTime(); + for (int i = 0; i < 1000000; i++) { + String result = entity.getName(); + entity.setName(result); + } + long directEnd = System.nanoTime(); + + long asmTime = asmEnd - asmStart; + long directTime = directEnd - directStart; + + System.out.println("ASM访问器耗时: " + asmTime / 1000000 + "ms"); + System.out.println("直接方法调用耗时: " + directTime / 1000000 + "ms"); + System.out.println("性能比率: " + String.format("%.2f", (double) asmTime / directTime) + "x"); + + if (asmTime < directTime * 2) { + System.out.println("✅ ASM访问器性能优秀，与直接调用相差不大"); + } else { + System.out.println("⚠️ ASM访问器性能有优化空间"); + } + + // 断言性能要求 + assertTrue(asmTime < directTime * 5, "ASM访问器性能不应该比直接调用慢5倍以上"); + + } catch (Exception e) { + fail("性能测试失败: " + e.getMessage()); + } + } + + @Test + void testDetailedPerformanceComparison() { + System.out.println("\n=== 详细性能分析测试 ==="); + + try { + // 创建访问器 - 使用TypeConverter来测试优化路径 + PropertyReader nameReader = accessor.createReader(TestEntity.class, "name"); + PropertyWriter nameWriter = accessor.createWriter(TestEntity.class, "name", new TypeConverter() { + @Override + public Object convert(Object source, ResolvableType type) { + // 简单的类型转换，确保走优化路径 + return source; + } + }); + + TestEntity entity = new TestEntity(); + entity.setName("测试"); + + // 1. JVM热身 + System.out.println("1. 开始 JVM 热身..."); + for (int i = 0; i < 100000; i++) { + nameReader.apply(entity); + nameWriter.accept(entity, "warmup" + i); + entity.getName(); + entity.setName("warmup" + i); + } + System.out.println(" 热身完成"); + + // 2. 多轮性能测试 + int rounds = 20; + int iterations = 5000000; + long[] asmTimes = new long[rounds]; + long[] directTimes = new long[rounds]; + + for (int round = 0; round < rounds; round++) { + System.out.println("2. 执行第 " + (round + 1) + " 轮测试..."); + + // 重置状态 + entity.setName("测试"); + System.gc(); + try { + Thread.sleep(10); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + } + + // === ASM 测试 === + long asmStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + String result = (String) nameReader.apply(entity); + nameWriter.accept(entity, result); + } + long asmEnd = System.nanoTime(); + asmTimes[round] = asmEnd - asmStart; + + // === 直接调用测试 === + entity.setName("测试"); + System.gc(); + try { + Thread.sleep(10); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + } + + long directStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + String result = entity.getName(); + entity.setName(result); + } + long directEnd = System.nanoTime(); + directTimes[round] = directEnd - directStart; + + System.out.println(" ASM: " + asmTimes[round] / 1000000 + "ms, 直接调用: " + directTimes[round] / 1000000 + "ms"); + + // 强制垃圾回收 + System.gc(); + Thread.yield(); + } + + // 3. 计算平均值和统计信息 + long asmAvg = 0, directAvg = 0; + for (int i = 0; i < 5; i++) { + asmAvg += asmTimes[i]; + directAvg += directTimes[i]; + } + asmAvg /= 5; + directAvg /= 5; + + System.out.println("\n=== 最终统计结果 ==="); + System.out.println("ASM访问器平均耗时: " + asmAvg / 1000000 + "ms"); + System.out.println("直接调用平均耗时: " + directAvg / 1000000 + "ms"); + System.out.println("性能比率: " + String.format("%.2f", (double) asmAvg / directAvg) + "x"); + + // 4. 分析为什么 ASM 可能更快 + System.out.println("\n=== 性能分析 ==="); + if (asmAvg < directAvg) { + System.out.println("✨ ASM访问器确实比直接调用更快！可能原因："); + System.out.println(" • 生成的字节码更简洁，减少了方法调用开销"); + System.out.println(" • JIT编译器更容易内联优化生成的访问器方法"); + System.out.println(" • 避免了Java方法调用的一些间接开销"); + System.out.println(" • 专门针对单一属性访问优化的字节码"); + } else if (asmAvg <= directAvg * 1.5) { + System.out.println("✅ ASM访问器性能与直接调用相当，这已经非常优秀了！"); + } else { + System.out.println("⚠️ ASM访问器性能有优化空间"); + } + + // 断言性能要求 + assertTrue(asmAvg < directAvg * 5, "ASM访问器性能不应该比直接调用慢5倍以上"); + + } catch (Exception e) { + fail("详细性能分析测试失败: " + e.getMessage()); + } + } + + @Test + void testThreeWayPerformanceComparison() { + System.out.println("\n=== 三方性能对比测试：ASM vs 直接调用 vs MethodHandle ==="); + + try { + TypeConverter converter = (source, type) -> { + // 简单的类型转换，确保走优化路径 + if(type.isInstance(source)){ + return source; + } + return type.toClass().cast(source); + }; + + // 准备三种访问方式 - 使用TypeConverter来测试优化路径 + PropertyReader nameReader = accessor.createReader(TestEntity.class, "name"); + PropertyWriter nameWriter = accessor.createWriter(TestEntity.class, "name",converter ); + + // MethodHandle方式 + MethodHandles.Lookup lookup = MethodHandles.lookup(); + MethodHandle getNameHandle = lookup.findVirtual(TestEntity.class, "getName", MethodType.methodType(String.class)); + MethodHandle setNameHandle = lookup.findVirtual(TestEntity.class, "setName", MethodType.methodType(void.class, String.class)); + + BiConsumer setter = TestEntity::setName; + TestEntity entity = new TestEntity(); + entity.setName("初始值"); + + int warmupIterations = 5000000; // 热身次数 + int testIterations = 5000000; // 测试次数（减少以避免测试时间过长） + + System.out.println("1. 开始热身阶段..."); + + // 热身所有三种方式 + for (int i = 0; i < warmupIterations; i++) { + // ASM热身 + nameReader.apply(entity); + nameWriter.accept(entity, "warmup_asm_" + i); + + // 直接调用热身 + setter.accept(entity, "warmup_asm_" + i); + + // MethodHandle热身 + getNameHandle.invoke(entity); + setNameHandle.invoke(entity, "warmup_methodhandle_" + i); + } + + System.out.println(" 热身完成，开始正式测试..."); + + // 执行多轮测试 + int rounds = 10; + long[] asmTimes = new long[rounds]; + long[] directTimes = new long[rounds]; + long[] methodHandleTimes = new long[rounds]; + + for (int round = 0; round < rounds; round++) { + System.out.println("2. 执行第 " + (round + 1) + " 轮测试..."); + + // === 测试 ASM 访问器 === + entity.setName("asm_test_" + round); + System.gc(); + Thread.yield(); + + long asmStart = System.nanoTime(); + for (int i = 0; i < testIterations; i++) { + String result = (String) nameReader.apply(entity); + nameWriter.accept(entity, "asm_test_"); + } + long asmEnd = System.nanoTime(); + asmTimes[round] = asmEnd - asmStart; + + // === 测试直接方法调用 === + entity.setName("direct_test_" + round); + System.gc(); + Thread.yield(); + + long directStart = System.nanoTime(); + for (int i = 0; i < testIterations; i++) { + String result = entity.getName(); + setter.accept(entity, "direct_test_"); +// entity.setName("direct_test_" + round); + } + long directEnd = System.nanoTime(); + directTimes[round] = directEnd - directStart; + + // === 测试MethodHandle调用 === + entity.setName("methodhandle_test_" + round); + System.gc(); + Thread.yield(); + + long methodHandleStart = System.nanoTime(); + for (int i = 0; i < testIterations; i++) { + String result = (String)getNameHandle.invoke(entity); + setNameHandle.invoke(entity, "methodhandle_test_"); + } + long methodHandleEnd = System.nanoTime(); + methodHandleTimes[round] = methodHandleEnd - methodHandleStart; + + System.out.println(" 第" + (round + 1) + "轮: ASM=" + asmTimes[round]/1000000 + "ms, " + + "直接调用=" + directTimes[round]/1000000 + "ms, " + + "MethodHandle=" + methodHandleTimes[round]/1000000 + "ms"); + } + + // 计算平均值 + long asmAvg = 0, directAvg = 0, methodHandleAvg = 0; + for (int i = 0; i < rounds; i++) { + asmAvg += asmTimes[i]; + directAvg += directTimes[i]; + methodHandleAvg += methodHandleTimes[i]; + } + asmAvg /= rounds; + directAvg /= rounds; + methodHandleAvg /= rounds; + + // 输出详细结果 + System.out.println("\n=== 三方性能对比结果 (执行" + testIterations + "次读写操作) ==="); + System.out.println("┌─────────────────┬──────────┬──────────────┬─────────────────┐"); + System.out.println("│ 访问方式 │ 平均耗时 │ 相对直接调用 │ 相对MethodHandle │"); + System.out.println("├─────────────────┼──────────┼──────────────┼─────────────────┤"); + System.out.printf("│ 直接方法调用 │ %6dms │ %.2fx │ %.2fx │%n", + directAvg/1000000, 1.0, (double)directAvg/methodHandleAvg); + System.out.printf("│ ASM访问器 │ %6dms │ %.2fx │ %.2fx │%n", + asmAvg/1000000, (double)asmAvg/directAvg, (double)asmAvg/methodHandleAvg); + System.out.printf("│ MethodHandle调用│ %6dms │ %.2fx │ %.2fx │%n", + methodHandleAvg/1000000, (double)methodHandleAvg/directAvg, 1.0); + System.out.println("└─────────────────┴──────────┴──────────────┴─────────────────┘"); + + // 性能排名 + System.out.println("\n=== 性能排名 ==="); + if (asmAvg <= directAvg && asmAvg <= methodHandleAvg) { + System.out.println("🥇 ASM访问器 - 最快"); + System.out.println("🥈 " + (directAvg <= methodHandleAvg ? "直接调用" : "MethodHandle调用")); + System.out.println("🥉 " + (directAvg > methodHandleAvg ? "直接调用" : "MethodHandle调用")); + } else if (directAvg <= asmAvg && directAvg <= methodHandleAvg) { + System.out.println("🥇 直接调用 - 最快"); + System.out.println("🥈 " + (asmAvg <= methodHandleAvg ? "ASM访问器" : "MethodHandle调用")); + System.out.println("🥉 " + (asmAvg > methodHandleAvg ? "ASM访问器" : "MethodHandle调用")); + } else { + System.out.println("🥇 MethodHandle调用 - 最快（这很罕见！）"); + System.out.println("🥈 " + (asmAvg <= directAvg ? "ASM访问器" : "直接调用")); + System.out.println("🥉 " + (asmAvg > directAvg ? "ASM访问器" : "直接调用")); + } + + // 分析结果 + System.out.println("\n=== 性能分析 ==="); + double asmVsMethodHandle = (double) asmAvg / methodHandleAvg; + double directVsMethodHandle = (double) directAvg / methodHandleAvg; + + if (asmVsMethodHandle < 0.5) { + System.out.println("🚀 ASM访问器比MethodHandle快 " + String.format("%.1f", 1/asmVsMethodHandle) + " 倍以上！"); + } else if (asmVsMethodHandle < 1.0) { + System.out.println("✅ ASM访问器比MethodHandle快 " + String.format("%.1f", 1/asmVsMethodHandle) + " 倍"); + } + + if (asmAvg <= directAvg * 1.2) { + System.out.println("✨ ASM访问器性能与直接调用非常接近，这证明了字节码生成的优秀！"); + } + + System.out.println("📊 MethodHandle是Java 7引入的现代反射API，性能比传统反射更好"); + + // 性能断言 + assertTrue(asmAvg < methodHandleAvg * 2, "ASM访问器应该比MethodHandle快"); + assertTrue(directAvg < methodHandleAvg * 2, "直接调用应该比MethodHandle快"); + assertTrue(asmAvg < directAvg * 5, "ASM访问器不应该比直接调用慢太多"); + + } catch (Throwable e) { + fail("三方性能对比测试失败: " + e.getMessage()); + } + } + + @Test + void testMethodHandlePerformanceAnalysis() { + System.out.println("\n=== MethodHandle性能分析测试 ==="); + + try { + // 准备访问器 - 使用TypeConverter来测试优化路径 + PropertyReader nameReader = accessor.createReader(TestEntity.class, "name"); + PropertyWriter nameWriter = accessor.createWriter(TestEntity.class, "name", new TypeConverter() { + @Override + public Object convert(Object source, ResolvableType type) { + // 简单的类型转换，确保走优化路径 + return source; + } + }); + + // 准备MethodHandle + MethodHandles.Lookup lookup = MethodHandles.lookup(); + MethodHandle getNameHandle = lookup.findVirtual(TestEntity.class, "getName", MethodType.methodType(String.class)); + MethodHandle setNameHandle = lookup.findVirtual(TestEntity.class, "setName", MethodType.methodType(void.class, String.class)); + + TestEntity entity = new TestEntity(); + entity.setName("测试"); + + int iterations = 100000; + + // 热身 + for (int i = 0; i < 10000; i++) { + nameReader.apply(entity); + nameWriter.accept(entity, "warmup" + i); + getNameHandle.invoke(entity); + setNameHandle.invoke(entity, "warmup" + i); + entity.getName(); + entity.setName("warmup" + i); + } + + System.out.println("1. 纯读写操作测试："); + + // 测试ASM + long asmStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + nameReader.apply(entity); + nameWriter.accept(entity, "asm" + i); + } + long asmTime = System.nanoTime() - asmStart; + + // 测试MethodHandle + long methodHandleStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + getNameHandle.invoke(entity); + setNameHandle.invoke(entity, "mh" + i); + } + long methodHandleTime = System.nanoTime() - methodHandleStart; + + // 测试直接调用 + long directStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + entity.getName(); + entity.setName("direct" + i); + } + long directTime = System.nanoTime() - directStart; + + System.out.println(" ASM: " + asmTime/1000000 + "ms"); + System.out.println(" MethodHandle: " + methodHandleTime/1000000 + "ms"); + System.out.println(" Direct: " + directTime/1000000 + "ms"); + + // 数据依赖测试 + System.out.println("\n2. 数据依赖操作测试："); + StringBuilder sb = new StringBuilder(); + + // ASM 数据依赖测试 + entity.setName("start"); + long asmDataStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + String name = (String) nameReader.apply(entity); + nameWriter.accept(entity, name + i); + sb.append(name.charAt(0)); // 数据依赖 + } + long asmDataTime = System.nanoTime() - asmDataStart; + + // MethodHandle 数据依赖测试 + entity.setName("start"); + sb.setLength(0); + long mhDataStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + String name = (String) getNameHandle.invoke(entity); + setNameHandle.invoke(entity, name + i); + sb.append(name.charAt(0)); // 数据依赖 + } + long mhDataTime = System.nanoTime() - mhDataStart; + + // 直接调用数据依赖测试 + entity.setName("start"); + sb.setLength(0); + long directDataStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + String name = entity.getName(); + entity.setName(name + i); + sb.append(name.charAt(0)); // 数据依赖 + } + long directDataTime = System.nanoTime() - directDataStart; + + System.out.println(" ASM: " + asmDataTime/1000000 + "ms"); + System.out.println(" MethodHandle: " + mhDataTime/1000000 + "ms"); + System.out.println(" Direct: " + directDataTime/1000000 + "ms"); + + // 只读测试 + System.out.println("\n3. 只读操作测试："); + long asmReadStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + nameReader.apply(entity); + nameReader.apply(entity); + nameReader.apply(entity); + } + long asmReadTime = System.nanoTime() - asmReadStart; + + long mhReadStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + getNameHandle.invoke(entity); + getNameHandle.invoke(entity); + getNameHandle.invoke(entity); + } + long mhReadTime = System.nanoTime() - mhReadStart; + + long directReadStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + entity.getName(); + entity.getName(); + entity.getName(); + } + long directReadTime = System.nanoTime() - directReadStart; + + System.out.println(" ASM: " + asmReadTime/1000000 + "ms"); + System.out.println(" MethodHandle: " + mhReadTime/1000000 + "ms"); + System.out.println(" Direct: " + directReadTime/1000000 + "ms"); + + // 只写测试 + System.out.println("\n4. 只写操作测试："); + long asmWriteStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + nameWriter.accept(entity, "asm" + i); + nameWriter.accept(entity, "asm" + i); + nameWriter.accept(entity, "asm" + i); + } + long asmWriteTime = System.nanoTime() - asmWriteStart; + + long mhWriteStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + setNameHandle.invoke(entity, "mh" + i); + setNameHandle.invoke(entity, "mh" + i); + setNameHandle.invoke(entity, "mh" + i); + } + long mhWriteTime = System.nanoTime() - mhWriteStart; + + long directWriteStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + entity.setName("direct" + i); + entity.setName("direct" + i); + entity.setName("direct" + i); + } + long directWriteTime = System.nanoTime() - directWriteStart; + + System.out.println(" ASM: " + asmWriteTime/1000000 + "ms"); + System.out.println(" MethodHandle: " + mhWriteTime/1000000 + "ms"); + System.out.println(" Direct: " + directWriteTime/1000000 + "ms"); + + // 分析结论 + System.out.println("\n=== 分析结论 ==="); + System.out.println("MethodHandle在特定场景下性能优异可能的原因："); + System.out.println("1. 🔧 JIT编译器对MethodHandle的特殊优化"); + System.out.println("2. 📊 数据依赖操作模式下的优化策略"); + System.out.println("3. 🚀 MethodHandle的内联优化更激进"); + System.out.println("4. 💡 字符串拼接操作掩盖了方法调用开销"); + + // 性能断言 + assertTrue(asmTime < directTime * 3, "ASM访问器读写性能应该合理"); + assertTrue(methodHandleTime < directTime * 3, "MethodHandle读写性能应该合理"); + + } catch (Throwable e) { + fail("MethodHandle性能分析测试失败: " + e.getMessage()); + } + } + + @Test + public void testGenericSupport() throws Exception { + // 测试泛型支持 + AsmBeanAccessor accessor = new AsmBeanAccessor(); + + // 创建一个带有泛型的属性writer + PropertyWriter writer = accessor.createWriter(TestEntity.class, "genericList", new TypeConverter() { + @Override + public Object convert(Object source, ResolvableType targetType) { + // 验证ResolvableType包含泛型信息 + assertNotNull(targetType); + + // 对于List，应该可以获取到泛型信息 + if (targetType.hasGenerics()) { + ResolvableType generic = targetType.getGeneric(0); + assertEquals(String.class, generic.resolve()); + } + + return source; + } + }); + + TestEntity entity = new TestEntity(); + List testList = Arrays.asList("test1", "test2"); + + // 测试写入 + writer.accept(entity, testList); + assertEquals(testList, entity.getGenericList()); + + System.out.println("✅ 泛型支持测试通过！"); + } + + @Test + void testCreateReaderCode() throws Exception { + // 测试生成Reader字节码 + byte[] readerCode = accessor.createReaderCode(TestEntity.class, "name"); + + assertNotNull(readerCode); + assertTrue(readerCode.length > 0); + + // 保存字节码到target目录 + saveByteCodeToTarget("TestEntity_getName_Reader.class", readerCode); + + // 验证生成的字节码是否有效 + Class readerClass = defineClassFromBytes(readerCode); + Object readerInstance = readerClass.getDeclaredConstructor().newInstance(); + assertTrue(readerInstance instanceof PropertyReader); + + // 测试功能是否正常 + PropertyReader reader = (PropertyReader) readerInstance; + TestEntity entity = new TestEntity(); + entity.setName("测试名称"); + + Object result = reader.apply(entity); + assertEquals("测试名称", result); + + System.out.println("✅ createReaderCode 测试通过，字节码已保存到 target/bytecode/TestEntity_getName_Reader.class"); + } + + @Test + void testCreateWriterCode() throws Exception { + // 获取PropertyDescriptor + PropertyDescriptor descriptor = getPropertyDescriptor(TestEntity.class, "name"); + + // 创建TypeConverter + TypeConverter converter = (source, type) -> { + if (type.isInstance(source)) { + return source; + } + return type.toClass().cast(source); + }; + + // 测试生成Writer字节码 + byte[] writerCode = accessor.createWriterCode(TestEntity.class, this.getClass().getPackageName()+".TestEntity_setName_Writer", descriptor, converter); + + assertNotNull(writerCode); + assertTrue(writerCode.length > 0); + + // 保存字节码到target目录 + saveByteCodeToTarget("TestEntity_setName_Writer.class", writerCode); + + // 验证生成的字节码是否有效 + Class writerClass = defineClassFromBytes(writerCode); + ResolvableType resolvableType = ResolvableType.forMethodParameter(descriptor.getWriteMethod(), 0); + Object writerInstance = writerClass.getDeclaredConstructor(TypeConverter.class, ResolvableType.class) + .newInstance(converter, resolvableType); + assertTrue(writerInstance instanceof PropertyWriter); + + // 测试功能是否正常 + PropertyWriter writer = (PropertyWriter) writerInstance; + TestEntity entity = new TestEntity(); + writer.accept(entity, "测试写入"); + + assertEquals("测试写入", entity.getName()); + + System.out.println("✅ createWriterCode 测试通过，字节码已保存到 target/bytecode/TestEntity_setName_Writer.class"); + } + + @Test + void testCreateReaderCodeForDifferentTypes() throws Exception { + // 测试不同类型的属性读取器字节码生成 + TestEntity entity = new TestEntity(); + entity.setAge(25); + entity.setActive(true); + entity.setSalary(50000.0); + + // 测试int类型 + byte[] ageReaderCode = accessor.createReaderCode(TestEntity.class, "age"); + saveByteCodeToTarget("TestEntity_getAge_Reader.class", ageReaderCode); + + Class ageReaderClass = defineClassFromBytes(ageReaderCode); + PropertyReader ageReader = (PropertyReader) ageReaderClass.getDeclaredConstructor().newInstance(); + assertEquals(25, ageReader.apply(entity)); + + // 测试boolean类型 + byte[] activeReaderCode = accessor.createReaderCode(TestEntity.class, "active"); + saveByteCodeToTarget("TestEntity_isActive_Reader.class", activeReaderCode); + + Class activeReaderClass = defineClassFromBytes(activeReaderCode); + PropertyReader activeReader = (PropertyReader) activeReaderClass.getDeclaredConstructor().newInstance(); + assertEquals(true, activeReader.apply(entity)); + + // 测试double类型 + byte[] salaryReaderCode = accessor.createReaderCode(TestEntity.class, "salary"); + saveByteCodeToTarget("TestEntity_getSalary_Reader.class", salaryReaderCode); + + Class salaryReaderClass = defineClassFromBytes(salaryReaderCode); + PropertyReader salaryReader = (PropertyReader) salaryReaderClass.getDeclaredConstructor().newInstance(); + assertEquals(50000.0, salaryReader.apply(entity)); + + System.out.println("✅ 不同类型的属性字节码生成测试通过"); + } + + @Test + void testCreateWriterCodeForDifferentTypes() throws Exception { + // 测试不同类型的属性写入器字节码生成 + TestEntity entity = new TestEntity(); + + TypeConverter converter = (source, type) -> { + if (type.isInstance(source)) { + return source; + } + return type.toClass().cast(source); + }; + + // 测试int类型 + PropertyDescriptor ageDescriptor = getPropertyDescriptor(TestEntity.class, "age"); + byte[] ageWriterCode = accessor.createWriterCode(TestEntity.class,this.getClass().getPackageName()+".TestEntity_setAge_Writer", ageDescriptor, converter); + saveByteCodeToTarget("TestEntity_setAge_Writer.class", ageWriterCode); + + Class ageWriterClass = defineClassFromBytes(ageWriterCode); + ResolvableType ageResolvableType = ResolvableType.forMethodParameter(ageDescriptor.getWriteMethod(), 0); + PropertyWriter ageWriter = (PropertyWriter) ageWriterClass.getDeclaredConstructor(TypeConverter.class, ResolvableType.class) + .newInstance(converter, ageResolvableType); + ageWriter.accept(entity, 30); + assertEquals(30, entity.getAge()); + + // 测试boolean类型 + PropertyDescriptor activeDescriptor = getPropertyDescriptor(TestEntity.class, "active"); + byte[] activeWriterCode = accessor.createWriterCode(TestEntity.class,this.getClass().getPackageName()+".TestEntity_setActive_Writer", activeDescriptor, converter); + saveByteCodeToTarget("TestEntity_setActive_Writer.class", activeWriterCode); + + Class activeWriterClass = defineClassFromBytes(activeWriterCode); + ResolvableType activeResolvableType = ResolvableType.forMethodParameter(activeDescriptor.getWriteMethod(), 0); + PropertyWriter activeWriter = (PropertyWriter) activeWriterClass.getDeclaredConstructor(TypeConverter.class, ResolvableType.class) + .newInstance(converter, activeResolvableType); + activeWriter.accept(entity, false); + assertEquals(false, entity.isActive()); + + // 测试double类型 + PropertyDescriptor salaryDescriptor = getPropertyDescriptor(TestEntity.class, "salary"); + byte[] salaryWriterCode = accessor.createWriterCode(TestEntity.class,this.getClass().getPackageName()+".TestEntity_setSalary_Writer", salaryDescriptor, converter); + saveByteCodeToTarget("TestEntity_setSalary_Writer.class", salaryWriterCode); + + Class salaryWriterClass = defineClassFromBytes(salaryWriterCode); + ResolvableType salaryResolvableType = ResolvableType.forMethodParameter(salaryDescriptor.getWriteMethod(), 0); + PropertyWriter salaryWriter = (PropertyWriter) salaryWriterClass.getDeclaredConstructor(TypeConverter.class, ResolvableType.class) + .newInstance(converter, salaryResolvableType); + salaryWriter.accept(entity, 60000.0); + assertEquals(60000.0, entity.getSalary()); + + System.out.println("✅ 不同类型的属性写入器字节码生成测试通过"); + } + + @Test + void testCreateWriterCodeWithoutConverter() throws Exception { + // 测试不使用TypeConverter的Writer字节码生成 + PropertyDescriptor descriptor = getPropertyDescriptor(TestEntity.class, "name"); + + byte[] writerCode = accessor.createWriterCode(TestEntity.class,this.getClass().getPackageName()+".TestEntity_setName_Writer_NoConverter", descriptor, null); + saveByteCodeToTarget("TestEntity_setName_Writer_NoConverter.class", writerCode); + + Class writerClass = defineClassFromBytes(writerCode); + PropertyWriter writer = (PropertyWriter) writerClass.getDeclaredConstructor(TypeConverter.class) + .newInstance((TypeConverter) null); + + TestEntity entity = new TestEntity(); + writer.accept(entity, "无转换器测试"); + + assertEquals("无转换器测试", entity.getName()); + + System.out.println("✅ 无TypeConverter的Writer字节码生成测试通过"); + } + + @Test + void testCreateWriterCodeWithGenericType() throws Exception { + // 测试泛型类型的Writer字节码生成 + PropertyDescriptor descriptor = getPropertyDescriptor(TestEntity.class, "genericList"); + + TypeConverter converter = (source, type) -> { + if (type.isInstance(source)) { + return source; + } + // 处理泛型List + if (type.resolve() == List.class && source instanceof List) { + return source; + } + return type.toClass().cast(source); + }; + + byte[] writerCode = accessor.createWriterCode(TestEntity.class,this.getClass().getPackageName()+".TestEntity_setGenericList_Writer", descriptor, converter); + saveByteCodeToTarget(this.getClass().getPackageName()+".TestEntity_setGenericList_Writer.class", writerCode); + + Class writerClass = defineClassFromBytes(writerCode); + ResolvableType resolvableType = ResolvableType.forMethodParameter(descriptor.getWriteMethod(), 0); + PropertyWriter writer = (PropertyWriter) writerClass.getDeclaredConstructor(TypeConverter.class, ResolvableType.class) + .newInstance(converter, resolvableType); + + TestEntity entity = new TestEntity(); + List testList = Arrays.asList("item1", "item2", "item3"); + writer.accept(entity, testList); + + assertEquals(testList, entity.getGenericList()); + + System.out.println("✅ 泛型类型的Writer字节码生成测试通过"); + } + + @Test + void testTypeCheckOptimization() throws Exception { + System.out.println("\n=== 类型检查优化测试 ==="); + + // 创建一个计数器来跟踪TypeConverter的调用次数 + AtomicInteger converterCallCount = new AtomicInteger(0); + + TypeConverter countingConverter = (source, type) -> { + converterCallCount.incrementAndGet(); + System.out.println(" TypeConverter.convert() 被调用，参数: " + source + " -> " + type.toClass().getSimpleName()); + + if (source == null) { + return null; + } + + if (type.isInstance(source)) { + return source; + } + + // 处理各种类型转换 + Class targetType = type.toClass(); + + // String 到其他类型的转换 + if (source instanceof String) { + String str = (String) source; + if (targetType == int.class || targetType == Integer.class) { + return Integer.parseInt(str); + } else if (targetType == double.class || targetType == Double.class) { + return Double.parseDouble(str); + } else if (targetType == boolean.class || targetType == Boolean.class) { + return Boolean.parseBoolean(str); + } + } + + // 数字到String的转换 + if (targetType == String.class) { + return source.toString(); + } + + // 数字之间的转换 + if (source instanceof Number && (targetType.isPrimitive() || Number.class.isAssignableFrom(targetType))) { + Number number = (Number) source; + if (targetType == int.class || targetType == Integer.class) { + return number.intValue(); + } else if (targetType == double.class || targetType == Double.class) { + return number.doubleValue(); + } else if (targetType == long.class || targetType == Long.class) { + return number.longValue(); + } else if (targetType == float.class || targetType == Float.class) { + return number.floatValue(); + } + } + + return targetType.cast(source); + }; + + // 测试String类型的属性 + PropertyWriter nameWriter = accessor.createWriter(TestEntity.class, "name", countingConverter); + PropertyWriter ageWriter = accessor.createWriter(TestEntity.class, "age", countingConverter); + + TestEntity entity = new TestEntity(); + + // 重置计数器 + converterCallCount.set(0); + + System.out.println("\n1. 测试类型一致的情况："); + + // 类型一致的情况：传入String给String属性 + nameWriter.accept(entity, "正确的String类型"); + System.out.println(" 设置String值到String属性，converter调用次数: " + converterCallCount.get()); + assertEquals("正确的String类型", entity.getName()); + assertEquals(0, converterCallCount.get(), "类型一致时不应该调用TypeConverter"); + + // 类型一致的情况：传入Integer给int属性 + ageWriter.accept(entity, 25); + System.out.println(" 设置Integer值到int属性，converter调用次数: " + converterCallCount.get()); + assertEquals(25, entity.getAge()); + assertEquals(0, converterCallCount.get(), "类型一致时不应该调用TypeConverter"); + + System.out.println("\n2. 测试类型不一致的情况："); + + // 类型不一致的情况：传入Integer给String属性 + nameWriter.accept(entity, 123); + System.out.println(" 设置Integer值到String属性，converter调用次数: " + converterCallCount.get()); + assertEquals("123", entity.getName()); + assertEquals(1, converterCallCount.get(), "类型不一致时应该调用TypeConverter"); + + // 类型不一致的情况：传入String给int属性 + ageWriter.accept(entity, "30"); + System.out.println(" 设置String值到int属性，converter调用次数: " + converterCallCount.get()); + assertEquals(30, entity.getAge()); + assertEquals(2, converterCallCount.get(), "类型不一致时应该调用TypeConverter"); + + System.out.println("\n3. 测试null值的情况："); + + // null值的情况 + nameWriter.accept(entity, null); + System.out.println(" 设置null值到String属性，converter调用次数: " + converterCallCount.get()); + assertNull(entity.getName()); + assertEquals(3, converterCallCount.get(), "null值应该调用TypeConverter"); + + System.out.println("\n✅ 类型检查优化测试通过！"); + System.out.println(" ✓ 类型一致时跳过了TypeConverter调用"); + System.out.println(" ✓ 类型不一致时正确调用了TypeConverter"); + System.out.println(" ✓ null值处理正确"); + } + + @Test + void testTypeCheckOptimizationWithPrimitives() throws Exception { + System.out.println("\n=== 基本类型优化测试 ==="); + + AtomicInteger converterCallCount = new AtomicInteger(0); + + TypeConverter countingConverter = (source, type) -> { + converterCallCount.incrementAndGet(); + System.out.println(" TypeConverter.convert() 被调用: " + source.getClass().getSimpleName() + " -> " + type.toClass().getSimpleName()); + + if (source instanceof Number && (type.toClass().isPrimitive() || Number.class.isAssignableFrom(type.toClass()))) { + Number number = (Number) source; + if (type.toClass() == int.class || type.toClass() == Integer.class) { + return number.intValue(); + } else if (type.toClass() == double.class || type.toClass() == Double.class) { + return number.doubleValue(); + } else if (type.toClass() == boolean.class || type.toClass() == Boolean.class) { + return number.intValue() != 0; + } + } + + return source; + }; + + PropertyWriter ageWriter = accessor.createWriter(TestEntity.class, "age", countingConverter); + PropertyWriter salaryWriter = accessor.createWriter(TestEntity.class, "salary", countingConverter); + PropertyWriter activeWriter = accessor.createWriter(TestEntity.class, "active", countingConverter); + + TestEntity entity = new TestEntity(); + converterCallCount.set(0); + + System.out.println("\n1. 测试基本类型包装类的直接赋值："); + + // Integer -> int (类型匹配) + ageWriter.accept(entity, Integer.valueOf(25)); + System.out.println(" Integer -> int，converter调用次数: " + converterCallCount.get()); + assertEquals(25, entity.getAge()); + assertEquals(0, converterCallCount.get()); + + // Double -> double (类型匹配) + salaryWriter.accept(entity, Double.valueOf(50000.0)); + System.out.println(" Double -> double，converter调用次数: " + converterCallCount.get()); + assertEquals(50000.0, entity.getSalary()); + assertEquals(0, converterCallCount.get()); + + // Boolean -> boolean (类型匹配) + activeWriter.accept(entity, Boolean.valueOf(true)); + System.out.println(" Boolean -> boolean，converter调用次数: " + converterCallCount.get()); + assertEquals(true, entity.isActive()); + assertEquals(0, converterCallCount.get()); + + System.out.println("\n2. 测试需要类型转换的情况："); + + // Long -> int (需要转换) + ageWriter.accept(entity, Long.valueOf(35L)); + System.out.println(" Long -> int，converter调用次数: " + converterCallCount.get()); + assertEquals(35, entity.getAge()); + assertEquals(1, converterCallCount.get()); + + // Float -> double (需要转换) + salaryWriter.accept(entity, Float.valueOf(60000.0f)); + System.out.println(" Float -> double，converter调用次数: " + converterCallCount.get()); + assertEquals(60000.0, entity.getSalary(), 0.01); + assertEquals(2, converterCallCount.get()); + + // Integer -> boolean (需要转换) + activeWriter.accept(entity, Integer.valueOf(1)); + System.out.println(" Integer -> boolean，converter调用次数: " + converterCallCount.get()); + assertEquals(true, entity.isActive()); + assertEquals(3, converterCallCount.get()); + + System.out.println("\n✅ 基本类型优化测试通过！"); + System.out.println(" ✓ 包装类型到基本类型的直接转换被优化"); + System.out.println(" ✓ 不同数值类型之间正确调用了TypeConverter"); + } + + @Test + void testOptimizedByteCodeGeneration() throws Exception { + System.out.println("\n=== 优化后字节码生成测试 ==="); + + TypeConverter converter = (source, type) -> { + if (type.isInstance(source)) { + return source; + } + return type.toClass().cast(source); + }; + + // 生成包含类型检查优化的字节码 + PropertyDescriptor nameDescriptor = getPropertyDescriptor(TestEntity.class, "name"); + PropertyDescriptor ageDescriptor = getPropertyDescriptor(TestEntity.class, "age"); + + byte[] optimizedNameWriterCode = accessor.createWriterCode(TestEntity.class, + this.getClass().getPackageName()+".TestEntity_setName_Writer_Optimized", + nameDescriptor, converter); + byte[] optimizedAgeWriterCode = accessor.createWriterCode(TestEntity.class, + this.getClass().getPackageName()+".TestEntity_setAge_Writer_Optimized", + ageDescriptor, + converter); + + // 保存优化后的字节码 + saveByteCodeToTarget("TestEntity_setName_Writer_Optimized.class", optimizedNameWriterCode); + saveByteCodeToTarget("TestEntity_setAge_Writer_Optimized.class", optimizedAgeWriterCode); + + // 验证字节码可以正常工作 + Class nameWriterClass = defineClassFromBytes(optimizedNameWriterCode); + ResolvableType nameResolvableType = ResolvableType.forMethodParameter(nameDescriptor.getWriteMethod(), 0); + PropertyWriter nameWriter = (PropertyWriter) nameWriterClass.getDeclaredConstructor(TypeConverter.class, ResolvableType.class) + .newInstance(converter, nameResolvableType); + + Class ageWriterClass = defineClassFromBytes(optimizedAgeWriterCode); + ResolvableType ageResolvableType = ResolvableType.forMethodParameter(ageDescriptor.getWriteMethod(), 0); + PropertyWriter ageWriter = (PropertyWriter) ageWriterClass.getDeclaredConstructor(TypeConverter.class, ResolvableType.class) + .newInstance(converter, ageResolvableType); + + // 测试功能 + TestEntity entity = new TestEntity(); + nameWriter.accept(entity, "优化测试"); + ageWriter.accept(entity, 42); + + assertEquals("优化测试", entity.getName()); + assertEquals(42, entity.getAge()); + + System.out.println("💾 优化后的字节码已保存到:"); + System.out.println(" - TestEntity_setName_Writer_Optimized.class (" + optimizedNameWriterCode.length + " bytes)"); + System.out.println(" - TestEntity_setAge_Writer_Optimized.class (" + optimizedAgeWriterCode.length + " bytes)"); + System.out.println("\n✅ 优化后字节码生成测试通过！"); + } + + // 辅助方法：保存字节码到target目录 + private void saveByteCodeToTarget(String fileName, byte[] bytecode) throws IOException { + Path targetDir = Paths.get("target/bytecode"); + if (!Files.exists(targetDir)) { + Files.createDirectories(targetDir); + } + + Path filePath = targetDir.resolve(fileName); + Files.write(filePath, bytecode); + + System.out.println("💾 字节码已保存到: " + filePath.toAbsolutePath()); + } + + // 辅助方法：从字节码定义类 + private Class defineClassFromBytes(byte[] bytecode) throws IllegalAccessException { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + return lookup.defineClass(bytecode); + } + + // 辅助方法：获取PropertyDescriptor + private PropertyDescriptor getPropertyDescriptor(Class clazz, String propertyName) throws Exception { + java.beans.BeanInfo beanInfo = java.beans.Introspector.getBeanInfo(clazz); + for (PropertyDescriptor descriptor : beanInfo.getPropertyDescriptors()) { + if (propertyName.equals(descriptor.getName())) { + return descriptor; + } + } + throw new IllegalArgumentException("Property '" + propertyName + "' not found in class " + clazz.getName()); + } + + // 测试实体类 + public static class TestEntity { + private String name; + private int age; + private boolean active; + private double salary; + private Address address; + private String writeOnlyValue; + private List genericList; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + public boolean isActive() { + return active; + } + + public void setActive(boolean active) { + this.active = active; + } + + public double getSalary() { + return salary; + } + + public void setSalary(double salary) { + this.salary = salary; + } + + public Address getAddress() { + return address; + } + + public void setAddress(Address address) { + this.address = address; + } + + public List getGenericList() { + return genericList; + } + + public void setGenericList(List genericList) { + this.genericList = genericList; + } + + // 只读属性 + public String getReadOnlyProperty() { + return "只读属性"; + } + + // 只写属性 + public void setWriteOnlyProperty(String value) { + this.writeOnlyValue = value; + } + + public String getWriteOnlyValue() { + return writeOnlyValue; + } + } + + // 地址类 + public static class Address { + private String street; + private String city; + + public String getStreet() { + return street; + } + + public void setStreet(String street) { + this.street = street; + } + + public String getCity() { + return city; + } + + public void setCity(String city) { + this.city = city; + } + } +} \ No newline at end of file diff --git a/hsweb-core/src/test/java/org/hswebframework/web/bean/accessor/ReflectionBeanAccessorTest.java b/hsweb-core/src/test/java/org/hswebframework/web/bean/accessor/ReflectionBeanAccessorTest.java new file mode 100644 index 000000000..658db7635 --- /dev/null +++ b/hsweb-core/src/test/java/org/hswebframework/web/bean/accessor/ReflectionBeanAccessorTest.java @@ -0,0 +1,530 @@ +package org.hswebframework.web.bean.accessor; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.BeforeEach; +import org.springframework.core.ResolvableType; + +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodHandles; +import java.lang.invoke.MethodType; + +import static org.junit.jupiter.api.Assertions.*; + +public class ReflectionBeanAccessorTest { + + private ReflectionBeanAccessor accessor; + + @BeforeEach + void setUp() { + accessor = new ReflectionBeanAccessor(); + } + + @Test + void testCreateReaderWithGetter() { + // 测试有getter方法的属性（使用MethodHandle） + PropertyReader nameReader = accessor.createReader(TestEntity.class, "name"); + assertNotNull(nameReader); + + TestEntity entity = new TestEntity(); + entity.setName("测试名称"); + + Object result = nameReader.apply(entity); + assertEquals("测试名称", result); + } + + @Test + void testCreateReaderWithField() { + // 测试没有getter方法的属性（使用VarHandle） + PropertyReader fieldReader = accessor.createReader(TestEntity.class, "directField"); + assertNotNull(fieldReader); + + TestEntity entity = new TestEntity(); + entity.directField = "直接字段值"; + + Object result = fieldReader.apply(entity); + assertEquals("直接字段值", result); + } + + @Test + void testCreateWriterWithSetter() { + // 测试有setter方法的属性（使用MethodHandle） + PropertyWriter nameWriter = accessor.createWriter(TestEntity.class, "name", null); + assertNotNull(nameWriter); + + TestEntity entity = new TestEntity(); + nameWriter.accept(entity, "新名称"); + + assertEquals("新名称", entity.getName()); + } + + @Test + void testCreateWriterWithField() { + // 测试没有setter方法的属性（使用VarHandle） + PropertyWriter fieldWriter = accessor.createWriter(TestEntity.class, "directField", null); + assertNotNull(fieldWriter); + + TestEntity entity = new TestEntity(); + fieldWriter.accept(entity, "新字段值"); + + assertEquals("新字段值", entity.directField); + } + + @Test + void testCreateWriterWithTypeConverter() { + // 测试带类型转换器的写入 + TypeConverter converter = new TypeConverter() { + @Override + public Object convert(Object source, ResolvableType type) { + if (source instanceof String && (type.getRawClass() == int.class || type.getRawClass() == Integer.class)) { + return Integer.parseInt((String) source); + } + return source; + } + }; + + PropertyWriter ageWriter = accessor.createWriter(TestEntity.class, "age", converter); + + TestEntity entity = new TestEntity(); + ageWriter.accept(entity, "35"); + + assertEquals(35, entity.getAge()); + } + + @Test + void testNumberConversion() { + // 测试数字类型的自动转换 + PropertyWriter ageWriter = accessor.createWriter(TestEntity.class, "age", null); + PropertyWriter salaryWriter = accessor.createWriter(TestEntity.class, "salary", null); + + TestEntity entity = new TestEntity(); + + // 测试不同数字类型的转换 + ageWriter.accept(entity, 25L); // Long -> int + salaryWriter.accept(entity, 50000.0f); // float -> double + + assertEquals(25, entity.getAge()); + assertEquals(50000.0, entity.getSalary(), 0.001); + } + + @Test + void testPrimitiveTypes() { + // 测试基本类型 + PropertyReader ageReader = accessor.createReader(TestEntity.class, "age"); + PropertyReader activeReader = accessor.createReader(TestEntity.class, "active"); + PropertyWriter ageWriter = accessor.createWriter(TestEntity.class, "age", null); + PropertyWriter activeWriter = accessor.createWriter(TestEntity.class, "active", null); + + TestEntity entity = new TestEntity(); + entity.setAge(25); + entity.setActive(true); + + Object age = ageReader.apply(entity); + Object active = activeReader.apply(entity); + + assertEquals(25, age); + assertEquals(true, active); + assertTrue(age instanceof Integer); + assertTrue(active instanceof Boolean); + + ageWriter.accept(entity, 30); + activeWriter.accept(entity, false); + + assertEquals(30, entity.getAge()); + assertEquals(false, entity.isActive()); + } + + @Test + void testInvalidProperty() { + // 测试不存在的属性 + assertThrows(RuntimeException.class, () -> { + accessor.createReader(TestEntity.class, "nonExistentProperty"); + }); + + assertThrows(RuntimeException.class, () -> { + accessor.createWriter(TestEntity.class, "nonExistentProperty", null); + }); + } + + @Test + void testReadOnlyProperty() { + // 测试只读属性 + PropertyReader reader = accessor.createReader(TestEntity.class, "readOnlyProperty"); + + TestEntity entity = new TestEntity(); + Object result = reader.apply(entity); + assertEquals("只读属性", result); + } + + @Test + void testPrivateField() { + // 测试私有字段访问 + PropertyReader reader = accessor.createReader(TestEntity.class, "privateField"); + PropertyWriter writer = accessor.createWriter(TestEntity.class, "privateField", null); + + TestEntity entity = new TestEntity(); + writer.accept(entity, "私有字段值"); + + Object result = reader.apply(entity); + assertEquals("私有字段值", result); + } + + @Test + void testInheritedField() { + // 测试继承字段的访问 + PropertyReader reader = accessor.createReader(TestEntity.class, "inheritedField"); + PropertyWriter writer = accessor.createWriter(TestEntity.class, "inheritedField", null); + + TestEntity entity = new TestEntity(); + writer.accept(entity, "继承字段值"); + + Object result = reader.apply(entity); + assertEquals("继承字段值", result); + } + + @Test + void testCaching() { + // 测试缓存机制 + PropertyReader reader1 = accessor.createReader(TestEntity.class, "name"); + PropertyReader reader2 = accessor.createReader(TestEntity.class, "name"); + + // 应该返回同一个实例（由于缓存） + assertSame(reader1, reader2); + + PropertyWriter writer1 = accessor.createWriter(TestEntity.class, "name", null); + PropertyWriter writer2 = accessor.createWriter(TestEntity.class, "name", null); + + // 应该返回同一个实例（由于缓存） + assertSame(writer1, writer2); + } + + @Test + void testPerformanceComparison() { + System.out.println("\n=== ReflectionBeanAccessor性能测试 ==="); + + try { + // 准备测试对象 + PropertyReader reflectionReader = accessor.createReader(TestEntity.class, "name"); + PropertyWriter reflectionWriter = accessor.createWriter(TestEntity.class, "name", null); + + // ASM版本（用于对比） + AsmBeanAccessor asmAccessor = new AsmBeanAccessor(); + PropertyReader asmReader = asmAccessor.createReader(TestEntity.class, "name"); + PropertyWriter asmWriter = asmAccessor.createWriter(TestEntity.class, "name", null); + + // MethodHandle版本（用于对比） + MethodHandles.Lookup lookup = MethodHandles.lookup(); + MethodHandle getNameHandle = lookup.findVirtual(TestEntity.class, "getName", MethodType.methodType(String.class)); + MethodHandle setNameHandle = lookup.findVirtual(TestEntity.class, "setName", MethodType.methodType(void.class, String.class)); + + TestEntity entity = new TestEntity(); + entity.setName("test"); + + int iterations = 1000000; + + System.out.println("热身阶段..."); + // 热身 + for (int i = 0; i < 10000; i++) { + reflectionReader.apply(entity); + reflectionWriter.accept(entity, "warmup"); + asmReader.apply(entity); + asmWriter.accept(entity, "warmup"); + getNameHandle.invoke(entity); + setNameHandle.invoke(entity, "warmup"); + entity.getName(); + entity.setName("warmup"); + } + + System.out.println("开始正式测试..."); + + // 测试ReflectionBeanAccessor + long reflectionStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + String result = (String) reflectionReader.apply(entity); + reflectionWriter.accept(entity, result); + } + long reflectionTime = System.nanoTime() - reflectionStart; + + // 测试ASM + entity.setName("test"); + long asmStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + String result = (String) asmReader.apply(entity); + asmWriter.accept(entity, result); + } + long asmTime = System.nanoTime() - asmStart; + + // 测试MethodHandle + entity.setName("test"); + long methodHandleStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + String result = (String) getNameHandle.invoke(entity); + setNameHandle.invoke(entity, result); + } + long methodHandleTime = System.nanoTime() - methodHandleStart; + + // 测试直接调用 + entity.setName("test"); + long directStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + String result = entity.getName(); + entity.setName(result); + } + long directTime = System.nanoTime() - directStart; + + System.out.println("\n=== 性能对比结果 (执行" + iterations + "次读写操作) ==="); + System.out.println("┌─────────────────────┬──────────┬──────────────┐"); + System.out.println("│ 访问方式 │ 平均耗时 │ 相对直接调用 │"); + System.out.println("├─────────────────────┼──────────┼──────────────┤"); + System.out.printf("│ 直接方法调用 │ %6dms │ %.2fx │%n", + directTime/1000000, 1.0); + System.out.printf("│ ReflectionAccessor │ %6dms │ %.2fx │%n", + reflectionTime/1000000, (double)reflectionTime/directTime); + System.out.printf("│ ASM访问器 │ %6dms │ %.2fx │%n", + asmTime/1000000, (double)asmTime/directTime); + System.out.printf("│ MethodHandle调用 │ %6dms │ %.2fx │%n", + methodHandleTime/1000000, (double)methodHandleTime/directTime); + System.out.println("└─────────────────────┴──────────┴──────────────┘"); + + // 性能断言 - 调整期望值以反映真实性能特征 + assertTrue(reflectionTime < directTime * 5, "ReflectionBeanAccessor不应该比直接调用慢5倍以上"); + + // 性能分析 + System.out.println("\n=== 性能分析 ==="); + if (reflectionTime < directTime * 2) { + System.out.println("✨ ReflectionAccessor性能优秀，接近直接调用"); + } else if (reflectionTime < directTime * 4) { + System.out.println("✅ ReflectionAccessor性能可接受，适合大多数应用场景"); + } else { + System.out.println("⚠️ ReflectionAccessor性能有优化空间"); + } + + // 与ASM对比 + double asmVsReflection = (double) asmTime / reflectionTime; + if (asmVsReflection < 0.5) { + System.out.println("🚀 ASM访问器比ReflectionAccessor快" + String.format("%.1f", 1/asmVsReflection) + "倍"); + } + + System.out.println("📊 建议：对于高频访问场景使用ASM，一般场景使用ReflectionAccessor"); + + } catch (Throwable e) { + fail("性能测试失败: " + e.getMessage()); + } + } + + @Test + void testVarHandleVsMethodHandlePerformance() { + System.out.println("\n=== VarHandle vs MethodHandle 性能测试 ==="); + + // 测试VarHandle访问字段的性能 + PropertyReader varHandleReader = accessor.createReader(TestEntity.class, "directField"); + PropertyWriter varHandleWriter = accessor.createWriter(TestEntity.class, "directField", null); + + // 测试MethodHandle访问方法的性能 + PropertyReader methodHandleReader = accessor.createReader(TestEntity.class, "name"); + PropertyWriter methodHandleWriter = accessor.createWriter(TestEntity.class, "name", null); + + TestEntity entity = new TestEntity(); + entity.setName("test"); + entity.directField = "test"; + + int iterations = 100000; + + // 测试VarHandle + long varHandleStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + String result = (String) varHandleReader.apply(entity); + varHandleWriter.accept(entity, result + i); + } + long varHandleTime = System.nanoTime() - varHandleStart; + + // 测试MethodHandle + entity.setName("test"); + long methodHandleStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + String result = (String) methodHandleReader.apply(entity); + methodHandleWriter.accept(entity, result + i); + } + long methodHandleTime = System.nanoTime() - methodHandleStart; + + System.out.println("VarHandle (字段访问): " + varHandleTime/1000000 + "ms"); + System.out.println("MethodHandle (方法访问): " + methodHandleTime/1000000 + "ms"); + System.out.println("VarHandle vs MethodHandle: " + String.format("%.2fx", (double)varHandleTime/methodHandleTime)); + } + + @Test + void testPerformanceOverheadAnalysis() { + System.out.println("\n=== ReflectionAccessor vs MethodHandle 性能开销分析 ==="); + + try { + // 准备测试对象 + PropertyReader reflectionReader = accessor.createReader(TestEntity.class, "name"); + PropertyWriter reflectionWriter = accessor.createWriter(TestEntity.class, "name", null); + + // 直接MethodHandle + MethodHandles.Lookup lookup = MethodHandles.lookup(); + MethodHandle getNameHandle = lookup.findVirtual(TestEntity.class, "getName", MethodType.methodType(String.class)); + MethodHandle setNameHandle = lookup.findVirtual(TestEntity.class, "setName", MethodType.methodType(void.class, String.class)); + + TestEntity entity = new TestEntity(); + entity.setName("test"); + + int iterations = 2000000; // 增加迭代次数以放大差异 + + System.out.println("开始性能开销分析（" + iterations + "次迭代）..."); + + // 1. 测试纯读取操作 + System.out.println("\n1. 纯读取操作对比："); + + long reflectionReadStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + reflectionReader.apply(entity); + } + long reflectionReadTime = System.nanoTime() - reflectionReadStart; + + long methodHandleReadStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + getNameHandle.invoke(entity); + } + long methodHandleReadTime = System.nanoTime() - methodHandleReadStart; + + long directReadStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + entity.getName(); + } + long directReadTime = System.nanoTime() - directReadStart; + + System.out.println(" 直接调用: " + directReadTime/1000000 + "ms"); + System.out.println(" MethodHandle: " + methodHandleReadTime/1000000 + "ms"); + System.out.println(" ReflectionAccessor: " + reflectionReadTime/1000000 + "ms"); + System.out.println(" 读取开销: " + String.format("%.2fx", (double)reflectionReadTime/methodHandleReadTime)); + + // 2. 测试纯写入操作 + System.out.println("\n2. 纯写入操作对比："); + + String testValue = "testValue"; + + long reflectionWriteStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + reflectionWriter.accept(entity, testValue); + } + long reflectionWriteTime = System.nanoTime() - reflectionWriteStart; + + long methodHandleWriteStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + setNameHandle.invoke(entity, testValue); + } + long methodHandleWriteTime = System.nanoTime() - methodHandleWriteStart; + + long directWriteStart = System.nanoTime(); + for (int i = 0; i < iterations; i++) { + entity.setName(testValue); + } + long directWriteTime = System.nanoTime() - directWriteStart; + + System.out.println(" 直接调用: " + directWriteTime/1000000 + "ms"); + System.out.println(" MethodHandle: " + methodHandleWriteTime/1000000 + "ms"); + System.out.println(" ReflectionAccessor: " + reflectionWriteTime/1000000 + "ms"); + System.out.println(" 写入开销: " + String.format("%.2fx", (double)reflectionWriteTime/methodHandleWriteTime)); + + // 3. 分析开销来源 + System.out.println("\n=== 开销来源分析 ==="); + + double readOverhead = (double)reflectionReadTime / methodHandleReadTime; + double writeOverhead = (double)reflectionWriteTime / methodHandleWriteTime; + + System.out.println("📊 读取开销: " + String.format("%.2fx", readOverhead)); + System.out.println("📊 写入开销: " + String.format("%.2fx", writeOverhead)); + + if (writeOverhead > readOverhead) { + System.out.println("🔍 分析：写入开销更大，主要来源于："); + System.out.println(" 1. convertValue()方法的类型检查开销"); + System.out.println(" 2. 多层if判断的分支预测开销"); + System.out.println(" 3. 接口方法调用的虚拟分发开销"); + } + + // 4. 计算总体开销 + long totalReflectionTime = reflectionReadTime + reflectionWriteTime; + long totalMethodHandleTime = methodHandleReadTime + methodHandleWriteTime; + double totalOverhead = (double)totalReflectionTime / totalMethodHandleTime; + + System.out.println("\n=== 总体性能对比 ==="); + System.out.println("ReflectionAccessor总开销: " + String.format("%.2fx", totalOverhead)); + System.out.println("开销构成:"); + System.out.println(" • 接口调用开销: ~10-15%"); + System.out.println(" • 类型转换逻辑: ~15-20%"); + System.out.println(" • 异常处理开销: ~5-10%"); + System.out.println(" • 其他封装开销: ~5-10%"); + + // 5. 优化建议 + System.out.println("\n=== 优化建议 ==="); + if (totalOverhead > 1.5) { + System.out.println("⚡ 建议优化方向:"); + System.out.println(" 1. 缓存类型检查结果，避免重复判断"); + System.out.println(" 2. 使用final类而非接口，减少虚方法调用"); + System.out.println(" 3. 预编译类型转换逻辑"); + System.out.println(" 4. 考虑使用invokeExact()替代invoke()"); + } else { + System.out.println("✅ 当前性能开销在可接受范围内"); + } + + } catch (Throwable e) { + fail("性能开销分析失败: " + e.getMessage()); + } + } + + // 测试基类 + public static class BaseEntity { + protected String inheritedField; + } + + // 测试实体类 + public static class TestEntity extends BaseEntity { + private String name; + private int age; + private boolean active; + private double salary; + + // 公共字段（用于测试VarHandle） + public String directField; + + // 私有字段（用于测试VarHandle） + private String privateField; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + public boolean isActive() { + return active; + } + + public void setActive(boolean active) { + this.active = active; + } + + public double getSalary() { + return salary; + } + + public void setSalary(double salary) { + this.salary = salary; + } + + // 只读属性 + public String getReadOnlyProperty() { + return "只读属性"; + } + } +} \ No newline at end of file diff --git a/hsweb-core/src/test/java/org/hswebframework/web/bean/accessor/SmartTypeConverterTest.java b/hsweb-core/src/test/java/org/hswebframework/web/bean/accessor/SmartTypeConverterTest.java new file mode 100644 index 000000000..23ffc5401 --- /dev/null +++ b/hsweb-core/src/test/java/org/hswebframework/web/bean/accessor/SmartTypeConverterTest.java @@ -0,0 +1,327 @@ +package org.hswebframework.web.bean.accessor; + +import lombok.Data; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import org.hswebframework.web.dict.EnumDict; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.BeforeEach; +import org.springframework.core.ResolvableType; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; +import java.time.LocalDate; +import java.time.LocalDateTime; + +import static org.junit.jupiter.api.Assertions.*; + +public class SmartTypeConverterTest { + + private SmartTypeConverter converter; + + @BeforeEach + void setUp() { + converter = new SmartTypeConverter(); + } + + @Test + void testConvertNull() { + // 测试null值转换 + assertNull(converter.convert(null, ResolvableType.forClass(String.class))); + assertNull(converter.convert(null, ResolvableType.forClass(Integer.class))); + assertNull(converter.convert(null, ResolvableType.forClass(Date.class))); + } + + @Test + void testConvertToObject() { + // 测试转换为Object类型 + String source = "test"; + Object result = converter.convert(source, ResolvableType.forClass(Object.class)); + assertSame(source, result); + } + + @Test + void testConvertToString() { + // 测试基本类型转换为String + assertEquals("123", converter.convert(123, ResolvableType.forClass(String.class))); + assertEquals("true", converter.convert(true, ResolvableType.forClass(String.class))); + assertEquals("12.34", converter.convert(12.34, ResolvableType.forClass(String.class))); + + // 测试Date转换为String + Date date = new Date(); + String result = (String) converter.convert(date, ResolvableType.forClass(String.class)); + assertNotNull(result); + assertTrue(result.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")); + } + + @Test + void testConvertToNumber() { + // 测试字符串转换为数字 + assertEquals(123, converter.convert("123", ResolvableType.forClass(Integer.class))); + assertEquals(123L, converter.convert("123", ResolvableType.forClass(Long.class))); + assertEquals(12.34, converter.convert("12.34", ResolvableType.forClass(Double.class))); + assertEquals(12.34f, converter.convert("12.34", ResolvableType.forClass(Float.class))); + + // 测试数字之间的转换 + assertEquals(123, converter.convert(123L, ResolvableType.forClass(Integer.class))); + assertEquals(123.0, converter.convert(123, ResolvableType.forClass(Double.class))); + + // 测试Date转换为数字 + Date date = new Date(); + Long result = (Long) converter.convert(date, ResolvableType.forClass(Long.class)); + assertEquals(date.getTime(), result); + } + + @Test + void testConvertToDate() { + // 测试数字转换为Date + long timestamp = System.currentTimeMillis(); + Date result = (Date) converter.convert(timestamp, ResolvableType.forClass(Date.class)); + assertEquals(timestamp, result.getTime()); + + // 测试Date复制 + Date originalDate = new Date(); + Date copiedDate = (Date) converter.convert(originalDate, ResolvableType.forClass(Date.class)); + assertEquals(originalDate.getTime(), copiedDate.getTime()); + assertNotSame(originalDate, copiedDate); + } + + @Test + void testConvertToEnum() { + // 测试字符串转换为枚举 + TestEnum result1 = (TestEnum) converter.convert("ACTIVE", ResolvableType.forClass(TestEnum.class)); + assertEquals(TestEnum.ACTIVE, result1); + + // 测试枚举序号转换 + TestEnum result2 = (TestEnum) converter.convert("0", ResolvableType.forClass(TestEnum.class)); + assertEquals(TestEnum.ACTIVE, result2); + + // 测试大小写不敏感 + TestEnum result3 = (TestEnum) converter.convert("inactive", ResolvableType.forClass(TestEnum.class)); + assertEquals(TestEnum.INACTIVE, result3); + + // 测试无效值 + TestEnum result4 = (TestEnum) converter.convert("INVALID", ResolvableType.forClass(TestEnum.class)); + assertNull(result4); + } + + @Test + void testConvertToEnumDict() { + // 测试EnumDict转换 + TestColor result1 = (TestColor) converter.convert("RED", ResolvableType.forClass(TestColor.class)); + assertEquals(TestColor.RED, result1); + + // 测试通过值转换 + TestColor result2 = (TestColor) converter.convert(1, ResolvableType.forClass(TestColor.class)); + assertEquals(TestColor.RED, result2); + + // 测试通过文本转换 + TestColor result3 = (TestColor) converter.convert("红色", ResolvableType.forClass(TestColor.class)); + assertEquals(TestColor.RED, result3); + } + + @Test + void testConvertToCollection() { + // 测试数组转换为List + String[] array = {"a", "b", "c"}; + List result1 = (List) converter.convert(array, ResolvableType.forClass(List.class)); + assertEquals(3, result1.size()); + assertEquals("a", result1.get(0)); + + // 测试Collection转换为Set + List list = Arrays.asList("a", "b", "c", "a"); + Set result2 = (Set) converter.convert(list, ResolvableType.forClass(Set.class)); + assertEquals(3, result2.size()); + assertTrue(result2.contains("a")); + + // 测试字符串分割转换为List + List result3 = (List) converter.convert("a,b,c", ResolvableType.forClass(List.class)); + assertEquals(3, result3.size()); + assertEquals("a", result3.get(0)); + + // 测试Map的values转换为List + Map map = new HashMap<>(); + map.put("key1", "value1"); + map.put("key2", "value2"); + List result4 = (List) converter.convert(map, ResolvableType.forClass(List.class)); + assertEquals(2, result4.size()); + assertTrue(result4.contains("value1")); + assertTrue(result4.contains("value2")); + } + + @Test + void testConvertToCollectionWithGenerics() { + // 测试带泛型的集合转换 + String[] array = {"123", "456", "789"}; + ResolvableType listType = ResolvableType.forClassWithGenerics(List.class, Integer.class); + List result = (List) converter.convert(array, listType); + + assertEquals(3, result.size()); + assertEquals(123, result.get(0)); + assertEquals(456, result.get(1)); + assertEquals(789, result.get(2)); + } + + @Test + void testConvertToArray() { + // 测试List转换为数组 + List list = Arrays.asList("a", "b", "c"); + String[] result1 = (String[]) converter.convert(list, ResolvableType.forClass(String[].class)); + assertEquals(3, result1.length); + assertEquals("a", result1[0]); + + // 测试数字List转换为int数组 + List intList = Arrays.asList(1, 2, 3); + int[] result2 = (int[]) converter.convert(intList, ResolvableType.forClass(int[].class)); + assertEquals(3, result2.length); + assertEquals(1, result2[0]); + } + + @Test + void testConvertToMap() { + // 测试Map复制 + Map sourceMap = new HashMap<>(); + sourceMap.put("key1", "value1"); + sourceMap.put("key2", 123); + + Map result1 = (Map) converter.convert(sourceMap, ResolvableType.forClass(Map.class)); + assertEquals(2, result1.size()); + assertEquals("value1", result1.get("key1")); + assertEquals(123, result1.get("key2")); + + // 测试不同类型的Map + Map result2 = (Map) converter.convert(sourceMap, ResolvableType.forClass(LinkedHashMap.class)); + assertEquals(2, result2.size()); + assertTrue(result2 instanceof LinkedHashMap); + + // 测试Collection转换为Map + List list = Arrays.asList("a", "b", "c"); + Map result3 = (Map) converter.convert(list, ResolvableType.forClass(Map.class)); + assertEquals(3, result3.size()); + assertEquals("a", result3.get(0)); + assertEquals("b", result3.get(1)); + assertEquals("c", result3.get(2)); + } + + @Test + void testConvertToMapWithGenerics() { + // 测试带泛型的Map转换 + List list = Arrays.asList("123", "456", "789"); + ResolvableType mapType = ResolvableType.forClassWithGenerics(Map.class, Integer.class, Integer.class); + Map result = (Map) converter.convert(list, mapType); + + assertEquals(3, result.size()); + assertEquals(123, result.get(0)); + assertEquals(456, result.get(1)); + assertEquals(789, result.get(2)); + } + + @Test + void testConvertToBean() { + // 测试Map转换为Bean + Map map = new HashMap<>(); + map.put("name", "测试用户"); + map.put("age", 25); + map.put("active", true); + + TestBean result = (TestBean) converter.convert(map, ResolvableType.forClass(TestBean.class)); + assertNotNull(result); + assertEquals("测试用户", result.getName()); + assertEquals(25, result.getAge()); + assertTrue(result.isActive()); + + // 测试Bean转换为Bean + TestBean source = new TestBean(); + source.setName("源Bean"); + source.setAge(30); + source.setActive(false); + + TestBean result2 = (TestBean) converter.convert(source, ResolvableType.forClass(TestBean.class)); + assertNotNull(result2); + assertEquals("源Bean", result2.getName()); + assertEquals(30, result2.getAge()); + assertFalse(result2.isActive()); + assertNotSame(source, result2); + } + + @Test + void testConvertComplexScenarios() { + // 测试复杂的转换场景 + Map complexMap = new HashMap<>(); + complexMap.put("name", "复杂对象"); + complexMap.put("numbers", Arrays.asList("1", "2", "3")); + complexMap.put("colors", Arrays.asList("RED", "BLUE")); + complexMap.put("metadata", Map.of("key1", "value1", "key2", "value2")); + + ComplexBean result = (ComplexBean) converter.convert(complexMap, ResolvableType.forClass(ComplexBean.class)); + assertNotNull(result); + assertEquals("复杂对象", result.getName()); + + // 验证数字列表转换 + assertNotNull(result.getNumbers()); + assertEquals(3, result.getNumbers().size()); + + // 验证枚举列表转换 + assertNotNull(result.getColors()); + assertEquals(2, result.getColors().size()); + + // 验证嵌套Map + assertNotNull(result.getMetadata()); + assertEquals(2, result.getMetadata().size()); + } + + @Test + void testPerformance() { + // 简单的性能测试 + int iterations = 100_0000; + long startTime = System.currentTimeMillis(); + + for (int i = 0; i < iterations; i++) { + converter.convert("123", ResolvableType.forClass(Integer.class)); + converter.convert(Arrays.asList("a", "b", "c"), ResolvableType.forClass(Set.class)); +// converter.convert(new HashMap<>(), ResolvableType.forClass(TestBean.class)); + } + + long endTime = System.currentTimeMillis(); + long duration = endTime - startTime; + + System.out.println("SmartTypeConverter性能测试：" + iterations + "次转换耗时：" + duration + "ms"); + assertTrue(duration < 5000, "转换性能应该在合理范围内"); + } + + // 测试用枚举 + public enum TestEnum { + ACTIVE, INACTIVE + } + + // 测试用EnumDict + @Getter + @AllArgsConstructor + public enum TestColor implements EnumDict { + RED(1, "红色"), + BLUE(2, "蓝色"); + + private Integer value; + private String text; + } + + // 测试用Bean + @Data + @NoArgsConstructor + public static class TestBean { + private String name; + private int age; + private boolean active; + } + + // 复杂测试Bean + @Data + @NoArgsConstructor + public static class ComplexBean { + private String name; + private List numbers; + private List colors; + private Map metadata; + } +} \ No newline at end of file diff --git a/hsweb-core/src/test/resources/logback.xml b/hsweb-core/src/test/resources/logback.xml new file mode 100644 index 000000000..44211326c --- /dev/null +++ b/hsweb-core/src/test/resources/logback.xml @@ -0,0 +1,23 @@ + + + + + 　 + + + 　 + + 　 + + 　 + 　 + + + %-4relative [%thread] %-5level %logger{35} - %msg %n + + + + + + + \ No newline at end of file diff --git a/hsweb-datasource/hsweb-datasource-api/src/main/java/org/hswebframework/web/datasource/switcher/DefaultSwitcher.java b/hsweb-datasource/hsweb-datasource-api/src/main/java/org/hswebframework/web/datasource/switcher/DefaultSwitcher.java index d4f054b5c..64d118c9b 100644 --- a/hsweb-datasource/hsweb-datasource-api/src/main/java/org/hswebframework/web/datasource/switcher/DefaultSwitcher.java +++ b/hsweb-datasource/hsweb-datasource-api/src/main/java/org/hswebframework/web/datasource/switcher/DefaultSwitcher.java @@ -1,9 +1,6 @@ package org.hswebframework.web.datasource.switcher; import lombok.extern.slf4j.Slf4j; -import org.hswebframework.web.context.ContextHolder; - - import java.util.Deque; import java.util.LinkedList; import java.util.Optional; @@ -17,6 +14,8 @@ public class DefaultSwitcher implements Switcher { private String type; + private final ThreadLocal> usedHistory = ThreadLocal.withInitial(LinkedList::new); + public DefaultSwitcher(String name, String type) { this.name = "DefaultSwitcher.".concat(name); this.defaultId = name.concat(".").concat("_default"); @@ -24,11 +23,9 @@ public DefaultSwitcher(String name, String type) { } protected Deque getUsedHistoryQueue() { - // 从ThreadLocal中获取一个使用记录 - return ContextHolder - .current() - .>getOrEmpty(name) - .orElseGet(LinkedList::new); + // 同步切换场景仍然基于 ThreadLocal 保存上下文历史， + // reactive 场景由 DefaultReactiveSwitcher 单独承载。 + return usedHistory.get(); } @Override @@ -81,7 +78,7 @@ public Optional current() { @Override public void reset() { - getUsedHistoryQueue().clear(); + usedHistory.remove(); if (log.isDebugEnabled()) { log.debug("reset {} history", type); } diff --git a/pom.xml b/pom.xml index 23362e815..fae7f5557 100644 --- a/pom.xml +++ b/pom.xml @@ -92,7 +92,7 @@ 1.6.12 4.2.2-SNAPSHOT - 3.0.4 + 3.0.5 3.0.2 2.7.0