class ClassProperty {

        @Getter
        protected String name;

        @Getter
        protected String readMethodName;

        @Getter
        protected String writeMethodName;

        @Getter
        protected BiFunction<Class<?>, Class<?>, String> getter;

        @Getter
        protected BiFunction<Class<?>, 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<?>, Class<?>, String> createGetterFunction() {<FILL_FUNCTION_BODY>}

        public BiFunction<Class<?>, String, String> createSetterFunction(Function<String, String> 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);
        }
    }


            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();
            };
        
<no_super_class>