Java 随机数据发生器

我必须用一个随机值填充给定对象的每个属性。 以下是我对it的要求：

• 所有属性都是本机Java类型（

  int

  、

  double

  、

  String

  等）
• 我可以使用反射
• 我可以使用Spring

  DirectFieldAccessor

我不想重新发明方轮，所以我更愿意问。 现在我想到了这个：

使用以下命令获取所有属性名称：

Field field : myObject.getClass().getDeclaredFields()

迭代这些字段并获取它们的类

对每个已知的本机Java类型使用一个巨型switch语句，并生成一个随机值

你怎么看？

因为这是一个用于随机数据生成的方法。它只使用了你提到的反射概念。 它检查字段上提到的注释，并在此基础上检查提供者类。通过Personmodel类。 它有一些基本的和非基本的fo字段

public class Person {

   @FirstName
   public String mFirstName;

   @LastName
   public String mLastName;

   @Number(min = 14,max = 25,decimals = 0)
   public int age;

   @Email
   public String mEmailId;

   @ReferenceRecord(clazz = Address.class)
   public Address address;

}

@ReferencedRecord
public class Address {

   @StreetAddress
   public String streetAddress;

   @State
   public String state;
}

//Generate random 100 Person(Model Class) object 
Generator<Person> generator = new Generator<>(Person.class);  
List<Person> persons = generator.generate(100);                          

公共类人物{
@名字
公共字符串mFirstName；
@姓氏
公共字符串mLastName；
@数字（最小值=14，最大值=25，小数=0）
公共信息；
@电子邮件
公共字符串mEmailId；
@ReferenceRecord（clazz=Address.class）
公共广播；
}
@参考记录
公共课堂演讲{
@街道地址
公共字符串地址；
@陈述
公共字符串状态；
}
//生成随机100人（模型类）对象
发电机=新发电机（人员等级）；
列表人员=生成器生成（100）；

---

由于有许多内置数据生成器可以使用注释进行访问，您也可以使用@CustomGenerator注释构建自定义数据生成器。我建议您阅读库页面上提供的文档

您可以使用一个名为的库，以编程方式用可以作为“真实”传递的任意数据“填充”对象

例如，为了填充对象，您可以查看该方法：

//创建一个内部使用
//随机的线程。
MockNeat m=MockNeat.threadLocal（）；
列出公司雇员名单=
m、 reflect（Employee.class）//我们正在嘲笑的类
.field（“唯一标识”，
m、 uuids（））//生成一个随机唯一标识符
.field（“id”，
m、 longSeq（））//生成序列中的长数字
.field（“全名”，
m、 name（）.full（））//为雇主生成全名
.field（“公司邮件”，
m、 emails（）.domain（“company.com”）//生成具有给定域的公司电子邮件
.field（“个人电子邮件”，
m、 emails（））//生成没有域约束的任意电子邮件
.field（“工薪信用卡”，
m、 creditCards（）.types（美国运通卡、万事达卡））//生成“types”的信用卡号
.field（“外部”，
m、 bools（）.probability（20.0））//生成概率为20%的布尔值
.field（“hireDate”，
m、 localDates（）.pass（of（1999，1，1））//生成过去的日期，但大于1987年1月1日
.field（“生日”，
m、 localDates（）.between（of（1950,1,1），of（1994,1,1））//生成给定范围内的数据
.field（“pcs”，
m、 reflect（EmployeePC.class）//模拟EmployeePC对象
.field（“uuid”，
m、 uuids（））//生成唯一标识符
.field（“用户名”，
m、 users（））//生成任意用户名
.field（“操作系统”，
m、 from（新字符串[]{“Linux”、“Windows 10”、“Windows 8”}））//从给定列表中随机选择一个操作系统
.field（“ipAddress”，
m、 ipv4s（）.type（CLASS_B））//生成一个CLASS B IPv4地址
.field（“macAddress”，
m、 macs（））//生成MAC地址
.list（2））//创建具有2个值的列表
.list（1000）//创建一个包含1000个值的列表
.val（）；//返回列表

稍后编辑：

因为我的初始答案提供了更多的生成方法。

您可以尝试，一个设计用于生成随机数据的框架。设置是最小的

用法：

CreationPlan creationPlan = jpaContext.create(
        Entity.of(Employee.class, 2).with(Employee_.Country, INDIA),
        Entity.of(Person.class).with(Person_.gender, "Male"));

另一个选择是。它看起来像：

import static org.quicktheories.QuickTheory.qt;
import static org.quicktheories.generators.SourceDSL.*;

public class SomeTests {

  @Test
  public void addingTwoPositiveIntegersAlwaysGivesAPositiveInteger(){
    qt()
      .forAll(integers().allPositive()
          , integers().allPositive())
      .check((i,j) -> i + j > 0); 
  }

  @Test
  public void someTheoryOrOther(){
    qt()
      .forAll(integers().allPositive()
          , strings().basicLatinAlphabet().ofLengthBetween(0, 10)
          , lists().allListsOf(integers().all()).ofSize(42))
      .assuming((i,s,l) -> s.contains(i.toString())) // <-- an assumption
      .check((i,s,l) -> l.contains(i) && s.contains(i.toString()));
  }
}

导入静态org.QuickTheory.QuickTheory.qt；
导入静态org.quicktheory.generators.SourceDSL.*；
公共类考试{
@试验
public void addingtwo正整数{
qt（）
.forAll（整数（）.allPositive（））
，整数（）
.检查（（i，j）->i+j>0）；
}
@试验
公共无效的某物或其他（）{
qt（）
.forAll（整数（）.allPositive（））
，strings（）.basicLatinAlphabet（）。的长度介于（0,10）之间
，lists（）.allListsOf（integers（）.all（））。of size（42））
.假设（（i，s，l）->s.contains（i.toString（））//l.contains（i）和&s.contains（i.toString（））；
}
}

听起来很有趣！去争取吧有趣的方法。就像你想的那样！：）您是否有任何字段和/或数据类型特定的约束，您的随机值必须遵守这些约束才能有效？（例如，数值范围、字符串的最小/最大长度、字符串中允许的字符等）请参见此问题：您是否正在构建一个年轻人/女士？

import static org.quicktheories.QuickTheory.qt;
import static org.quicktheories.generators.SourceDSL.*;

public class SomeTests {

  @Test
  public void addingTwoPositiveIntegersAlwaysGivesAPositiveInteger(){
    qt()
      .forAll(integers().allPositive()
          , integers().allPositive())
      .check((i,j) -> i + j > 0); 
  }

  @Test
  public void someTheoryOrOther(){
    qt()
      .forAll(integers().allPositive()
          , strings().basicLatinAlphabet().ofLengthBetween(0, 10)
          , lists().allListsOf(integers().all()).ofSize(42))
      .assuming((i,s,l) -> s.contains(i.toString())) // <-- an assumption
      .check((i,s,l) -> l.contains(i) && s.contains(i.toString()));
  }
}