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

  1 //
  2 // Source code recreated from a .class file by IntelliJ IDEA
  3 // (powered by Fernflower decompiler)
  4 //
  5 
  6 package com.zhouyy.netBank.framework.cglib.beans;
  7 
  8 import org.springframework.asm.ClassVisitor;
  9 import org.springframework.asm.Label;
 10 import org.springframework.asm.Type;
 11 import org.springframework.cglib.core.*;
 12 
 13 import java.beans.PropertyDescriptor;
 14 import java.lang.reflect.Modifier;
 15 import java.security.ProtectionDomain;
 16 import java.util.HashMap;
 17 import java.util.Map;
 18 
 19 public abstract class BeanCopier {
 20     private static final BeanCopier.BeanCopierKey KEY_FACTORY = (BeanCopier.BeanCopierKey) KeyFactory.create(BeanCopier.BeanCopierKey.class);
 21     private static final Type CONVERTER = TypeUtils.parseType("org.springframework.cglib.core.Converter");
 22     private static final Type BEAN_COPIER = TypeUtils.parseType(BeanCopier.class.getName());
 23     private static final Signature COPY;
 24     private static final Signature CONVERT;
 25 
 26     public BeanCopier() {
 27     }
 28 
 29     public static BeanCopier create(Class source, Class target, boolean useConverter) {
 30         BeanCopier.Generator gen = new BeanCopier.Generator();
 31         gen.setSource(source);
 32         gen.setTarget(target);
 33         gen.setUseConverter(useConverter);
 34         return gen.create();
 35     }
 36 
 37     public static BeanCopier create(Class source, Class target, boolean useConverter, boolean useNoneNull) {
 38         BeanCopier.Generator gen = new BeanCopier.Generator();
 39         gen.setSource(source);
 40         gen.setTarget(target);
 41         gen.setUseConverter(useConverter);
 42         gen.setUseNoneNull(useNoneNull);
 43         return gen.create();
 44     }
 45 
 46     public abstract void copy(Object var1, Object var2, Converter var3);
 47 
 48     static {
 49         COPY = new Signature("copy", Type.VOID_TYPE, new Type[]{Constants.TYPE_OBJECT, Constants.TYPE_OBJECT, CONVERTER});
 50         CONVERT = TypeUtils.parseSignature("Object convert(Object, Class, Object)");
 51     }
 52 
 53     public static class Generator extends AbstractClassGenerator {
 54         private static final Source SOURCE = new Source(BeanCopier.class.getName());
 55         private Class source;
 56         private Class target;
 57         //使用转换器
 58         private boolean useConverter;
 59         //使用非空判断
 60         private boolean useNoneNull;
 61 
 62         public Generator() {
 63             super(SOURCE);
 64         }
 65 
 66         public void setSource(Class source) {
 67             if (!Modifier.isPublic(source.getModifiers())) {
 68                 this.setNamePrefix(source.getName());
 69             }
 70 
 71             this.source = source;
 72         }
 73 
 74         public void setTarget(Class target) {
 75             if (!Modifier.isPublic(target.getModifiers())) {
 76                 this.setNamePrefix(target.getName());
 77             }
 78 
 79             this.target = target;
 80         }
 81 
 82 
 83         public void setUseNoneNull(boolean useNoneNull) {
 84             this.useNoneNull = useNoneNull;
 85         }
 86 
 87         public void setUseConverter(boolean useConverter) {
 88             this.useConverter = useConverter;
 89         }
 90 
 91         protected ClassLoader getDefaultClassLoader() {
 92             return this.source.getClassLoader();
 93         }
 94 
 95         protected ProtectionDomain getProtectionDomain() {
 96             return ReflectUtils.getProtectionDomain(this.source);
 97         }
 98 
 99         public BeanCopier create() {
100             Object key = KEY_FACTORY.newInstance(source.getName(), target.getName(), useConverter,this.useNoneNull);
101             return (BeanCopier)super.create(key);
102         }
103 
104         public void generateClass(ClassVisitor v) {
105             Type sourceType = Type.getType(source);
106             Type targetType = Type.getType(target);
107             ClassEmitter ce = new ClassEmitter(v);
108             ce.begin_class(Constants.V1_7, Constants.ACC_PUBLIC, getClassName(), BEAN_COPIER, null, Constants.SOURCE_FILE);
109 
110             EmitUtils.null_constructor(ce);
111             CodeEmitter e = ce.begin_method(Constants.ACC_PUBLIC, COPY, null);
112             PropertyDescriptor[] getters = ReflectUtils.getBeanGetters(source);
113             PropertyDescriptor[] setters = ReflectUtils.getBeanSetters(target);
114             Map names = new HashMap<>();
115 
116             for (int i = 0; i < getters.length; ++i) {
117                 names.put(getters[i].getName(), getters[i]);
118             }
119 
120             Local targetLocal = e.make_local();
121             Local sourceLocal = e.make_local();
122             if (this.useConverter) {
123                 e.load_arg(1);
124                 e.checkcast(targetType);
125                 e.store_local(targetLocal);
126                 e.load_arg(0);
127                 e.checkcast(sourceType);
128                 e.store_local(sourceLocal);
129             } else {
130                 e.load_arg(1);
131                 e.checkcast(targetType);
132                 e.load_arg(0);
133                 e.checkcast(sourceType);
134             }
135 
136             for (int i = 0; i < setters.length; ++i) {
137                 PropertyDescriptor setter = setters[i];
138                 PropertyDescriptor getter = (PropertyDescriptor) names.get(setter.getName());
139                 if (getter != null) {
140                     Class<?> returnType = getter.getReadMethod().getReturnType();
141                     //是否为基本数据类型 true是,false否
142                     boolean isPrimitive = returnType.isPrimitive();
143                     MethodInfo read = ReflectUtils.getMethodInfo(getter.getReadMethod());
144                     MethodInfo write = ReflectUtils.getMethodInfo(setter.getWriteMethod());
145                     Type setterType = write.getSignature().getArgumentTypes()[0];
146                     if (this.useConverter) {
147                         Label start = null;
148                         if (this.useNoneNull && !isPrimitive) {
149                             //将sourceLocal压入栈顶，以便在if处能获取到source对象的变量
150                             e.load_local(sourceLocal);
151                             //创建标签
152                             start = e.make_label();
153                             //调用getter方法，获取值
154                             e.invoke(read);
155                             //进行非空判断
156                             e.ifnull(start);
157                         }
158                         e.load_local(targetLocal);
159                         e.load_arg(2);
160                         e.load_local(sourceLocal);
161                         e.invoke(read);
162                         e.box(read.getSignature().getReturnType());
163                         EmitUtils.load_class(e, setterType);
164                         e.push(write.getSignature().getName());
165                         e.invoke_interface(BeanCopier.CONVERTER, BeanCopier.CONVERT);
166                         e.unbox_or_zero(setterType);
167                         e.invoke(write);
168 
169                         if (start != null) {
170                             //结束
171                             e.mark(start);
172                         }
173                     } else if (compatible(getter, setter)) {
174                         //如果是非空复制
175                         Label start = null;
176                         if (this.useNoneNull && !isPrimitive) {
177                             //复制栈顶并进行压栈
178                             e.dup();
179                             //创建标签
180                             start = e.make_label();
181                             //调用getter方法，获取值
182                             e.invoke(read);
183                             //进行非空判断
184                             e.ifnull(start);
185                         }
186                         e.dup2();
187                         e.invoke(read);
188                         e.invoke(write);
189                         if (start != null) {
190                             //结束
191                             e.mark(start);
192                         }
193                     }
194                 }
195             }
196             e.return_value();
197             e.end_method();
198             ce.end_class();
199         }
200 
201         private static boolean compatible(PropertyDescriptor getter, PropertyDescriptor setter) {
202             return setter.getPropertyType().isAssignableFrom(getter.getPropertyType());
203         }
204 
205         protected Object firstInstance(Class type) {
206             return ReflectUtils.newInstance(type);
207         }
208 
209         protected Object nextInstance(Object instance) {
210             return instance;
211         }
212     }
213 
214     interface BeanCopierKey {
215         Object newInstance(String var1, String var2, boolean var3, boolean useNoneNull);
216     }
217 }

 1 package com.zhouyy.netBank.framework.cglib.beans;
 2 
 3 import java.math.BigDecimal;
 4 import java.math.BigInteger;
 5 
 6 /**
 7  * 基础数据类型转换，在BeanMapEmitter使用cglib生成的代码中使用该类
 8  *
 9  * @author zhoul
10  * create time 2019-06-20
11  */
12 public abstract class BasicDataCast {
13 
14     public static Object cast(Object source, Class target) {
15         if(source == null){
16             return null;
17         }
18         // 如果类型一致，则直接返回
19         if (source.getClass() == target) {
20             return source;
21         }
22         if (source instanceof Character) {
23             Character character = (Character) source;
24             if (target == String.class) {
25                 return character.toString();
26             }
27         } else if (source instanceof CharSequence) {
28             CharSequence character = (CharSequence) source;
29             if (target == String.class) {
30                 return character.toString();
31             }
32         } else if (source instanceof Number) {
33             Number number = (Number) source;
34             if (target == BigDecimal.class) {
35                 return BigDecimal.valueOf(number.doubleValue());
36             } else if (target == BigInteger.class) {
37                 return BigInteger.valueOf(number.longValue());
38             } else if (target == Long.class) {
39                 return number.longValue();
40             } else if (target == Integer.class) {
41                 return number.intValue();
42             } else if (target == Double.class) {
43                 return number.doubleValue();
44             } else if (target == Float.class) {
45                 return number.floatValue();
46             } else if (target == Short.class) {
47                 return number.shortValue();
48             } else if (target == Byte.class) {
49                 return number.byteValue();
50             }else if (target == String.class) {
51                 return number.toString();
52             }
53         }
54         return source;
55     }
56 }

  1 package com.zhouyy.netBank.framework.cglib.beans;
  2 
  3 import org.springframework.asm.ClassVisitor;
  4 import org.springframework.cglib.core.AbstractClassGenerator;
  5 import org.springframework.cglib.core.KeyFactory;
  6 import org.springframework.cglib.core.ReflectUtils;
  7 
  8 import java.security.ProtectionDomain;
  9 import java.util.*;
 10 
 11 /**
 12  * A Map-based view of a JavaBean.  The default set of keys is the
 13  * union of all property names (getters or setters). An attempt to set
 14  * a read-only property will be ignored, and write-only properties will
 15  * be returned as null. Removal of objects is not a
 16  * supported (the key set is fixed).
 17  *
 18  * @author Chris Nokleberg
 19  * @author zhoul
 20  */
 21 abstract public class BeanMap implements Map {
 22     /**
 23      * Limit the properties reflected in the key set of the map
 24      * to readable properties.
 25      *
 26      * @see BeanMap.Generator#setRequire
 27      */
 28     public static final int REQUIRE_GETTER = 1;
 29 
 30     /**
 31      * Limit the properties reflected in the key set of the map
 32      * to writable properties.
 33      *
 34      * @see BeanMap.Generator#setRequire
 35      */
 36     public static final int REQUIRE_SETTER = 2;
 37 
 38     /**
 39      * Helper method to create a new BeanMap.  For finer
 40      * control over the generated instance, use a new instance of
 41      * BeanMap.Generator instead of this static method.
 42      *
 43      * @param bean the JavaBean underlying the map
 44      * @return a new BeanMap instance
 45      */
 46     public static BeanMap create(Object bean) {
 47         Generator gen = new Generator();
 48         gen.setBean(bean);
 49         return gen.create();
 50     }
 51 
 52     /**
 53      * 创建对象
 54      *
 55      * @param bean
 56      * @param ignoreKeyCase 是否忽略KEY的大小写，要与putAllIgnoreKeyCase配合使用
 57      * @return
 58      */
 59     public static BeanMap create(Object bean, boolean ignoreKeyCase) {
 60         Generator gen = new Generator();
 61         gen.setBean(bean);
 62         gen.setIgnoreKeyCase(ignoreKeyCase);
 63         return gen.create();
 64     }
 65 
 66     public static class Generator extends AbstractClassGenerator {
 67         private static final Source SOURCE = new Source(BeanMap.class.getName());
 68 
 69         private static final BeanMapKey KEY_FACTORY =
 70                 (BeanMapKey) KeyFactory.create(BeanMapKey.class, KeyFactory.CLASS_BY_NAME);
 71 
 72         interface BeanMapKey {
 73             public Object newInstance(Class type, int require, boolean ignoreKeyCase);
 74         }
 75 
 76         private Object bean;
 77         private Class beanClass;
 78         private int require;
 79         private boolean ignoreKeyCase;
 80 
 81         public Generator() {
 82             super(SOURCE);
 83         }
 84 
 85         public void setIgnoreKeyCase(boolean ignoreKeyCase) {
 86             this.ignoreKeyCase = ignoreKeyCase;
 87         }
 88 
 89         /**
 90          * Set the bean that the generated map should reflect. The bean may be swapped
 91          * out for another bean of the same type using {@link #setBean}.
 92          * Calling this method overrides any value previously set using {@link #setBeanClass}.
 93          * You must call either this method or {@link #setBeanClass} before {@link #create}.
 94          *
 95          * @param bean the initial bean
 96          */
 97         public void setBean(Object bean) {
 98             this.bean = bean;
 99             if (bean != null)
100                 beanClass = bean.getClass();
101         }
102 
103         /**
104          * Set the class of the bean that the generated map should support.
105          * You must call either this method or {@link #setBeanClass} before {@link #create}.
106          *
107          * @param beanClass the class of the bean
108          */
109         public void setBeanClass(Class beanClass) {
110             this.beanClass = beanClass;
111         }
112 
113         /**
114          * Limit the properties reflected by the generated map.
115          *
116          * @param require any combination of {@link #REQUIRE_GETTER} and
117          *                {@link #REQUIRE_SETTER}; default is zero (any property allowed)
118          */
119         public void setRequire(int require) {
120             this.require = require;
121         }
122 
123         protected ClassLoader getDefaultClassLoader() {
124             return beanClass.getClassLoader();
125         }
126 
127         protected ProtectionDomain getProtectionDomain() {
128             return ReflectUtils.getProtectionDomain(beanClass);
129         }
130 
131         /**
132          * Create a new instance of the BeanMap. An existing
133          * generated class will be reused if possible.
134          */
135         public BeanMap create() {
136             if (beanClass == null) {
137                 throw new IllegalArgumentException("Class of bean unknown");
138             }
139             setNamePrefix(beanClass.getName());
140             return (BeanMap) super.create(KEY_FACTORY.newInstance(beanClass, require, ignoreKeyCase));
141         }
142 
143         public void generateClass(ClassVisitor v) throws Exception {
144             new BeanMapEmitter(v, getClassName(), beanClass, require, ignoreKeyCase);
145         }
146 
147         protected Object firstInstance(Class type) {
148             return ((BeanMap) ReflectUtils.newInstance(type)).newInstance(bean);
149         }
150 
151         protected Object nextInstance(Object instance) {
152             return ((BeanMap) instance).newInstance(bean);
153         }
154     }
155 
156     /**
157      * Create a new BeanMap instance using the specified bean.
158      * This is faster than using the {@link #create} static method.
159      *
160      * @param bean the JavaBean underlying the map
161      * @return a new BeanMap instance
162      */
163     abstract public BeanMap newInstance(Object bean);
164 
165     /**
166      * Get the type of a property.
167      *
168      * @param name the name of the JavaBean property
169      * @return the type of the property, or null if the property does not exist
170      */
171     abstract public Class getPropertyType(String name);
172 
173     protected Object bean;
174 
175     protected BeanMap() {
176     }
177 
178     protected BeanMap(Object bean) {
179         setBean(bean);
180     }
181 
182     public Object get(Object key) {
183         return get(bean, key);
184     }
185 
186     public Object put(Object key, Object value) {
187         return put(bean, key, value);
188     }
189 
190     /**
191      * Get the property of a bean. This allows a BeanMap
192      * to be used statically for multiple beans--the bean instance tied to the
193      * map is ignored and the bean passed to this method is used instead.
194      *
195      * @param bean the bean to query; must be compatible with the type of
196      *             this BeanMap
197      * @param key  must be a String
198      * @return the current value, or null if there is no matching property
199      */
200     abstract public Object get(Object bean, Object key);
201 
202     /**
203      * Set the property of a bean. This allows a BeanMap
204      * to be used statically for multiple beans--the bean instance tied to the
205      * map is ignored and the bean passed to this method is used instead.
206      *
207      * @param key must be a String
208      * @return the old value, if there was one, or null
209      */
210     abstract public Object put(Object bean, Object key, Object value);
211 
212     /**
213      * Change the underlying bean this map should use.
214      *
215      * @param bean the new JavaBean
216      * @see #getBean
217      */
218     public void setBean(Object bean) {
219         this.bean = bean;
220     }
221 
222     /**
223      * Return the bean currently in use by this map.
224      *
225      * @return the current JavaBean
226      * @see #setBean
227      */
228     public Object getBean() {
229         return bean;
230     }
231 
232     public void clear() {
233         throw new UnsupportedOperationException();
234     }
235 
236     public boolean containsKey(Object key) {
237         return keySet().contains(key);
238     }
239 
240     public boolean containsValue(Object value) {
241         for (Iterator it = keySet().iterator(); it.hasNext(); ) {
242             Object v = get(it.next());
243             if (((value == null) && (v == null)) || (value != null && value.equals(v)))
244                 return true;
245         }
246         return false;
247     }
248 
249     public int size() {
250         return keySet().size();
251     }
252 
253     public boolean isEmpty() {
254         return size() == 0;
255     }
256 
257     public Object remove(Object key) {
258         throw new UnsupportedOperationException();
259     }
260 
261     public void putAll(Map t) {
262         for (Iterator it = t.keySet().iterator(); it.hasNext(); ) {
263             Object key = it.next();
264             put(key, t.get(key));
265         }
266     }
267 
268     public boolean equals(Object o) {
269         if (o == null || !(o instanceof Map)) {
270             return false;
271         }
272         Map other = (Map) o;
273         if (size() != other.size()) {
274             return false;
275         }
276         for (Iterator it = keySet().iterator(); it.hasNext(); ) {
277             Object key = it.next();
278             if (!other.containsKey(key)) {
279                 return false;
280             }
281             Object v1 = get(key);
282             Object v2 = other.get(key);
283             if (!((v1 == null) ? v2 == null : v1.equals(v2))) {
284                 return false;
285             }
286         }
287         return true;
288     }
289 
290     public int hashCode() {
291         int code = 0;
292         for (Iterator it = keySet().iterator(); it.hasNext(); ) {
293             Object key = it.next();
294             Object value = get(key);
295             code += ((key == null) ? 0 : key.hashCode()) ^
296                     ((value == null) ? 0 : value.hashCode());
297         }
298         return code;
299     }
300 
301     // TODO: optimize
302     public Set entrySet() {
303         HashMap copy = new HashMap<>();
304         for (Object key : keySet()) {
305             copy.put(key, get(key));
306         }
307         return Collections.unmodifiableMap(copy).entrySet();
308     }
309 
310     public Collection values() {
311         Set keys = keySet();
312         List