【转】为自定义对象生成随机属性值

转自：http://blog.csdn.net/zknxx/article/details/70197884

 

这几天在熟悉Swagger的时候，发现它没有提供为自定义对象属性赋随机值的功能(如果有的话，请告知一下)，于是自己就写了一个能生成对象随机属性值的工具类，主要用到了反射机制、注解、随机类。具体的代码如下所示：

随机生成对象属性值的类：

 

[java]  view plain  copy

 

1. public class RandomObjectValue {  
2.   
3.     public static <T> T getObject(Class<?> clazz) {  
4.         T t = null;  
5.         if (clazz == null) {  
6.             return t;  
7.         }  
8.         if((t = (T)getPrimitive(clazz))!= null){  
9.             return t;  
10.         }  
11.         //需要有无参的构造器  
12.         try {  
13.             t = (T)clazz.newInstance();  
14.         } catch (InstantiationException e) {  
15.             e.printStackTrace();  
16.         } catch (IllegalAccessException e) {  
17.             e.printStackTrace();  
18.         }  
19.         Field[] fields = clazz.getDeclaredFields();  
20.         //属性字段  
21.         String fileName = "";  
22.         //符合JavaBean规则的属性  
23.         PropertyDescriptor property = null;  
24.         //set方法对象  
25.         Method method = null;  
26.         for (int i = 0; i < fields.length; i++) {  
27.             //属性字段  
28.             fileName = fields[i].getName();  
29.             //获取属性上的注解  
30.             FormatAnnotation annotation = fields[i].getAnnotation(FormatAnnotation.class);  
31.             try {  
32.                 property = new PropertyDescriptor(fileName, clazz);  
33.             } catch (IntrospectionException e) {  
34.                 //没有设置set方法，或者不符合JavaBean规范  
35.                 continue;  
36.             }  
37.             //获取set方法对象  
38.             method = property.getWriteMethod();  
39.             //如果是字节类型(包含基本类型和包装类)  
40.             if (fields[i].getType() == byte.class || fields[i].getType() == Byte.class) {  
41.                 try {  
42.                     method.invoke(t, SelfUtils.getByteValue());  
43.                 } catch (IllegalAccessException e) {  
44.                     e.printStackTrace();  
45.                 } catch (InvocationTargetException e) {  
46.                     e.printStackTrace();  
47.                 }  
48.             }  
49.             //如果是short类型(包含基本类型和包装类)  
50.             else if (fields[i].getType() == short.class || fields[i].getType() == Short.class) {  
51.                 try {  
52.                     method.invoke(t, SelfUtils.getShortValue());  
53.                 } catch (IllegalAccessException e) {  
54.                     e.printStackTrace();  
55.                 } catch (InvocationTargetException e) {  
56.                     e.printStackTrace();  
57.                 }  
58.             }  
59.             //如果是char类型(包含基本类型和包装类)  
60.             else if (fields[i].getType() == char.class || fields[i].getType() == Character.class) {  
61.                 try {  
62.                     method.invoke(t, SelfUtils.getCharValue());  
63.                 } catch (IllegalAccessException e) {  
64.                     e.printStackTrace();  
65.                 } catch (InvocationTargetException e) {  
66.                     e.printStackTrace();  
67.                 }  
68.             }  
69.             //如果是整型(包含基本类型和包装类)  
70.             else if (fields[i].getType() == int.class || fields[i].getType() == Integer.class) {  
71.                 try {  
72.                     //为属性赋值  
73.                     method.invoke(t, SelfUtils.getIntValue());  
74.                 } catch (InvocationTargetException e) {  
75.                     e.printStackTrace();  
76.                 } catch (IllegalAccessException e) {  
77.                     e.printStackTrace();  
78.                 }  
79.             }  
80.             //如果是float(包含基本类型和包装类)  
81.             else if (fields[i].getType() == float.class || fields[i].getType() == Float.class) {  
82.                 try {  
83.                     //为属性赋值  
84.                     method.invoke(t, SelfUtils.getFloatValue());  
85.                 } catch (InvocationTargetException e) {  
86.                     e.printStackTrace();  
87.                 } catch (IllegalAccessException e) {  
88.                     e.printStackTrace();  
89.                 }  
90.             }  
91.             //如果是double(包含基本类型和包装类)  
92.             else if (fields[i].getType() == double.class || fields[i].getType() == Double.class) {  
93.                 try {  
94.                     //为属性赋值  
95.                     method.invoke(t, SelfUtils.getDoubleValue());  
96.                 } catch (InvocationTargetException e) {  
97.                     e.printStackTrace();  
98.                 } catch (IllegalAccessException e) {  
99.                     e.printStackTrace();  
100.                 }  
101.             }  
102.             //如果是double(包含基本类型和包装类)  
103.             else if (fields[i].getType() == long.class || fields[i].getType() == Long.class) {  
104.                 try {  
105.                     //为属性赋值  
106.                     method.invoke(t, SelfUtils.getDoubleValue());  
107.                 } catch (InvocationTargetException e) {  
108.                     e.printStackTrace();  
109.                 } catch (IllegalAccessException e) {  
110.                     e.printStackTrace();  
111.                 }  
112.             }  
113.             //如果是boolean(包含基本类型和包装类)  
114.             else if (fields[i].getType() == boolean.class || fields[i].getType() == Boolean.class) {  
115.                 try {  
116.                     //为属性赋值  
117.                     method.invoke(t, SelfUtils.getBooleanValue());  
118.                 } catch (InvocationTargetException e) {  
119.                     e.printStackTrace();  
120.                 } catch (IllegalAccessException e) {  
121.                     e.printStackTrace();  
122.                 }  
123.             }  
124.             //如果是boolean(包含基本类型和包装类)  
125.             else if (fields[i].getType() == String.class) {  
126.                 try {  
127.                     //为属性赋值  
128.                     method.invoke(t, SelfUtils.getRamdomString(8));  
129.                 } catch (InvocationTargetException e) {  
130.                     e.printStackTrace();  
131.                 } catch (IllegalAccessException e) {  
132.                     e.printStackTrace();  
133.                 }  
134.             }  
135.             //如果是日期类型  
136.             else if (fields[i].getType() == Date.class) {  
137.                 try {  
138.                     method.invoke(t, SelfUtils.getDateValue());  
139.                 } catch (IllegalAccessException e) {  
140.                     e.printStackTrace();  
141.                 } catch (InvocationTargetException e) {  
142.                     e.printStackTrace();  
143.                 }  
144.             }  
145.             //如果是List类型  
146.             else if (fields[i].getType().isAssignableFrom(List.class)) {  
147.                 //获取泛型  
148.                 Type type = fields[i].getGenericType();  
149.                 //如果不是泛型，不做处理  
150.                 if (type == null) {  
151.                     continue;  
152.                 }  
153.                 if (type instanceof ParameterizedType) {  
154.                     ParameterizedType parameterizedType = (ParameterizedType)type;  
155.                     Class<?> genericClazz = (Class)parameterizedType.getActualTypeArguments()[0];  
156.                     int length = 0;  
157.                     String listLength = "4";  
158.                     if (annotation != null) {  
159.                         listLength = annotation.listLength();  
160.                     }  
161.                     if (StringUtils.isEmpty(listLength) || !listLength.matches(RegularExpression.allNumber)) {  
162.                         length = 4;  
163.                     }  
164.                     length = Integer.parseInt(listLength);  
165.                     List<Object> list = new ArrayList<>(length);  
166.                     for (int j = 0; j < length; j++) {  
167.                         list.add(getObject((Class<T>)genericClazz));  
168.                     }  
169.                     try {  
170.                         method.invoke(t, list);  
171.                     } catch (IllegalAccessException e) {  
172.                         e.printStackTrace();  
173.                     } catch (InvocationTargetException e) {  
174.                         e.printStackTrace();  
175.                     }  
176.                 }  
177.             }  
178.             //如果是Map类型  
179.             else if(fields[i].getType().isAssignableFrom(Map.class)){  
180.                 //获取泛型  
181.                 Type types = fields[i].getGenericType();  
182.                 //如果不是泛型的话则不处理  
183.                 if(types == null){  
184.                     continue;  
185.                 }  
186.                 if(types instanceof ParameterizedType){  
187.                     int length = 4;  
188.                     if(annotation != null){  
189.                         String lengthStr = annotation.mapLength();  
190.                         if(!StringUtils.isEmpty(lengthStr) && lengthStr.matches(RegularExpression.allNumber)){  
191.                             length = Integer.parseInt(lengthStr);  
192.                         }  
193.                     }  
194.                     ParameterizedType parameterizedType = (ParameterizedType)types;  
195.                     Map<Object,Object> map = new HashMap();  
196.                     for(int j=0;j<length;j++){  
197.                         map.put(getObject((Class<?>)parameterizedType.getActualTypeArguments()[0]),  
198.                             getObject((Class<?>)parameterizedType.getActualTypeArguments()[1]));  
199.                     }  
200.                     try {  
201.                         method.invoke(t,map);  
202.                     } catch (IllegalAccessException e) {  
203.                         e.printStackTrace();  
204.                     } catch (InvocationTargetException e) {  
205.                         e.printStackTrace();  
206.                     }  
207.                 }  
208.             }  
209.             //这里默认处理的是自定义对象  
210.             else {  
211.                 try {  
212.                     Object obj = getObject(fields[i].getType());  
213.                     method.invoke(t,obj);  
214.                 } catch (IllegalAccessException e) {  
215.                     e.printStackTrace();  
216.                 } catch (InvocationTargetException e) {  
217.                     e.printStackTrace();  
218.                 }  
219.             }  
220.         }  
221.         return t;  
222.     }  
223.   
224.     private static Object getPrimitive(Class<?> clazz) {  
225.         //如果是byte类型(包含基本类型和包装类)  
226.         if (clazz == byte.class || clazz == Byte.class) {  
227.             return SelfUtils.getByteValue();  
228.         }  
229.         //如果是short类型(包含基本类型和包装类)  
230.         if (clazz == short.class || clazz == Short.class) {  
231.             return SelfUtils.getShortValue();  
232.         }  
233.         //如果是char类型(包含基本类型和包装类)  
234.         if (clazz == char.class || clazz == Character.class) {  
235.             return SelfUtils.getCharValue();  
236.         }  
237.         //如果是整型(包含基本类型和包装类)  
238.         if (clazz == int.class || clazz == Integer.class) {  
239.             //为属性赋值  
240.             return SelfUtils.getIntValue();  
241.         }  
242.         //如果是float(包含基本类型和包装类)  
243.         if (clazz == float.class || clazz == Float.class) {  
244.             //为属性赋值  
245.             return SelfUtils.getFloatValue();  
246.         }  
247.         //如果是double(包含基本类型和包装类)  
248.         if (clazz == double.class || clazz == Double.class) {  
249.             //为属性赋值  
250.             return SelfUtils.getDoubleValue();  
251.         }  
252.         //如果是double(包含基本类型和包装类)  
253.         if (clazz == long.class || clazz == Long.class) {  
254.             //为属性赋值  
255.             return SelfUtils.getDoubleValue();  
256.         }  
257.         //如果是boolean(包含基本类型和包装类)  
258.         if (clazz == boolean.class || clazz == Boolean.class) {  
259.             return SelfUtils.getBooleanValue();  
260.         }  
261.         //如果是boolean(包含基本类型和包装类)  
262.         if (clazz == String.class) {  
263.             //为属性赋值  
264.             return SelfUtils.getRamdomString(8);  
265.         }  
266.         //如果是日期类型  
267.         if (clazz == Date.class) {  
268.             return SelfUtils.getDateValue();  
269.         }  
270.         return null;  
271.     }  
272. }  

[java]  view plain  copy

 

1. public class SelfUtils {  
2.   
3.     private static Random random = new Random();  
4.   
5.     private static char[] ch = {'A', 'B', 'C', 'D', 'E', 'F', 'G',  
6.         'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b',  
7.         'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',  
8.         'x', 'y', 'z'};  
9.     public static String getRamdomString(int length) {  
10.         //        char[] ch = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G',  
11.         //                'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',  
12.         // 'Z', 'a', 'b',  
13.         //                'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',  
14.         // 'u', 'v', 'w',  
15.         //                'x', 'y', 'z', 'o', '1'};  
16.         if (length <= 0) {  
17.             length = ch.length;  
18.         }  
19.         char[] chars = new char[length];  
20.         for (int i = 0; i < length; i++) {  
21.             chars[i] = ch[random.nextInt(ch.length)];  
22.         }  
23.         return new String(chars);  
24.     }  
25.   
26.     public static int getIntValue() {  
27.   
28.         return random.nextInt(1000);  
29.     }  
30.   
31.     public static byte getByteValue() {  
32.         return (byte)(random.nextInt() & 0xEF);  
33.     }  
34.   
35.     public static long getLongValue() {  
36.   
37.         return random.nextLong();  
38.     }  
39.   
40.     public static short getShortValue() {  
41.   
42.         return (short)(random.nextInt() & 0xEFFF);  
43.     }  
44.   
45.     public static float getFloatValue() {  
46.   
47.         return random.nextFloat();  
48.     }  
49.   
50.     public static double getDoubleValue(){  
51.   
52.         return random.nextDouble();  
53.     }  
54.   
55.     public static char getCharValue() {  
56.   
57.         return ch[random.nextInt(ch.length)];  
58.     }  
59.   
60.     public static boolean getBooleanValue() {  
61.   
62.         return random.nextInt()%2 == 0;  
63.     }  
64.   
65.     public static Date getDateValue() {  
66.           
67.         return new Date();  
68.     }  
69. }  

[java]  view plain  copy

 

1. import java.lang.annotation.ElementType;  
2. import java.lang.annotation.Retention;  
3. import java.lang.annotation.RetentionPolicy;  
4. import java.lang.annotation.Target;  
5.   
6. @Retention(RetentionPolicy.RUNTIME)  
7. @Target(ElementType.FIELD)  
8. public @interface FormatAnnotation {  
9.   
10.     /** 
11.      * 日期的格式 
12.      * @return 
13.      */  
14.     String dateFormat() default "yyyy-MM-dd hh:mm:ss";  
15.   
16.     /** 
17.      * list集合的长度 
18.      * @return 
19.      */  
20.     String listLength() default "4";  
21.   
22.     /** 
23.      * map集合的长度 
24.      * @return 
25.      */  
26.     String mapLength() default "4";  
27. }  

[java]  view plain  copy

 

1. public class RegularExpression {  
2.   
3.     public static final String allNumber = "[0-9]{1,}";  
4. }