`

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

 
阅读更多

转自：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. }  
分享到：
[转]spring cloud config实现datasource的 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    自定义View随机生成数字验证码

    例如，我们可以定义一个成员变量来存储验证码的值，并提供一个方法来随机生成验证码： ```java private String code; public void generateCode(int length) { Random random = new Random(); StringBuilder sb =...

    Android自定义控件深入学习 Android生成随机验证码

    本文将深入探讨如何创建一个自定义控件，特别关注如何实现一个能够生成随机验证码的功能。首先，我们来了解一下自定义控件的基本概念。 自定义控件通常基于Android的`View`或`ViewGroup`类进行扩展，通过重写它们的...

    Android自定义随机键盘

    在Android开发中，有时我们需要为应用提供特殊功能的键盘，比如密码输入、验证码输入等，这时自定义键盘就显得尤为重要。本项目“Android自定义随机键盘”正为此目的设计，它能够实现一个随机数字和字母组合的软键盘...

    Android自定义View编写随机验证码

    2. **在构造方法中获取自定义属性**：在自定义View的构造函数中，通过`AttributeSet`参数来获取这些属性值。这通常包括默认构造函数、带`AttributeSet`的构造函数以及带`AttributeSet`和默认样式资源ID的构造函数： ...

    android 自定义随机键盘（全键般随机，字母+数字+标点符号都随机）

    - 在Activity或Fragment中，通过`setKeyboard(Keyboard)`方法将自定义的`Keyboard`对象绑定到`KeyboardView`上，同时设置`EditText`的`InputConnection`为`KeyboardView`的`InputConnection`，以实现输入的联动。...

    0.4_data_gen_生成随机数据_自动生成csv文件_数据随机生成函数_生成数据_

    在IT行业中，尤其是在数据分析、机器学习和深度学习领域，生成随机数据是一项重要的任务。这个名为"0.4_data_gen.py"的Python脚本显然旨在帮助用户自动生成用于测试和验证模型性能的随机数据集，特别是当需要大量...

    android自定义效果——随机抽奖

    在Android开发中，自定义效果往往能够为应用增添独特的交互体验，吸引用户的注意力。本教程将专注于创建一个随机抽奖功能，模拟超市常见的指针转盘抽奖效果。这一过程涉及到的关键技术包括Android动画、随机数生成...

    android 自定义抽奖转盘

    可以使用`Random`类生成一个随机角度，然后计算最接近的奖品。为了模拟真实的抽奖感觉，可以添加一些随机抖动效果。 7. **优化性能**： 为了提高性能，可以在`onDraw()`方法中使用`canvas.save()`和`canvas....

    自定义精简版商品SKU生成表格数据

    2. **设置属性值**：为每个属性设定可能的值，例如颜色有红色、蓝色、绿色等，尺码有S、M、L、XL等。 3. **构建规则**：定义如何将这些属性值组合成唯一的SKU代码。你可以选择按照特定顺序排列属性，或者使用分隔符...

    随机段小数生成器1_区间随机数生成器_

    在游戏设计中，可能要设定怪物的血量或玩家的属性值。 随机段小数生成器可能包含以下功能： 1. **区间设定**：用户可以自定义最小值和最大值，生成的随机数将在这个区间内。 2. **精度控制**：用户可能需要指定...

    Android自定义View——拼手气转盘

    7. **属性设置**：为了方便在XML布局中配置转盘的颜色、大小等属性，我们可以使用 attrs.xml 文件定义自定义属性，并在代码中通过TypedArray读取这些属性值。 8. **使用自定义View**：在XML布局文件中引入自定义...

    Jmockdta是一款实现模拟JAVA类型或对象的实例化并随机初始化对象的数据的工具框架

    Jmockdata的工作原理是基于Java反射机制，它能动态地创建类的实例，并根据预设的规则生成随机数据填充到对象的属性中。这种随机数据的生成可以根据属性的数据类型进行，例如对于字符串类型，它可以生成随机长度的...

    算法与数据结构设计 指定类型数据随机生成算法

    在游戏开发中，它可以用于生成随机地图、角色属性等；在机器学习中，它用于生成训练数据，帮助模型学习和泛化。 总的来说，掌握指定类型数据的随机生成算法对于提升编程技能、解决实际问题至关重要。通过对C++中...

    随机生成验证码

    在这个程序中，可能使用了`System.Char`类和`Random`类来生成随机字符序列。这些字符可能包括大小写字母和数字，甚至特殊字符，以增加破解的难度。 为了增加验证码的复杂性，模糊效果可以通过在`Graphics`对象上...

    abaqus 随机圆平面分布脚本

    2. **圆的半径**：可以设定一个固定的半径，或者根据需求生成随机的半径值。这取决于具体的应用场景，例如模拟不同大小的颗粒。 3. **创建几何实体**：使用ABAQUS的Python API，我们可以创建`Part`对象，然后在该...

    Android自定义View——拼手气转盘（新）

    例如，可以使用`Random`类生成随机角度，或者基于特定权重分配每个区域的停留概率。 8. **布局使用**：在XML布局文件中，像使用其他系统提供的View一样引入自定义的`LuckyWheelView`，并设置相关属性。 接下来，...

    PHP基于自定义类随机生成姓名的方法示例

    这篇文档详细介绍了如何使用PHP自定义类来随机生成中文姓名，并通过实例来演示了具体的实现技巧。要实现这一功能，我们首先需要了解一些基础知识点。 1. PHP类和对象的使用：在PHP中，类是一种用户定义的数据类型，...

    AI illustrator 脚本jsx 源码 随机调节对象大小及透明度

    这个压缩包提供的jsx源码，"RandResize.js" 和 "RandOpacity.js"，专门用于随机调整选定对象的大小和透明度，从而为设计师提供了一种创新的方式去快速实验和探索不同的设计可能性。 "RandResize.js" 脚本的核心功能...

    Android自定义View实现随机验证码

    本篇文章将详细介绍如何在Android中实现一个自定义View来生成随机验证码，这个过程包括定义View的属性、获取属性值、测量与布局以及绘制验证码。 首先，自定义View的属性定义在`values/attrs.xml`文件中。在这个...

Magicbox
Global site tag (gtag.js) - Google Analytics