# jmockdata **Repository Path**: hm-learn/jmockdata ## Basic Information - **Project Name**: jmockdata - **Description**: No description available - **Primary Language**: Unknown - **License**: Apache-2.0 - **Default Branch**: master - **Homepage**: None - **GVP Project**: No ## Statistics - **Stars**: 0 - **Forks**: 0 - **Created**: 2020-06-21 - **Last Updated**: 2024-05-30 ## Categories & Tags **Categories**: Uncategorized **Tags**: None ## README ## 开源项目不容易，如果觉得本项目对您的工作还是有帮助的话，请在帮忙 * github star # Jmockdata [![Build Status](https://www.travis-ci.org/jsonzou/jmockdata.svg?branch=master)](https://www.travis-ci.org/jsonzou/jmockdata) [![Coverage Status](https://coveralls.io/repos/github/jsonzou/jmockdata/badge.svg)](https://coveralls.io/github/jsonzou/jmockdata) [![Maven central](https://maven-badges.herokuapp.com/maven-central/com.github.jsonzou/jmockdata/badge.svg)](http://mvnrepository.com/artifact/com.github.jsonzou/jmockdata) [![License](http://img.shields.io/:license-apache-brightgreen.svg)](http://www.apache.org/licenses/LICENSE-2.0.html) Jmockdta是一款实现模拟JAVA类型或对象的实例化并随机初始化对象的数据的工具框架。 ![mark](http://p1wz9nw0p.bkt.clouddn.com/blog/180118/0DaEC98Kib.png?imageslim) The plugin of Jmockdata what through random algorithm mock java data. Jmockdata插件通过随机算法模拟Java数据. ![mark](http://p1wz9nw0p.bkt.clouddn.com/blog/180118/dclH8cgg30.png?imageslim) ## Feature * 支持丰富多样的数据类型模拟，包括：Java基本类型、字符串、枚举、日期、数组、多维数组、集合[List|Set|Map]、枚举、Java对象等 * 支持通过正则表达式反向模拟数据 * 支持泛型 * 支持继承 * 支持循环依赖、自依赖(手动开启enabledCircle) * 支持忽略字段 * 支持改变mockConfig来自定义模拟数据策略 * 支持自定义Mocker类 * 支持JDK1.8+ ## Download > ### _Jmockdata-4.2.0_ #### Jar > [Jmockdata-4.2.0](http://repo.maven.apache.org/maven2/com/github/jsonzou/jmockdata/4.2.0/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' ``` #### 更多已发布版本下载 > [https://github.com/jsonzou/jmockdata/releases](https://github.com/jsonzou/jmockdata/releases) ## History version - [1.0](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-1.0-RELEASE) - [2.0](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-2.0-RELEASE) - [2.1](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-2.1-RELEASE) - [2.2](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-2.2-RELEASE) - [2.3](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-2.3-RELEASE) - [2.4](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-2.4-RELEASE) - [3.0.0](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-3.0.0-RELEASE) - [3.0.1](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-3.0.1-RELEASE) - [3.1.0](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-3.1.0-RELEASE) - [4.0.0](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-4.0.0-RELEASE) - [4.0.1](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-4.0.1-RELEASE) - [4.1.0](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-4.1.0-RELEASE) - [4.1.1](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-4.1.1-RELEASE) - [4.1.2](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-4.1.2-RELEASE) - [4.2.0](https://github.com/jsonzou/jmockdata/releases/tag/jmockdata-4.2.0-RELEASE) ## Usage ### 基础类型 支持以下基础类型直接模拟 | 描述 | 类型 | | ------ | ---------------------------------------- | | 基础类型 | ```byte``` ```boolean``` ```char``` ```short``` ```int``` ```long``` ```float``` ```double``` | | 包装类型包装 | ```Byte``` ```Boolean``` ```Character``` ```Short``` ```Integer``` ```Long``` ```Float``` ```Double``` | | 常用类型 | ```BigDecimal``` ```BigInteger``` ```Date``` ```LocalDateTime``` ```LocalDate``` ```LocalTime``` ```java.sql.Timestamp``` ```String``` ```Enum``` | | 多维数组 | 以上所有类型的多维数组 如：```int[]``` ```int[][]``` ```int[][][]``` .... etc. | ```java //基本类型模拟 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 //模拟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） ```java @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\*] ```java 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); ``` ## 高级特性 ### 设置小数位数 ```java 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 等等 ```java /** * 根据正则模拟数据 * 正则优先于其他规则 */ @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(); } ``` ### 循环依赖 ```java 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); } ``` ### 自依赖 ```java 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); } ``` ### 泛型继承 ```java //定义一个泛型父类 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类注册 ```java MockConfig mockConfig = new MockConfig() .registerMocker(Mocker mocker, Class... clazzs) ```