java模拟每天随机调用_Jmockdata首页、文档和下载 - 随机模拟 java 数据插件 - OSCHINA - 中文开源技术交流社区...

Jmockdata

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

The plugin of Jmockdata what through random algorithm mock java data.

Jmockdata插件通过随机算法模拟Java数据.

Feature

支持丰富多样的数据类型模拟，包括：Java基本类型、字符串、枚举、日期、数组、多维数组、集合[List|Set|Map]、枚举、Java对象等

支持通过正则表达式反向模拟数据

支持泛型

支持继承

支持循环依赖、自依赖(手动开启enabledCircle)

支持忽略字段

支持改变mockConfig来自定义模拟数据策略

支持自定义Mocker类

支持JDK1.8+

Download

Jmockdata-4.2.0

Jar

Maven

com.github.jsonzou

jmockdata

4.2.0

Gradle

compile group: 'com.github.jsonzou', name: 'jmockdata', version: '4.2.0'

更多已发布版本下载

History version

Usage

基础类型

支持以下基础类型直接模拟

描述

类型

基础类型

byte boolean char short int long float double

包装类型包装

Byte Boolean Character Short Integer Long Float Double

常用类型

BigDecimal BigInteger Date LocalDateTime LocalDate LocalDate java.sql.Timestamp String Enum

多维数组

以上所有类型的多维数组 如：int[] int[][] int[][][] .... etc.

//基本类型模拟

int intNum = JMockData.mock(int.class);

int[] intArray = JMockData.mock(int[].class);

Integer integer = JMockData.mock(Integer.class);

Integer[] integerArray = JMockData.mock(Integer[].class);

//常用类型模拟

BigDecimal bigDecimal = JMockData.mock(BigDecimal.class);

BigInteger bigInteger = JMockData.mock(BigInteger.class);

Date date = JMockData.mock(Date.class);

String str = JMockData.mock(String.class);

JAVA对象

模拟bean，被模拟的数据必须是plain bean，底层采用了java自带的内省方法来获取字段和对应的setter方法。

支持模拟继承而来的属性。

//模拟Java对象

public class BasicBean {

//基本类型

private byte byteNum;

private boolean booleanNum;

private char charNum;

private short shortNum;

private int integerNum;

private long longNum;

private float floatNum;

private double doubleNum;

//基本包装类型

private Byte byteBoxing;

private Boolean booleanBoxing;

private Character charBoxing;

private Short shortBoxing;

private Integer integerBoxing;

private Long longBoxing;

private Float floatBoxing;

private Double doubleBoxing;

//基本类型数组

private byte[] byteNumArray;

private boolean[] booleanNumArray;

private char[] charNumArray;

private short[] shortNumArray;

private int[] integerNumArray;

private long[] longNumArray;

private float[] floatNumArray;

private double[] doubleNumArray;

//基本类型二维数组

private byte[][] byteNumDoubleArray;

private boolean[][] booleanNumDoubleArray;

private char[][] charNumDoubleArray;

private short[][] shortNumDoubleArray;

private int[][] integerNumDoubleArray;

private long[][] longNumDoubleArray;

private float[][] floatNumDoubleArray;

private double[][] doubleNumDoubleArray;

//基本包装类型数组

private Byte[] byteBoxingArray;

private Boolean[] booleanBoxingArray;

private Character[] charBoxingArray;

private Short[] shortBoxingArray;

private Integer[] integerBoxingArray;

private Long[] longBoxingArray;

private Float[] floatBoxingArray;

private Double[] doubleBoxingArray;

//基本包装类型二维数组

private Byte[][] byteBoxingDoubleArray;

private Boolean[][] booleanBoxingDoubleArray;

private Character[][] charBoxingDoubleArray;

private Short[][] shortBoxingDoubleArray;

private Integer[][] integerBoxingDoubleArray;

private Long[][] longBoxingDoubleArray;

private Float[][] floatBoxingDoubleArray;

private Double[][] doubleBoxingDoubleArray;

//其他常用类型

private BigDecimal bigDecimal;

private BigInteger bigInteger;

private Date date;

private String string;

//其他常用类型数组

private BigDecimal[] bigDecimalArray;

private BigInteger[] bigIntegerArray;

private Date[] dateArray;

private String[] stringArray;

//其他常用类型二维数组

private BigDecimal[][] bigDecimalDoubleArray;

private BigInteger[][] bigIntegerDoubleArray;

private Date[][] dateDoubleArray;

private String[][] stringDoubleArray;

//集合、MAP数组

private List[] listArray;

private Set[] setArray;

private Map[] mapArray;

//集合、MAP二维数组

private List[][] listDoubleArray;

private Set[][] setDoubleArray;

private Map[][] mapDoubleArray;

//集合、MAP二维数组(内部数组)

private List[][] listInnerArrayDoubleArray;

private Set[][] setInnerArrayDoubleArray;

private Map[][] mapInnerArrayDoubleArray;

//集合、MAP二维数组(内部二维数组)

private List[][] listInnerDoubleArrayDoubleArray;

private Set[][] setInnerDoubleArrayDoubleArray;

private Map[][] mapInnerDoubleArrayDoubleArray;

//LIST

private List byteBoxingList;

private List booleanBoxingList;

private List charBoxingList;

private List shortBoxingList;

private List integerBoxingList;

private List longBoxingList;

private List floatBoxingList;

private List doubleBoxingList;

private List bigDecimalList;

private List bigIntegerList;

private List dateList;

private List stringList;

private List> stringListList;

private List> stringSetList;

private List> mapList;

//数组LIST

private List byteBoxingArrayList;

private List booleanBoxingArrayList;

private List charBoxingArrayList;

private List shortBoxingArrayList;

private List integerBoxingArrayList;

private List longBoxingArrayList;

private List floatBoxingArrayList;

private List doubleBoxingArrayList;

private List bigDecimalArrayList;

private List bigIntegerArrayList;

private List dateArrayList;

private List stringArrayList;

//二维数组LIST

private List byteBoxingDoubleArrayList;

private List booleanBoxingDoubleArrayList;

private List charBoxingDoubleArrayList;

private List shortBoxingDoubleArrayList;

private List integerBoxingDoubleArrayList;

private List longBoxingDoubleArrayList;

private List floatBoxingDoubleArrayList;

private List doubleBoxingDoubleArrayList;

private List bigDecimalDoubleArrayList;

private List bigIntegerDoubleArrayList;

private List dateDoubleArrayList;

private List stringDoubleArrayList;

//SET忽略同List

//MAP

private Map basicMap;

private Map keyArrayMap;

private Map valueArrayMap;

private Map keyValueArrayMap;

private Map keyValueDoubleArrayMap;

private Map, Map> keyListValueMapMap;

private Map[], Map[]> keyArrayListValueArrayMapMap;

//getter setter省略...

}

//调用模拟数据的方法模拟Java对象

BasicBean basicBean = JMockData.mock(BasicBean.class);

任意类型(LIST,SET,MAP)

@Test

//******注意TypeReference要加{}才能模拟******

public void testTypeRefrence() {

//模拟基础类型，不建议使用这种方式，参考基础类型章节直接模拟。

Integer integerNum = JMockData.mock(new TypeReference(){});

Integer[] integerArray = JMockData.mock(new TypeReference(){});

//模拟集合

List integerList = JMockData.mock(new TypeReference>(){});

//模拟数组集合

List integerArrayList = JMockData.mock(new TypeReference>(){});

//模拟集合数组

List[] integerListArray = JMockData.mock(new TypeReference[]>(){});

//模拟集合实体

List basicBeanList = JMockData.mock(new TypeReference>(){});

//各种组合忽略。。。。map同理。下面模拟一个不知道什么类型的map

Map>, Map, Double[]>> some = JMockData.mock(new TypeReference>, Map, Double[]>>>(){});

}

更改随机范围以及排除某些不模拟数据的字段

字段支持三种模式匹配，可快速配置：[*FieldWord*]、[*FieldWord]、[FieldWord*]

MockConfig mockConfig = new MockConfig()

// 全局配置

.globalConfig()

.sizeRange(1,1)

.charSeed((char) 97, (char) 98)

.byteRange((byte) 0, Byte.MAX_VALUE)

.shortRange((short) 0, Short.MAX_VALUE)

// 某些字段(名等于integerNum的字段、包含float的字段、double开头的字段)配置

.subConfig("integerNum","*float*","double*")

.intRange(10, 11)

.floatRange(1.22f, 1.50f)

.doubleRange(1.50,1.99)

// 某个类的某些字段(long开头的字段、date结尾的字段、包含string的字段)配置。

.subConfig(BasicBean.class,"long*","*date","*string*")

.longRange(12, 13)

.dateRange("2018-11-20", "2018-11-30")

.stringSeed("SAVED", "REJECT", "APPROVED")

.sizeRange(1,1)

// 全局配置

.globalConfig()

// 排除所有包含list/set/map字符的字段。表达式不区分大小写。

.excludes("*List*","*Set*","*Map*")

// 排除所有Array开头/Boxing结尾的字段。表达式不区分大小写。

.excludes(BasicBean.class,"*Array","Boxing*");

BasicBean basicBean = JMockData.mock(BasicBean.class, mockConfig);

高级特性

设置小数位数

public void testDecimalScaleMock() {

MockConfig mockConfig = new MockConfig()

.doubleRange(-1.1d,9999.99999d)

.floatRange(-1.11111f,9999.99999f)

.decimalScale(3) // 设置小数位数为3，默认是2

.globalConfig();

JMockData.mock(BigDecimal.class,mockConfig);

}

根据正则模拟数据

支持\w \W \d \D \s \S

支持[0-9a-zA-Z] [abc123_]

支持{n} {n,} {n,m}

支持 * + . ?

不支持其他，如() ^ $ | \n \t \cx \b \B \f 等等

/**

* 根据正则模拟数据

* 正则优先于其他规则

*/

@Test

public void testRegexMock() {

MockConfig mockConfig = new MockConfig()

// 随机段落字符串

.stringRegex("I'am a nice man\\.And I'll just scribble the characters, like：[a-z]{2}-[0-9]{2}-[abc123]{2}-\\w{2}-\\d{2}@\\s{1}-\\S{1}\\.?-.")

// 邮箱

.subConfig(RegexTestDataBean.class,"userEmail")

.stringRegex("[a-z0-9]{5,15}\\@\\w{3,5}\\.[a-z]{2,3}")

// 用户名规则

.subConfig(RegexTestDataBean.class,"userName")

.stringRegex("[a-zA-Z_]{1}[a-z0-9_]{5,15}")

// 年龄

.subConfig(RegexTestDataBean.class,"userAge")

.numberRegex("[1-9]{1}\\d?")

// 用户现金

.subConfig(RegexTestDataBean.class,"userMoney")

.numberRegex("[1-9]{2}\\.\\d?")

// 用户的得分

.subConfig(RegexTestDataBean.class,"userScore")

.numberRegex("[1-9]{1}\\d{1}")

// 用户身价

.subConfig(RegexTestDataBean.class,"userValue")

.numberRegex("[1-9]{1}\\d{3,8}")

.globalConfig();

}

循环依赖

public class AXB {

private BXA BXA;

private String name;

//getter setter省略...

}

public class BXA {

private AXB AXB;

private String name;

//getter setter省略...

}

@Test

public void testCircular() {

AXB axb = JMockData.mock(AXB.class);

AXB circularAxb = axb.getBXA().getAXB();

assertSame(axb, circularAxb);

}

自依赖

public class SelfRefData {

private Integer id;

private String name;

private SelfRefData parent;

private Map parentMap;

private SelfRefData[] parentArray;

private List list;

private List listArray;

private List> listListArray;

private List[] arrayList;

private SelfRefData[][][] data;

private Map mapArray;

private Map> mapList;

private Map> mapListArray;

//getter setter省略...

}

@Test

public void testSelf() {

SelfRefData selfRefData = JMockData.mock(SelfRefData.class);

assertSame(selfRefData.getParent(), selfRefData);

}

泛型继承

//定义一个泛型父类

public class GenericData {

private A a;

private B b;

private C c;

private A[] aArray;

private List bList;

private Map map;

private List[] cArray;

private Map, List>[] d;

//getter setter省略...

}

@Test

public void testGenericData() {

GenericData genericData = JMockData.mock(new TypeReference>() {});

assertNotNull(genericData);

}

自定义Mocker类注册

MockConfig mockConfig = new MockConfig()

.registerMocker(Mocker mocker, Class... clazzs)