工具类--BeanUtils----Bean转换工具

package com.zhouyy.netBank.util;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.springframework.beans.BeansException;
import org.springframework.beans.FatalBeanException;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.CollectionUtils;

import com.zhouyy.netBank.framework.cglib.beans.BeanCopier;
import com.zhouyy.netBank.framework.cglib.beans.BeanMap;

/**
 * Bean转换工具
 *
 * @author zhouyy
 * @version 0.0.5
 */
public abstract class BeanUtils extends org.springframework.beans.BeanUtils {

    private static final Map<String, BeanCopier> BEAN_COPIER_MAP = new ConcurrentHashMap<>();
    private static final Map<String, BeanCopier> NONE_NULL_BEAN_COPIER_MAP = new ConcurrentHashMap<>();

    /**
     * MAP集合转成bean对象集合
     *
     * @param listResult 需要拷贝的集合
     * @param clazz      需要将map转换成的Class
     * @param <B>        泛型
     * @return 集合泛型
     * @author zhouyy
     */
    public static <B> List<B> copyMapListProperties(List listResult, Class<B> clazz) {
        List<B> sourceList = new ArrayList<>();
        Map<String, Object> cacheMap = new HashMap<>();
        //遍历MAP结果集
        for (Object obj : listResult) {
            Map map = (Map) obj;
            B source = copyMapProperties(map, clazz, cacheMap);
//            if (null != clazz) {
//                source = copyMapProperties(map, clazz, cacheMap);
//            } else {
//                Map<String, Object> newMap = new HashMap<>();
//                Iterator<Map.Entry<String, Object>> entries = map.entrySet().iterator();
//                while (entries.hasNext()) {
//                    Map.Entry<String, Object> entry = entries.next();
//                    newMap.put(entry.getKey().toLowerCase(), entry.getValue());
//                }
//                source = (B) newMap;
//            }
            sourceList.add(source);
        }
        return sourceList;
    }

    /**
     * MAP转成bean对象集合
     *
     * @param map
     * @param clazz
     * @param <B>
     * @return
     * @author zhouyy
     */
    public static <B> B copyMapProperties(Map map, Class<B> clazz) {
        Map<String, Object> cacheMap = new HashMap<>();
        return copyMapProperties(map, clazz, cacheMap);
    }

    /**
     * 递归获取当前class的所有父类中的属性
     *
     * @param clazz     需要获取的类
     * @param fieldList 字段集合
     */
    public static void getAllFields(Class<?> clazz, List<Field> fieldList) {
        Class superClass = clazz.getSuperclass();
        if (superClass != Object.class) {
            getAllFields(superClass, fieldList);
        }
        Field[] fields = clazz.getDeclaredFields();
        fieldList.addAll(Arrays.asList(fields));
    }

    /**
     * MAP转成bean对象集合
     *
     * @param map
     * @param clazz
     * @param cacheMap
     * @param <B>
     * @return
     * @author zhouyy
     */
    @SuppressWarnings("unchecked")
    private static <B> B copyMapProperties(Map map, Class<B> clazz, Map<String, Object> cacheMap) {
        Assert.notNull(map, "map must not be null");
        Assert.notNull(clazz, "clazz must not be null");

        B instantiate = instantiate(clazz);
        BeanMap beanMap = BeanMap.create(instantiate, true);
        beanMap.putAll(map);
        return instantiate;

//        List<Field> fieldList = (List<Field>) cacheMap.get(clazz);
//        if (fieldList == null) {
//            fieldList = new ArrayList<>();
//            getAllFields(clazz, fieldList);
//        }
//
//        B source = null;
//        try {
//            source = clazz.newInstance();
//        } catch (InstantiationException | IllegalAccessException e) {
//            e.printStackTrace();
//        }
//        //遍历结果MAP
//        Iterator<Map.Entry<String, Object>> it = map.entrySet().iterator();
//        while (it.hasNext()) {
//            Map.Entry<String, Object> entry = it.next();
//            //遍历映射实体属性
//            for (Field field : fieldList) {
//                String key = entry.getKey();
//                Boolean flag = (Boolean) cacheMap.get(key + field.getName());
//                if (flag == null) {
//                    flag = !key.replace("_", "").equalsIgnoreCase(field.getName());
//                    cacheMap.put(key + field.getName(), flag);
//                }
//                if (flag) {
//                    continue;
//                }
//
//                Object value = entry.getValue();
//                Class typeClass = field.getType();
//                Object valueType = setFieldValueByFieldType(value, typeClass);
//                ReflectionUtils.makeAccessible(field);
//                ReflectionUtils.setField(field, source, valueType);
//            }
//        }
//        return source;
    }

    //    private static Object setFieldValueByFieldType(Object value, Class typeClass) {
//        //这里去掉typeClass == double.class是为了代码规范，保证bean中的属性使用包装类
//        if ((value instanceof Character) && typeClass == String.class) {
//            Character character = (Character) value;
//            value = character.toString();
//        }else if(value instanceof Number){
//            Number number = (Number) value;
//            if (typeClass == BigDecimal.class) {
//                value = BigDecimal.valueOf(number.doubleValue());
//            } else if (typeClass == BigInteger.class) {
//                value = BigInteger.valueOf(number.longValue());
//            } else if (typeClass == Long.class) {
//                value = number.longValue();
//            } else if (typeClass == Integer.class) {
//                value = number.intValue();
//            } else if (typeClass == Double.class) {
//                value = number.doubleValue();
//            } else if (typeClass == Float.class) {
//                value = number.floatValue();
//            } else if (typeClass == Short.class) {
//                value = number.shortValue();
//            } else if (typeClass == Byte.class) {
//                value = number.byteValue();
//            } else {
//                value = number;
//            }
//        }
//        return value;
//    }
    private static String getBeanCopierCacheKey(Class source, Class target) {
        return source.getName() + "|" + target.getName();
    }

    private static BeanCopier getBeanCopier(Class source, Class target) {
        String beanCopierCacheKey = getBeanCopierCacheKey(source, target);
        BeanCopier beanCopier = BEAN_COPIER_MAP.get(beanCopierCacheKey);
        if (beanCopier == null) {
            beanCopier = BeanCopier.create(source, target, false);
            BEAN_COPIER_MAP.put(beanCopierCacheKey, beanCopier);
        }
        return beanCopier;
    }

    private static BeanCopier getNoneNullBeanCopier(Class source, Class target) {
        String beanCopierCacheKey = getBeanCopierCacheKey(source, target);
        BeanCopier beanCopier = NONE_NULL_BEAN_COPIER_MAP.get(getBeanCopierCacheKey(source, target));
        if (beanCopier == null) {
            beanCopier = BeanCopier.create(source, target, false, true);
            NONE_NULL_BEAN_COPIER_MAP.put(beanCopierCacheKey, beanCopier);
        }
        return beanCopier;
    }

    /**
     * 作者：zhouyy
     * 批量转换List<Bean>
     *
     * @param source list集合
     * @param t      所成对象的class
     * @param <B>
     * @return List<T>
     * @throws BeansException
     */
    public static <S, B> List<B> copyListProperties(List<S> source, Class<B> t) throws BeansException {
        List<B> list = new ArrayList<>();
        if (CollectionUtils.isEmpty(source)) {
            return list;
        }

        BeanCopier beanCopier = getBeanCopier(source.get(0).getClass(), t);
        for (Object o : source) {
            B instantiate = instantiate(t);
            beanCopier.copy(o, instantiate, null);
//            copyProperties(o, instantiate);
            list.add(instantiate);
        }
        return list;
//        List<B> list = new ArrayList<>();
//        if (source == null) {
//            return list;
//        }
//        try {
//            for (Object o : source) {
//                B tObj = t.newInstance();
//                copyProperties(o, tObj);
//                list.add(tObj);
//            }
//        } catch (InstantiationException | IllegalAccessException e) {
//            e.printStackTrace();
//        }
//        return list;
    }


    public static Map<String, Object> beanToMap(Object obj) {
        BeanMap beanMap = BeanMap.create(obj);
        HashMap<String, Object> copy = new HashMap<>();
        for (Object key : beanMap.keySet()) {
            copy.put((String) key, beanMap.get(key));
        }
        return copy;
//        if (obj == null) {
//            return null;
//        }
//        Map<String, Object> map = new HashMap<>();
//        try {
//            BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
//            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
//            for (PropertyDescriptor property : propertyDescriptors) {
//                String key = property.getName();
//                // 过滤class属性
//                if (!key.equals("class")) {
//                    // 得到property对应的getter方法
//                    Method getter = property.getReadMethod();
//                    Object value = getter.invoke(obj);
//
//                    map.put(key, value);
//                }
//            }
//        } catch (Exception e) {
//            logger.error("transBean2Map Error {}", e);
//        }
//        return map;
    }

    /**
     * 将两个对象集合合并，并且转换为Map集合
     *
     * @param listA 对象集合A
     * @param listB 对象集合B
     * @param key   根据对象中的哪个值进行合并
     * @return 合并后的Map集合
     */
    public static List<Map<String, Object>> mergeListBeanToMap(List<?> listA, List<?> listB, String key) {
        List<Map<String, Object>> list = new ArrayList<>();
        for (Object objA : listA) {
            //将对象转换为Map
            Map<String, Object> mapA = beanToMap(objA);
            for (Object objB : listB) {
                //将对象转换为Map
                Map<String, Object> mapB = beanToMap(objB);
                //如果对象A和对象B的值一直，则合并两个对象Map
                if (mapA.get(key).equals(mapB.get(key))) {
                    mapA.putAll(mapB);
                }
            }
            //如果集合中不存在Map，则往List中追加合并后的Map
            if (!list.contains(mapA)) {
                list.add(mapA);
            }
        }
        return list;
    }

    /**
     * 将两个对象转换为map并做合并操作
     *
     * @param objA 对象A
     * @param objB 对象B
     * @param key  根据什么属性合并，属性名
     * @return 合并后的Map
     */
    public static Map<String, Object> mergeBeanToMap(Object objA, Object objB, String key) {
        if (objA == null) {
            return null;
        }
        Map<String, Object> mapA = beanToMap(objA);
        if (objB == null) {
            return mapA;
        }
        Map<String, Object> mapB = beanToMap(objB);
        if (mapA.get(key).equals(mapB.get(key))) {
            mapA.putAll(mapB);
        }
        return mapA;
    }

    /**
     * 把source和target相同属性的value复制到target中
     *
     * @param source 准备赋值对象
     * @param target 被赋值对象
     * @throws BeansException
     */
    public static void copyNotNullProperties(Object source, Object target) throws BeansException {
        BeanCopier noneNullBeanCopier = getNoneNullBeanCopier(source.getClass(), target.getClass());
        noneNullBeanCopier.copy(source, target, null);
//        copyProperties(source, target, null, null);
    }

    public static void copyNotNullProperties(Object source, Object target, String... ignoreProperties) throws BeansException {
        copyProperties(source, target, null, ignoreProperties);
    }

    public static <B> B copyNewInstanceProperties(Object source, Class<B> t) throws BeansException {
        BeanCopier beanCopier = getBeanCopier(source.getClass(), t);
        B instantiate = instantiate(t);
        beanCopier.copy(source, instantiate, null);
        return instantiate;
//        B tObj = null;
//        try {
//            tObj = t.newInstance();
//        } catch (InstantiationException | IllegalAccessException e) {
//            logger.error("copyNewInstanceProperties Error {}", e);
//        }
//        copyProperties(source, tObj);
//        return tObj;
    }

    private static void copyProperties(Object source, Object target, Class<?> editable, String... ignoreProperties) throws BeansException {

        Assert.notNull(source, "Source must not be null");
        Assert.notNull(target, "Target must not be null");

        Class<?> actualEditable = target.getClass();
        if (editable != null) {
            if (!editable.isInstance(target)) {
                throw new IllegalArgumentException("Target class [" + target.getClass().getName() +
                        "] not assignable to Editable class [" + editable.getName() + "]");
            }
            actualEditable = editable;
        }
        PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
        List<String> ignoreList = (ignoreProperties != null) ? Arrays.asList(ignoreProperties) : null;

        for (PropertyDescriptor targetPd : targetPds) {
            Method writeMethod = targetPd.getWriteMethod();
            if (writeMethod != null && (ignoreProperties == null || (!ignoreList.contains(targetPd.getName())))) {
                PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
                if (sourcePd != null) {
                    Method readMethod = sourcePd.getReadMethod();
                    if (readMethod != null &&
                            ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {
                        try {
                            if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
                                readMethod.setAccessible(true);
                            }
                            Object value = readMethod.invoke(source);
                            if (value != null) {  //只拷贝不为null的属性
                                if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
                                    writeMethod.setAccessible(true);
                                }
                                writeMethod.invoke(target, value);
                            }
                        } catch (Throwable ex) {
                            throw new FatalBeanException(
                                    "Could not copy property '" + targetPd.getName() + "' from source to target", ex);
                        }
                    }
                }
            }
        }
    }
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.zhouyy.netBank.framework.cglib.beans;

import org.springframework.asm.ClassVisitor;
import org.springframework.asm.Label;
import org.springframework.asm.Type;
import org.springframework.cglib.core.*;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Modifier;
import java.security.ProtectionDomain;
import java.util.HashMap;
import java.util.Map;

public abstract class BeanCopier {
    private static final BeanCopier.BeanCopierKey KEY_FACTORY = (BeanCopier.BeanCopierKey) KeyFactory.create(BeanCopier.BeanCopierKey.class);
    private static final Type CONVERTER = TypeUtils.parseType("org.springframework.cglib.core.Converter");
    private static final Type BEAN_COPIER = TypeUtils.parseType(BeanCopier.class.getName());
    private static final Signature COPY;
    private static final Signature CONVERT;

    public BeanCopier() {
    }

    public static BeanCopier create(Class source, Class target, boolean useConverter) {
        BeanCopier.Generator gen = new BeanCopier.Generator();
        gen.setSource(source);
        gen.setTarget(target);
        gen.setUseConverter(useConverter);
        return gen.create();
    }

    public static BeanCopier create(Class source, Class target, boolean useConverter, boolean useNoneNull) {
        BeanCopier.Generator gen = new BeanCopier.Generator();
        gen.setSource(source);
        gen.setTarget(target);
        gen.setUseConverter(useConverter);
        gen.setUseNoneNull(useNoneNull);
        return gen.create();
    }

    public abstract void copy(Object var1, Object var2, Converter var3);

    static {
        COPY = new Signature("copy", Type.VOID_TYPE, new Type[]{Constants.TYPE_OBJECT, Constants.TYPE_OBJECT, CONVERTER});
        CONVERT = TypeUtils.parseSignature("Object convert(Object, Class, Object)");
    }

    public static class Generator extends AbstractClassGenerator {
        private static final Source SOURCE = new Source(BeanCopier.class.getName());
        private Class source;
        private Class target;
        //使用转换器
        private boolean useConverter;
        //使用非空判断
        private boolean useNoneNull;

        public Generator() {
            super(SOURCE);
        }

        public void setSource(Class source) {
            if (!Modifier.isPublic(source.getModifiers())) {
                this.setNamePrefix(source.getName());
            }

            this.source = source;
        }

        public void setTarget(Class target) {
            if (!Modifier.isPublic(target.getModifiers())) {
                this.setNamePrefix(target.getName());
            }

            this.target = target;
        }


        public void setUseNoneNull(boolean useNoneNull) {
            this.useNoneNull = useNoneNull;
        }

        public void setUseConverter(boolean useConverter) {
            this.useConverter = useConverter;
        }

        protected ClassLoader getDefaultClassLoader() {
            return this.source.getClassLoader();
        }

        protected ProtectionDomain getProtectionDomain() {
            return ReflectUtils.getProtectionDomain(this.source);
        }

        public BeanCopier create() {
            Object key = KEY_FACTORY.newInstance(source.getName(), target.getName(), useConverter,this.useNoneNull);
            return (BeanCopier)super.create(key);
        }

        public void generateClass(ClassVisitor v) {
            Type sourceType = Type.getType(source);
            Type targetType = Type.getType(target);
            ClassEmitter ce = new ClassEmitter(v);
            ce.begin_class(Constants.V1_7, Constants.ACC_PUBLIC, getClassName(), BEAN_COPIER, null, Constants.SOURCE_FILE);

            EmitUtils.null_constructor(ce);
            CodeEmitter e = ce.begin_method(Constants.ACC_PUBLIC, COPY, null);
            PropertyDescriptor[] getters = ReflectUtils.getBeanGetters(source);
            PropertyDescriptor[] setters = ReflectUtils.getBeanSetters(target);
            Map<Object, Object> names = new HashMap<>();

            for (int i = 0; i < getters.length; ++i) {
                names.put(getters[i].getName(), getters[i]);
            }

            Local targetLocal = e.make_local();
            Local sourceLocal = e.make_local();
            if (this.useConverter) {
                e.load_arg(1);
                e.checkcast(targetType);
                e.store_local(targetLocal);
                e.load_arg(0);
                e.checkcast(sourceType);
                e.store_local(sourceLocal);
            } else {
                e.load_arg(1);
                e.checkcast(targetType);
                e.load_arg(0);
                e.checkcast(sourceType);
            }

            for (int i = 0; i < setters.length; ++i) {
                PropertyDescriptor setter = setters[i];
                PropertyDescriptor getter = (PropertyDescriptor) names.get(setter.getName());
                if (getter != null) {
                    Class<?> returnType = getter.getReadMethod().getReturnType();
                    //是否为基本数据类型 true是,false否
                    boolean isPrimitive = returnType.isPrimitive();
                    MethodInfo read = ReflectUtils.getMethodInfo(getter.getReadMethod());
                    MethodInfo write = ReflectUtils.getMethodInfo(setter.getWriteMethod());
                    Type setterType = write.getSignature().getArgumentTypes()[0];
                    if (this.useConverter) {
                        Label start = null;
                        if (this.useNoneNull && !isPrimitive) {
                            //将sourceLocal压入栈顶，以便在if处能获取到source对象的变量
                            e.load_local(sourceLocal);
                            //创建标签
                            start = e.make_label();
                            //调用getter方法，获取值
                            e.invoke(read);
                            //进行非空判断
                            e.ifnull(start);
                        }
                        e.load_local(targetLocal);
                        e.load_arg(2);
                        e.load_local(sourceLocal);
                        e.invoke(read);
                        e.box(read.getSignature().getReturnType());
                        EmitUtils.load_class(e, setterType);
                        e.push(write.getSignature().getName());
                        e.invoke_interface(BeanCopier.CONVERTER, BeanCopier.CONVERT);
                        e.unbox_or_zero(setterType);
                        e.invoke(write);

                        if (start != null) {
                            //结束
                            e.mark(start);
                        }
                    } else if (compatible(getter, setter)) {
                        //如果是非空复制
                        Label start = null;
                        if (this.useNoneNull && !isPrimitive) {
                            //复制栈顶并进行压栈
                            e.dup();
                            //创建标签
                            start = e.make_label();
                            //调用getter方法，获取值
                            e.invoke(read);
                            //进行非空判断
                            e.ifnull(start);
                        }
                        e.dup2();
                        e.invoke(read);
                        e.invoke(write);
                        if (start != null) {
                            //结束
                            e.mark(start);
                        }
                    }
                }
            }
            e.return_value();
            e.end_method();
            ce.end_class();
        }

        private static boolean compatible(PropertyDescriptor getter, PropertyDescriptor setter) {
            return setter.getPropertyType().isAssignableFrom(getter.getPropertyType());
        }

        protected Object firstInstance(Class type) {
            return ReflectUtils.newInstance(type);
        }

        protected Object nextInstance(Object instance) {
            return instance;
        }
    }

    interface BeanCopierKey {
        Object newInstance(String var1, String var2, boolean var3, boolean useNoneNull);
    }
}

package com.zhouyy.netBank.framework.cglib.beans;

import java.math.BigDecimal;
import java.math.BigInteger;

/**
 * 基础数据类型转换，在BeanMapEmitter使用cglib生成的代码中使用该类
 *
 * @author zhoul
 * create time 2019-06-20
 */
public abstract class BasicDataCast {

    public static Object cast(Object source, Class target) {
        if(source == null){
            return null;
        }
        // 如果类型一致，则直接返回
        if (source.getClass() == target) {
            return source;
        }
        if (source instanceof Character) {
            Character character = (Character) source;
            if (target == String.class) {
                return character.toString();
            }
        } else if (source instanceof CharSequence) {
            CharSequence character = (CharSequence) source;
            if (target == String.class) {
                return character.toString();
            }
        } else if (source instanceof Number) {
            Number number = (Number) source;
            if (target == BigDecimal.class) {
                return BigDecimal.valueOf(number.doubleValue());
            } else if (target == BigInteger.class) {
                return BigInteger.valueOf(number.longValue());
            } else if (target == Long.class) {
                return number.longValue();
            } else if (target == Integer.class) {
                return number.intValue();
            } else if (target == Double.class) {
                return number.doubleValue();
            } else if (target == Float.class) {
                return number.floatValue();
            } else if (target == Short.class) {
                return number.shortValue();
            } else if (target == Byte.class) {
                return number.byteValue();
            }else if (target == String.class) {
                return number.toString();
            }
        }
        return source;
    }
}

package com.zhouyy.netBank.framework.cglib.beans;

import org.springframework.asm.ClassVisitor;
import org.springframework.cglib.core.AbstractClassGenerator;
import org.springframework.cglib.core.KeyFactory;
import org.springframework.cglib.core.ReflectUtils;

import java.security.ProtectionDomain;
import java.util.*;

/**
 * A <code>Map</code>-based view of a JavaBean.  The default set of keys is the
 * union of all property names (getters or setters). An attempt to set
 * a read-only property will be ignored, and write-only properties will
 * be returned as <code>null</code>. Removal of objects is not a
 * supported (the key set is fixed).
 *
 * @author Chris Nokleberg
 * @author zhoul
 */
abstract public class BeanMap implements Map {
    /**
     * Limit the properties reflected in the key set of the map
     * to readable properties.
     *
     * @see BeanMap.Generator#setRequire
     */
    public static final int REQUIRE_GETTER = 1;

    /**
     * Limit the properties reflected in the key set of the map
     * to writable properties.
     *
     * @see BeanMap.Generator#setRequire
     */
    public static final int REQUIRE_SETTER = 2;

    /**
     * Helper method to create a new <code>BeanMap</code>.  For finer
     * control over the generated instance, use a new instance of
     * <code>BeanMap.Generator</code> instead of this static method.
     *
     * @param bean the JavaBean underlying the map
     * @return a new <code>BeanMap</code> instance
     */
    public static BeanMap create(Object bean) {
        Generator gen = new Generator();
        gen.setBean(bean);
        return gen.create();
    }

    /**
     * 创建对象
     *
     * @param bean
     * @param ignoreKeyCase 是否忽略KEY的大小写，要与putAllIgnoreKeyCase配合使用
     * @return
     */
    public static BeanMap create(Object bean, boolean ignoreKeyCase) {
        Generator gen = new Generator();
        gen.setBean(bean);
        gen.setIgnoreKeyCase(ignoreKeyCase);
        return gen.create();
    }

    public static class Generator extends AbstractClassGenerator {
        private static final Source SOURCE = new Source(BeanMap.class.getName());

        private static final BeanMapKey KEY_FACTORY =
                (BeanMapKey) KeyFactory.create(BeanMapKey.class, KeyFactory.CLASS_BY_NAME);

        interface BeanMapKey {
            public Object newInstance(Class type, int require, boolean ignoreKeyCase);
        }

        private Object bean;
        private Class beanClass;
        private int require;
        private boolean ignoreKeyCase;

        public Generator() {
            super(SOURCE);
        }

        public void setIgnoreKeyCase(boolean ignoreKeyCase) {
            this.ignoreKeyCase = ignoreKeyCase;
        }

        /**
         * Set the bean that the generated map should reflect. The bean may be swapped
         * out for another bean of the same type using {@link #setBean}.
         * Calling this method overrides any value previously set using {@link #setBeanClass}.
         * You must call either this method or {@link #setBeanClass} before {@link #create}.
         *
         * @param bean the initial bean
         */
        public void setBean(Object bean) {
            this.bean = bean;
            if (bean != null)
                beanClass = bean.getClass();
        }

        /**
         * Set the class of the bean that the generated map should support.
         * You must call either this method or {@link #setBeanClass} before {@link #create}.
         *
         * @param beanClass the class of the bean
         */
        public void setBeanClass(Class beanClass) {
            this.beanClass = beanClass;
        }

        /**
         * Limit the properties reflected by the generated map.
         *
         * @param require any combination of {@link #REQUIRE_GETTER} and
         *                {@link #REQUIRE_SETTER}; default is zero (any property allowed)
         */
        public void setRequire(int require) {
            this.require = require;
        }

        protected ClassLoader getDefaultClassLoader() {
            return beanClass.getClassLoader();
        }

        protected ProtectionDomain getProtectionDomain() {
            return ReflectUtils.getProtectionDomain(beanClass);
        }

        /**
         * Create a new instance of the <code>BeanMap</code>. An existing
         * generated class will be reused if possible.
         */
        public BeanMap create() {
            if (beanClass == null) {
                throw new IllegalArgumentException("Class of bean unknown");
            }
            setNamePrefix(beanClass.getName());
            return (BeanMap) super.create(KEY_FACTORY.newInstance(beanClass, require, ignoreKeyCase));
        }

        public void generateClass(ClassVisitor v) throws Exception {
            new BeanMapEmitter(v, getClassName(), beanClass, require, ignoreKeyCase);
        }

        protected Object firstInstance(Class type) {
            return ((BeanMap) ReflectUtils.newInstance(type)).newInstance(bean);
        }

        protected Object nextInstance(Object instance) {
            return ((BeanMap) instance).newInstance(bean);
        }
    }

    /**
     * Create a new <code>BeanMap</code> instance using the specified bean.
     * This is faster than using the {@link #create} static method.
     *
     * @param bean the JavaBean underlying the map
     * @return a new <code>BeanMap</code> instance
     */
    abstract public BeanMap newInstance(Object bean);

    /**
     * Get the type of a property.
     *
     * @param name the name of the JavaBean property
     * @return the type of the property, or null if the property does not exist
     */
    abstract public Class getPropertyType(String name);

    protected Object bean;

    protected BeanMap() {
    }

    protected BeanMap(Object bean) {
        setBean(bean);
    }

    public Object get(Object key) {
        return get(bean, key);
    }

    public Object put(Object key, Object value) {
        return put(bean, key, value);
    }

    /**
     * Get the property of a bean. This allows a <code>BeanMap</code>
     * to be used statically for multiple beans--the bean instance tied to the
     * map is ignored and the bean passed to this method is used instead.
     *
     * @param bean the bean to query; must be compatible with the type of
     *             this <code>BeanMap</code>
     * @param key  must be a String
     * @return the current value, or null if there is no matching property
     */
    abstract public Object get(Object bean, Object key);

    /**
     * Set the property of a bean. This allows a <code>BeanMap</code>
     * to be used statically for multiple beans--the bean instance tied to the
     * map is ignored and the bean passed to this method is used instead.
     *
     * @param key must be a String
     * @return the old value, if there was one, or null
     */
    abstract public Object put(Object bean, Object key, Object value);

    /**
     * Change the underlying bean this map should use.
     *
     * @param bean the new JavaBean
     * @see #getBean
     */
    public void setBean(Object bean) {
        this.bean = bean;
    }

    /**
     * Return the bean currently in use by this map.
     *
     * @return the current JavaBean
     * @see #setBean
     */
    public Object getBean() {
        return bean;
    }

    public void clear() {
        throw new UnsupportedOperationException();
    }

    public boolean containsKey(Object key) {
        return keySet().contains(key);
    }

    public boolean containsValue(Object value) {
        for (Iterator it = keySet().iterator(); it.hasNext(); ) {
            Object v = get(it.next());
            if (((value == null) && (v == null)) || (value != null && value.equals(v)))
                return true;
        }
        return false;
    }

    public int size() {
        return keySet().size();
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    public Object remove(Object key) {
        throw new UnsupportedOperationException();
    }

    public void putAll(Map t) {
        for (Iterator it = t.keySet().iterator(); it.hasNext(); ) {
            Object key = it.next();
            put(key, t.get(key));
        }
    }

    public boolean equals(Object o) {
        if (o == null || !(o instanceof Map)) {
            return false;
        }
        Map other = (Map) o;
        if (size() != other.size()) {
            return false;
        }
        for (Iterator it = keySet().iterator(); it.hasNext(); ) {
            Object key = it.next();
            if (!other.containsKey(key)) {
                return false;
            }
            Object v1 = get(key);
            Object v2 = other.get(key);
            if (!((v1 == null) ? v2 == null : v1.equals(v2))) {
                return false;
            }
        }
        return true;
    }

    public int hashCode() {
        int code = 0;
        for (Iterator it = keySet().iterator(); it.hasNext(); ) {
            Object key = it.next();
            Object value = get(key);
            code += ((key == null) ? 0 : key.hashCode()) ^
                    ((value == null) ? 0 : value.hashCode());
        }
        return code;
    }

    // TODO: optimize
    public Set entrySet() {
        HashMap<Object, Object> copy = new HashMap<>();
        for (Object key : keySet()) {
            copy.put(key, get(key));
        }
        return Collections.unmodifiableMap(copy).entrySet();
    }

    public Collection values() {
        Set keys = keySet();
        List<Object> values = new ArrayList<>(keys.size());
        for (Object key : keys) {
            values.add(get(key));
        }
        return Collections.unmodifiableCollection(values);
    }

    /*
     * @see java.util.AbstractMap#toString
     */
    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append('{');
        for (Iterator it = keySet().iterator(); it.hasNext(); ) {
            Object key = it.next();
            sb.append(key);
            sb.append('=');
            sb.append(get(key));
            if (it.hasNext()) {
                sb.append(", ");
            }
        }
        sb.append('}');
        return sb.toString();
    }
}

package com.zhouyy.netBank.framework.cglib.beans;

import org.springframework.asm.ClassVisitor;
import org.springframework.asm.Label;
import org.springframework.asm.Type;
import org.springframework.cglib.beans.FixedKeySet;
import org.springframework.cglib.core.*;
import org.springframework.util.StringUtils;

import java.beans.PropertyDescriptor;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;

class BeanMapEmitter extends ClassEmitter {
    private static final Type BEAN_MAP = TypeUtils.parseType(BeanMap.class.getName());
    private static final Type FIXED_KEY_SET = TypeUtils.parseType(FixedKeySet.class.getName());
    private static final Signature CSTRUCT_OBJECT = TypeUtils.parseConstructor("Object");
    private static final Signature CSTRUCT_STRING_ARRAY = TypeUtils.parseConstructor("String[]");
    private static final Signature BEAN_MAP_GET = TypeUtils.parseSignature("Object get(Object, Object)");
    private static final Signature BEAN_MAP_PUT = TypeUtils.parseSignature("Object put(Object, Object, Object)");
    private static final Signature KEY_SET = TypeUtils.parseSignature("java.util.Set keySet()");
    private static final Signature NEW_INSTANCE = new Signature("newInstance", BEAN_MAP, new Type[]{Constants.TYPE_OBJECT});
    private static final Signature GET_PROPERTY_TYPE = TypeUtils.parseSignature("Class getPropertyType(String)");
    private static final Signature CAST_DATA_TYPE = TypeUtils.parseSignature("Object cast(Object,Class)");
    private static final Signature TO_LOWER_CASE = TypeUtils.parseSignature("String toLowerCase()");
    private static final Type TYPE_BASIC_DATA_CAST = TypeUtils.parseType(BasicDataCast.class.getName());
    private final boolean ignoreKeyCase;

    public BeanMapEmitter(ClassVisitor v, String className, Class type, int require, boolean ignoreKeyCase) {
        super(v);
        this.ignoreKeyCase = ignoreKeyCase;
        begin_class(Constants.V1_7, Constants.ACC_PUBLIC, className, BEAN_MAP, null, Constants.SOURCE_FILE);
        EmitUtils.null_constructor(this);
        EmitUtils.factory_method(this, NEW_INSTANCE);
        generateConstructor();

        Map getters = makePropertyMap(ReflectUtils.getBeanGetters(type));
        Map setters = makePropertyMap(ReflectUtils.getBeanSetters(type));
        Map<Object, Object> allProps = new HashMap<>();
        allProps.putAll(getters);
        allProps.putAll(setters);

        if (require != 0) {
            for (Iterator it = allProps.keySet().iterator(); it.hasNext(); ) {
                String name = (String) it.next();
                if ((((require & BeanMap.REQUIRE_GETTER) != 0) && !getters.containsKey(name)) ||
                        (((require & BeanMap.REQUIRE_SETTER) != 0) && !setters.containsKey(name))) {
                    it.remove();
                    getters.remove(name);
                    setters.remove(name);
                }
            }
        }
        generateGet(type, getters);
        generatePut(type, setters);

        String[] allNames = getNames(allProps);
        generateKeySet(allNames);
        generateGetPropertyType(allProps, allNames);
        end_class();
    }

    private String lowerCaseName(String name) {
        return name.toLowerCase(Locale.US);
    }

    private String underscoreName(String name) {
        if (!StringUtils.hasLength(name)) {
            return "";
        }
        StringBuilder result = new StringBuilder();
        result.append(lowerCaseName(name.substring(0, 1)));
        for (int i = 1; i < name.length(); i++) {
            String s = name.substring(i, i + 1);
            String slc = lowerCaseName(s);
            if (!s.equals(slc)) {
                result.append("_").append(slc);
            } else {
                result.append(s);
            }
        }
        return result.toString();
    }

    private Map makePropertyMap(PropertyDescriptor[] props) {
        Map<Object, Object> names = new HashMap<>();
        for (PropertyDescriptor pd : props) {
            if (ignoreKeyCase) {
                names.put(lowerCaseName(pd.getName()), pd);
                String underscoredName = underscoreName(pd.getName());
                if (!lowerCaseName(pd.getName()).equals(underscoredName)) {
                    names.put(underscoredName, pd);
                }
            } else {
                names.put(pd.getName(), pd);
            }
        }
        return names;
    }

    @SuppressWarnings("ToArrayCallWithZeroLengthArrayArgument")
    private String[] getNames(Map propertyMap) {
        return (String[]) propertyMap.keySet().toArray(new String[propertyMap.size()]);
    }

    private void generateConstructor() {
        CodeEmitter e = begin_method(Constants.ACC_PUBLIC, CSTRUCT_OBJECT, null);
        e.load_this();
        e.load_arg(0);
        e.super_invoke_constructor(CSTRUCT_OBJECT);
        e.return_value();
        e.end_method();
    }

    private void generateGet(Class type, final Map getters) {
        final CodeEmitter e = begin_method(Constants.ACC_PUBLIC, BEAN_MAP_GET, null);
        e.load_arg(0);
        e.checkcast(Type.getType(type));
        e.load_arg(1);
        e.checkcast(Constants.TYPE_STRING);
        EmitUtils.string_switch(e, getNames(getters), Constants.SWITCH_STYLE_HASH, new ObjectSwitchCallback() {
            public void processCase(Object key, Label end) {
                PropertyDescriptor pd = (PropertyDescriptor) getters.get(key);
                MethodInfo method = ReflectUtils.getMethodInfo(pd.getReadMethod());
                e.invoke(method);
                e.box(method.getSignature().getReturnType());
                e.return_value();
            }

            public void processDefault() {
                e.aconst_null();
                e.return_value();
            }
        });
        e.end_method();
    }

    private void generatePut(Class type, final Map setters) {
        final CodeEmitter e = begin_method(Constants.ACC_PUBLIC, BEAN_MAP_PUT, null);
        e.load_arg(0);
        e.checkcast(Type.getType(type));
        e.load_arg(1);
        e.checkcast(Constants.TYPE_STRING);
        //是否忽略大小写
        if (ignoreKeyCase) {
            e.invoke_virtual(Constants.TYPE_STRING, TO_LOWER_CASE);
        }
        EmitUtils.string_switch(e, getNames(setters), Constants.SWITCH_STYLE_HASH, new ObjectSwitchCallback() {
            public void processCase(Object key, Label end) {
                PropertyDescriptor pd = (PropertyDescriptor) setters.get(key);
                if (pd.getReadMethod() == null) {
                    e.aconst_null();
                } else {
                    MethodInfo read = ReflectUtils.getMethodInfo(pd.getReadMethod());
                    e.dup();
                    e.invoke(read);
                    e.box(read.getSignature().getReturnType());
                }
                e.swap(); // move old value behind bean
                e.load_arg(2);

                MethodInfo write = ReflectUtils.getMethodInfo(pd.getWriteMethod());
                Type setterType = write.getSignature().getArgumentTypes()[0];
                EmitUtils.load_class(e, setterType);
                e.invoke_static(TYPE_BASIC_DATA_CAST, CAST_DATA_TYPE);
                e.box(Constants.TYPE_OBJECT);

                e.unbox(write.getSignature().getArgumentTypes()[0]);
                e.invoke(write);
                e.return_value();
            }

            public void processDefault() {
                // fall-through
            }
        });
        e.aconst_null();
        e.return_value();
        e.end_method();
    }

    private void generateKeySet(String[] allNames) {
        // static initializer
        declare_field(Constants.ACC_STATIC | Constants.ACC_PRIVATE, "keys", FIXED_KEY_SET, null);

        CodeEmitter e = begin_static();
        e.new_instance(FIXED_KEY_SET);
        e.dup();
        EmitUtils.push_array(e, allNames);
        e.invoke_constructor(FIXED_KEY_SET, CSTRUCT_STRING_ARRAY);
        e.putfield("keys");
        e.return_value();
        e.end_method();

        // keySet
        e = begin_method(Constants.ACC_PUBLIC, KEY_SET, null);
        e.load_this();
        e.getfield("keys");
        e.return_value();
        e.end_method();
    }

    private void generateGetPropertyType(final Map allProps, String[] allNames) {
        final CodeEmitter e = begin_method(Constants.ACC_PUBLIC, GET_PROPERTY_TYPE, null);
        e.load_arg(0);
        EmitUtils.string_switch(e, allNames, Constants.SWITCH_STYLE_HASH, new ObjectSwitchCallback() {
            public void processCase(Object key, Label end) {
                PropertyDescriptor pd = (PropertyDescriptor) allProps.get(key);
                EmitUtils.load_class(e, Type.getType(pd.getPropertyType()));
                e.return_value();
            }

            public void processDefault() {
                e.aconst_null();
                e.return_value();
            }
        });
        e.end_method();
    }
}