├── src ├── test │ └── java │ │ └── com │ │ └── mock │ │ ├── bean │ │ ├── enums │ │ │ ├── ErrorEnum.java │ │ │ └── DayEnum.java │ │ ├── ErrorBean.java │ │ ├── circular │ │ │ ├── AXB.java │ │ │ └── BXA.java │ │ ├── IgnoreBean.java │ │ ├── StringBean.java │ │ ├── GenericData.java │ │ ├── SelfRefData.java │ │ └── BasicBean.java │ │ └── MockTest.java └── main │ ├── java │ └── com │ │ └── mock │ │ ├── Mocker.java │ │ ├── MockException.java │ │ ├── mocker │ │ ├── BooleanMocker.java │ │ ├── LongMocker.java │ │ ├── ByteMocker.java │ │ ├── FloatMocker.java │ │ ├── DoubleMocker.java │ │ ├── IntegerMocker.java │ │ ├── ShortMocker.java │ │ ├── CharacterMocker.java │ │ ├── BigIntegerMocker.java │ │ ├── BigDecimalMocker.java │ │ ├── DateMocker.java │ │ ├── GenericMocker.java │ │ ├── AbstractDateMock.java │ │ ├── MapMocker.java │ │ ├── EnumMocker.java │ │ ├── ClassMocker.java │ │ ├── BaseMocker.java │ │ ├── CollectionMocker.java │ │ ├── BeanMocker.java │ │ ├── StringMocker.java │ │ └── ArrayMocker.java │ │ ├── annotation │ │ └── MockIgnore.java │ │ ├── util │ │ ├── JsonUtil.java │ │ ├── RandomUtils.java │ │ ├── ReflectionUtils.java │ │ └── StringUtil.java │ │ ├── TypeReference.java │ │ ├── Mock.java │ │ └── MockConfig.java │ └── resources │ └── String.text ├── .gitignore ├── pom.xml └── README.md /src/test/java/com/mock/bean/enums/ErrorEnum.java: -------------------------------------------------------------------------------- 1 | package com.mock.bean.enums; 2 | 3 | public enum ErrorEnum { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /src/test/java/com/mock/bean/enums/DayEnum.java: -------------------------------------------------------------------------------- 1 | package com.mock.bean.enums; 2 | 3 | public enum DayEnum { 4 | MON, TUE, WED, THU, FRI, SAT, SUN; 5 | } 6 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.war 2 | *.ear 3 | *.iml 4 | *.class 5 | .idea/ 6 | .svn/ 7 | target/ 8 | .project 9 | .mymetadata 10 | .classpath 11 | .settings/ 12 | .DS_Store 13 | 14 | -------------------------------------------------------------------------------- /src/main/java/com/mock/Mocker.java: -------------------------------------------------------------------------------- 1 | package com.mock; 2 | 3 | /** 4 | * 模拟器接口 5 | */ 6 | public interface Mocker { 7 | 8 | /** 9 | * 模拟数据 10 | * 11 | * @param mockConfig 模拟数据配置 12 | * @return 模拟数据对象 13 | */ 14 | T mock(MockConfig mockConfig); 15 | 16 | } 17 | -------------------------------------------------------------------------------- /src/test/java/com/mock/bean/ErrorBean.java: -------------------------------------------------------------------------------- 1 | package com.mock.bean; 2 | 3 | public class ErrorBean { 4 | 5 | private Integer id; 6 | private String name; 7 | 8 | public ErrorBean(Integer id, String name) { 9 | this.id = id; 10 | this.name = name; 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /src/main/java/com/mock/MockException.java: -------------------------------------------------------------------------------- 1 | package com.mock; 2 | 3 | public class MockException extends RuntimeException { 4 | 5 | public MockException(String message) { 6 | super(message); 7 | } 8 | 9 | public MockException(String message, Throwable cause) { 10 | super(message, cause); 11 | } 12 | 13 | public MockException(Throwable cause) { 14 | super(cause); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/BooleanMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | 7 | /** 8 | * Boolean对象模拟器 9 | */ 10 | public class BooleanMocker implements Mocker { 11 | 12 | @Override 13 | public Boolean mock(MockConfig mockConfig) { 14 | return RandomUtils.nextBoolean(); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/com/mock/annotation/MockIgnore.java: -------------------------------------------------------------------------------- 1 | package com.mock.annotation; 2 | 3 | import java.lang.annotation.Documented; 4 | import java.lang.annotation.ElementType; 5 | import java.lang.annotation.Retention; 6 | import java.lang.annotation.RetentionPolicy; 7 | import java.lang.annotation.Target; 8 | 9 | @Target({ElementType.FIELD}) 10 | @Retention(RetentionPolicy.RUNTIME) 11 | @Documented 12 | public @interface MockIgnore { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/LongMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | 7 | /** 8 | * 模拟Long对象 9 | */ 10 | public class LongMocker implements Mocker { 11 | 12 | @Override 13 | public Long mock(MockConfig mockConfig) { 14 | return RandomUtils.nextLong(mockConfig.getLongRange()[0], mockConfig.getLongRange()[1]); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/ByteMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | 7 | /** 8 | * Byte对象模拟器 9 | */ 10 | public class ByteMocker implements Mocker { 11 | 12 | @Override 13 | public Byte mock(MockConfig mockConfig) { 14 | return (byte) RandomUtils.nextInt(mockConfig.getByteRange()[0], mockConfig.getByteRange()[1]); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/FloatMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | 7 | /** 8 | * Float对象模拟器 9 | */ 10 | public class FloatMocker implements Mocker { 11 | 12 | @Override 13 | public Float mock(MockConfig mockConfig) { 14 | return RandomUtils.nextFloat(mockConfig.getFloatRange()[0], mockConfig.getFloatRange()[1]); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/DoubleMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | 7 | /** 8 | * Double对象模拟器 9 | */ 10 | public class DoubleMocker implements Mocker { 11 | 12 | @Override 13 | public Double mock(MockConfig mockConfig) { 14 | return RandomUtils.nextDouble(mockConfig.getDoubleRange()[0], mockConfig.getDoubleRange()[1]); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/IntegerMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | 7 | /** 8 | * Integer对象模拟器 9 | */ 10 | public class IntegerMocker implements Mocker { 11 | 12 | @Override 13 | public Integer mock(MockConfig mockConfig) { 14 | return RandomUtils.nextInt(mockConfig.getIntRange()[0], mockConfig.getIntRange()[1]); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/ShortMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | 7 | /** 8 | * 模拟Short对象 9 | */ 10 | public class ShortMocker implements Mocker { 11 | 12 | @Override 13 | public Short mock(MockConfig mockConfig) { 14 | return (short) RandomUtils.nextInt(mockConfig.getShortRange()[0], mockConfig.getShortRange()[1]); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/com/mock/util/JsonUtil.java: -------------------------------------------------------------------------------- 1 | package com.mock.util; 2 | 3 | import com.alibaba.fastjson.JSONObject; 4 | 5 | /** 6 | * @author : peng.liu 7 | * @description : json工具类 8 | * @date : 2018/7/13 15:08 9 | */ 10 | public class JsonUtil { 11 | 12 | /** 13 | * 对象转string 14 | * @param obj 对象 15 | * @return String 16 | */ 17 | public static String toStr(Object obj) { 18 | return JSONObject.toJSONString(obj); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/CharacterMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | 7 | /** 8 | * Character对象模拟器 9 | */ 10 | public class CharacterMocker implements Mocker { 11 | 12 | @Override 13 | public Character mock(MockConfig mockConfig) { 14 | char[] charSeed = mockConfig.getCharSeed(); 15 | return charSeed[RandomUtils.nextInt(0, charSeed.length)]; 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/BigIntegerMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | 7 | import java.math.BigInteger; 8 | 9 | /** 10 | * BigInteger对象模拟器 11 | */ 12 | public class BigIntegerMocker implements Mocker { 13 | 14 | @Override 15 | public BigInteger mock(MockConfig mockConfig) { 16 | return BigInteger.valueOf(RandomUtils.nextLong(mockConfig.getLongRange()[0], mockConfig.getLongRange()[1])); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/BigDecimalMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | 7 | import java.math.BigDecimal; 8 | 9 | /** 10 | * BigDecimal对象模拟器 11 | */ 12 | public class BigDecimalMocker implements Mocker { 13 | 14 | @Override 15 | public BigDecimal mock(MockConfig mockConfig) { 16 | return BigDecimal.valueOf(RandomUtils.nextDouble(mockConfig.getDoubleRange()[0], mockConfig.getDoubleRange()[1])); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /src/test/java/com/mock/bean/circular/AXB.java: -------------------------------------------------------------------------------- 1 | package com.mock.bean.circular; 2 | 3 | 4 | public class AXB { 5 | 6 | private BXA BXA; 7 | 8 | private String name; 9 | 10 | public com.mock.bean.circular.BXA getBXA() { 11 | return BXA; 12 | } 13 | 14 | public void setBXA(com.mock.bean.circular.BXA BXA) { 15 | this.BXA = BXA; 16 | } 17 | 18 | public String getName() { 19 | return name; 20 | } 21 | 22 | public void setName(String name) { 23 | this.name = name; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/test/java/com/mock/bean/circular/BXA.java: -------------------------------------------------------------------------------- 1 | package com.mock.bean.circular; 2 | 3 | public class BXA { 4 | 5 | private AXB AXB; 6 | 7 | private String name; 8 | 9 | 10 | public com.mock.bean.circular.AXB getAXB() { 11 | return AXB; 12 | } 13 | 14 | public void setAXB(com.mock.bean.circular.AXB AXB) { 15 | this.AXB = AXB; 16 | } 17 | 18 | public String getName() { 19 | return name; 20 | } 21 | 22 | public void setName(String name) { 23 | this.name = name; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/DateMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | 7 | import java.util.Date; 8 | 9 | /** 10 | * Date对象模拟器 11 | */ 12 | public class DateMocker extends AbstractDateMock implements Mocker { 13 | 14 | public DateMocker(String startTimePattern, String endTime) { 15 | super(startTimePattern, endTime); 16 | } 17 | 18 | @Override 19 | public Date mock(MockConfig mockConfig) { 20 | return new Date(RandomUtils.nextLong(startTime, endTime)); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/GenericMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | 6 | import java.lang.reflect.ParameterizedType; 7 | 8 | /** 9 | * 模拟泛型 10 | */ 11 | public class GenericMocker implements Mocker { 12 | 13 | private ParameterizedType type; 14 | 15 | GenericMocker(ParameterizedType type) { 16 | this.type = type; 17 | } 18 | 19 | @Override 20 | public Object mock(MockConfig mockConfig) { 21 | return new BaseMocker(type.getRawType(), type.getActualTypeArguments()).mock(mockConfig); 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /src/main/java/com/mock/TypeReference.java: -------------------------------------------------------------------------------- 1 | package com.mock; 2 | 3 | import java.lang.reflect.ParameterizedType; 4 | import java.lang.reflect.Type; 5 | 6 | /** 7 | * 类型引用 8 | * 用以获取泛型的类型 9 | * @param 泛型 10 | */ 11 | public abstract class TypeReference { 12 | 13 | private final Type type; 14 | 15 | public TypeReference() { 16 | Type superClass = getClass().getGenericSuperclass(); 17 | if (superClass instanceof Class) { 18 | throw new MockException("不支持的类型或者检查参数是否已经添加{},eg: Mock.mock(new TypeReference(){})"); 19 | } 20 | type = ((ParameterizedType) superClass).getActualTypeArguments()[0]; 21 | } 22 | 23 | public Type getType() { 24 | return type; 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /src/test/java/com/mock/bean/IgnoreBean.java: -------------------------------------------------------------------------------- 1 | package com.mock.bean; 2 | 3 | import com.mock.annotation.MockIgnore; 4 | 5 | /** 6 | * @author : peng.liu 7 | * @description : 测试忽略 属性 的bean 8 | * @date : 2018/7/16 10:13 9 | */ 10 | public class IgnoreBean { 11 | @MockIgnore 12 | private String ignore; 13 | private int notIgnore; 14 | 15 | public String getIgnore() { 16 | return ignore; 17 | } 18 | 19 | public void setIgnore(String ignore) { 20 | this.ignore = ignore; 21 | } 22 | 23 | public int getNotIgnore() { 24 | return notIgnore; 25 | } 26 | 27 | public void setNotIgnore(int notIgnore) { 28 | this.notIgnore = notIgnore; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/AbstractDateMock.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockException; 4 | import java.text.ParseException; 5 | import java.text.SimpleDateFormat; 6 | 7 | public class AbstractDateMock { 8 | 9 | private static final SimpleDateFormat FORMAT = new SimpleDateFormat("yyyy-MM-dd"); 10 | protected Long startTime; 11 | protected Long endTime; 12 | 13 | public AbstractDateMock(String startTimePattern, String endTimePattern) { 14 | try { 15 | this.startTime = FORMAT.parse(startTimePattern).getTime(); 16 | this.endTime = FORMAT.parse(endTimePattern).getTime(); 17 | } catch (ParseException e) { 18 | throw new MockException("时间格式设置错误，设置如下格式yyyy-MM-dd ", e); 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/MapMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | 7 | import java.lang.reflect.Type; 8 | import java.util.HashMap; 9 | import java.util.Map; 10 | 11 | /** 12 | * 模拟Map 13 | */ 14 | public class MapMocker implements Mocker { 15 | 16 | private Type[] types; 17 | 18 | MapMocker(Type[] types) { 19 | this.types = types; 20 | } 21 | 22 | @Override 23 | public Object mock(MockConfig mockConfig) { 24 | int size = RandomUtils.nextSize(mockConfig.getSizeRange()[0], mockConfig.getSizeRange()[1]); 25 | Map result = new HashMap<>(size); 26 | BaseMocker keyMocker = new BaseMocker(types[0]); 27 | BaseMocker valueMocker = new BaseMocker(types[1]); 28 | for (int index = 0; index < size; index++) { 29 | result.put(keyMocker.mock(mockConfig), valueMocker.mock(mockConfig)); 30 | } 31 | return result; 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/EnumMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.MockException; 5 | import com.mock.Mocker; 6 | import com.mock.util.RandomUtils; 7 | 8 | import java.lang.reflect.Field; 9 | 10 | /** 11 | * Double对象模拟器 12 | */ 13 | public class EnumMocker implements Mocker { 14 | 15 | private Class clazz; 16 | 17 | public EnumMocker(Class clazz) { 18 | this.clazz = clazz; 19 | } 20 | 21 | @Override 22 | public T mock(MockConfig mockConfig) { 23 | Enum[] enums = mockConfig.getcacheEnum(clazz.getName()); 24 | if (enums == null) { 25 | try { 26 | Field field = clazz.getDeclaredField("$VALUES"); 27 | field.setAccessible(true); 28 | enums = (Enum[]) field.get(clazz); 29 | if (enums.length == 0) { 30 | throw new MockException("空的enum不能模拟"); 31 | } 32 | mockConfig.cacheEnum(clazz.getName(), enums); 33 | } catch (NoSuchFieldException | IllegalAccessException e) { 34 | throw new MockException(e); 35 | } 36 | } 37 | return (T) enums[RandomUtils.nextInt(0, enums.length)]; 38 | } 39 | 40 | } 41 | -------------------------------------------------------------------------------- /src/main/java/com/mock/util/RandomUtils.java: -------------------------------------------------------------------------------- 1 | package com.mock.util; 2 | 3 | import java.util.Random; 4 | 5 | public final class RandomUtils { 6 | 7 | private final static Random RANDOM = new Random(); 8 | 9 | private RandomUtils() { 10 | } 11 | 12 | public static boolean nextBoolean() { 13 | return RANDOM.nextBoolean(); 14 | } 15 | 16 | public static int nextInt(int startInclusive, int endExclusive) { 17 | return startInclusive + RANDOM.nextInt(endExclusive - startInclusive); 18 | } 19 | 20 | public static long nextLong(long startInclusive, long endExclusive) { 21 | return (long) nextDouble(startInclusive, endExclusive); 22 | } 23 | 24 | public static float nextFloat(float startInclusive, float endInclusive) { 25 | return startInclusive + ((endInclusive - startInclusive) * RANDOM.nextFloat()); 26 | } 27 | 28 | public static double nextDouble(double startInclusive, double endInclusive) { 29 | return startInclusive + ((endInclusive - startInclusive) * RANDOM.nextDouble()); 30 | } 31 | 32 | public static int nextSize(int startInclusive, int endInclusive) { 33 | return startInclusive + RANDOM.nextInt(endInclusive - startInclusive + 1); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/ClassMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | 6 | import java.lang.reflect.Type; 7 | import java.util.Collection; 8 | import java.util.Map; 9 | 10 | public class ClassMocker implements Mocker { 11 | 12 | private Class clazz; 13 | 14 | private Type[] genericTypes; 15 | 16 | ClassMocker(Class clazz, Type[] genericTypes) { 17 | this.clazz = clazz; 18 | this.genericTypes = genericTypes; 19 | } 20 | 21 | @Override 22 | public Object mock(MockConfig mockConfig) { 23 | Mocker mocker; 24 | if (clazz.isArray()) { 25 | mocker = new ArrayMocker(clazz); 26 | } else if (Map.class.isAssignableFrom(clazz)) { 27 | mocker = new MapMocker(genericTypes); 28 | } else if (Collection.class.isAssignableFrom(clazz)) { 29 | mocker = new CollectionMocker(clazz, genericTypes[0]); 30 | } else if (clazz.isEnum()) { 31 | mocker = new EnumMocker(clazz); 32 | } else { 33 | mocker = mockConfig.getMocker(clazz); 34 | if (mocker == null) { 35 | mocker = new BeanMocker(clazz); 36 | } 37 | } 38 | return mocker.mock(mockConfig); 39 | } 40 | 41 | } 42 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/BaseMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | 6 | import java.lang.reflect.GenericArrayType; 7 | import java.lang.reflect.ParameterizedType; 8 | import java.lang.reflect.Type; 9 | import java.lang.reflect.TypeVariable; 10 | 11 | @SuppressWarnings("unchecked") 12 | public class BaseMocker implements Mocker { 13 | 14 | private Type type; 15 | 16 | private Type[] genericTypes; 17 | 18 | public BaseMocker(Type type, Type... genericTypes) { 19 | this.type = type; 20 | this.genericTypes = genericTypes; 21 | } 22 | 23 | @Override 24 | public T mock(MockConfig mockConfig) { 25 | Mocker mocker; 26 | if (type instanceof ParameterizedType) { 27 | mocker = new GenericMocker((ParameterizedType) type); 28 | } else if (type instanceof GenericArrayType) { 29 | mocker = new ArrayMocker(type); 30 | } else if (type instanceof TypeVariable) { 31 | mocker = new BaseMocker(mockConfig.getVariableType(((TypeVariable) type).getName())); 32 | } else { 33 | mocker = new ClassMocker((Class) type, genericTypes); 34 | } 35 | return (T) mocker.mock(mockConfig); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/CollectionMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | 7 | import java.lang.reflect.Type; 8 | import java.util.ArrayList; 9 | import java.util.Collection; 10 | import java.util.HashSet; 11 | import java.util.List; 12 | 13 | /** 14 | * 模拟Collection 15 | */ 16 | public class CollectionMocker implements Mocker { 17 | 18 | private Class clazz; 19 | 20 | private Type genericType; 21 | 22 | CollectionMocker(Class clazz, Type genericType) { 23 | this.clazz = clazz; 24 | this.genericType = genericType; 25 | } 26 | 27 | @Override 28 | public Object mock(MockConfig mockConfig) { 29 | int size = RandomUtils.nextSize(mockConfig.getSizeRange()[0], mockConfig.getSizeRange()[1]); 30 | Collection result; 31 | if (List.class.isAssignableFrom(clazz)) { 32 | result = new ArrayList<>(size); 33 | } else { 34 | result = new HashSet<>(size); 35 | } 36 | BaseMocker baseMocker = new BaseMocker(genericType); 37 | for (int index = 0; index < size; index++) { 38 | result.add(baseMocker.mock(mockConfig)); 39 | } 40 | return result; 41 | } 42 | 43 | } 44 | -------------------------------------------------------------------------------- /src/test/java/com/mock/bean/StringBean.java: -------------------------------------------------------------------------------- 1 | package com.mock.bean; 2 | 3 | import com.mock.annotation.MockIgnore; 4 | 5 | /** 6 | * @author : peng.liu 7 | * @description : 字符串bean 8 | * @date : 2018/7/17 13:29 9 | */ 10 | public class StringBean { 11 | @MockIgnore 12 | private String a1; 13 | private String a4; 14 | private String a2; 15 | private String a3; 16 | private String a55; 17 | private String a555; 18 | 19 | public String getA1() { 20 | return a1; 21 | } 22 | 23 | public void setA1(String a1) { 24 | this.a1 = a1; 25 | } 26 | 27 | public String getA4() { 28 | return a4; 29 | } 30 | 31 | public void setA4(String a4) { 32 | this.a4 = a4; 33 | } 34 | 35 | public String getA2() { 36 | return a2; 37 | } 38 | 39 | public void setA2(String a2) { 40 | this.a2 = a2; 41 | } 42 | 43 | public String getA3() { 44 | return a3; 45 | } 46 | 47 | public void setA3(String a3) { 48 | this.a3 = a3; 49 | } 50 | 51 | public String getA55() { 52 | return a55; 53 | } 54 | 55 | public void setA55(String a55) { 56 | this.a55 = a55; 57 | } 58 | 59 | public String getA555() { 60 | return a555; 61 | } 62 | 63 | public void setA555(String a555) { 64 | this.a555 = a555; 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /src/main/java/com/mock/Mock.java: -------------------------------------------------------------------------------- 1 | package com.mock; 2 | 3 | import com.mock.mocker.BaseMocker; 4 | 5 | /** 6 | * 模拟对象门面类 7 | * 8 | * @author jsonzou, kanyuxia, TaoYu 9 | */ 10 | public class Mock { 11 | 12 | 13 | /** 14 | * 模拟数据 15 | * 16 | * @param clazz 模拟数据类型 17 | * @return 模拟数据对象 18 | */ 19 | public static T mock(Class clazz) { 20 | return mock(clazz, new MockConfig()); 21 | } 22 | 23 | /** 24 | * 模拟数据 25 | * 26 | * @param clazz 模拟数据类型 27 | * @param mockConfig 模拟数据配置 28 | * @return 模拟数据对象 29 | */ 30 | public static T mock(Class clazz, MockConfig mockConfig) { 31 | return new BaseMocker(clazz).mock(mockConfig); 32 | } 33 | 34 | /** 35 | * 模拟数据 36 | * 
37 |    * 注意typeReference必须以{}结尾
38 |    *
39 | * 40 | * @param typeReference 模拟数据包装类型 41 | * @return 模拟数据对象 42 | */ 43 | public static T mock(TypeReference typeReference) { 44 | return mock(typeReference, new MockConfig()); 45 | } 46 | 47 | /** 48 | * 模拟数据 49 | * 
50 |    * 注意typeReference必须以{}结尾
51 |    *
52 | * 53 | * @param typeReference 模拟数据类型 54 | * @param mockConfig 模拟数据配置 55 | * @return 模拟数据对象 56 | */ 57 | public static T mock(TypeReference typeReference, MockConfig mockConfig) { 58 | return new BaseMocker(typeReference.getType()).mock(mockConfig.init(typeReference.getType())); 59 | } 60 | 61 | } 62 | -------------------------------------------------------------------------------- /src/test/java/com/mock/bean/GenericData.java: -------------------------------------------------------------------------------- 1 | package com.mock.bean; 2 | 3 | import java.util.List; 4 | import java.util.Map; 5 | 6 | /** 7 | * Created by jsonzou on 2018/1/17. 8 | */ 9 | public class GenericData { 10 | 11 | 12 | private A a; 13 | private B b; 14 | private C c; 15 | private A[] aArray; 16 | private List bList; 17 | private Map map; 18 | private List[] cArray; 19 | private Map, List>[] d; 20 | 21 | 22 | public A getA() { 23 | return a; 24 | } 25 | 26 | public void setA(A a) { 27 | this.a = a; 28 | } 29 | 30 | public B getB() { 31 | return b; 32 | } 33 | 34 | public void setB(B b) { 35 | this.b = b; 36 | } 37 | 38 | public C getC() { 39 | return c; 40 | } 41 | 42 | public void setC(C c) { 43 | this.c = c; 44 | } 45 | 46 | public A[] getaArray() { 47 | return aArray; 48 | } 49 | 50 | public void setaArray(A[] aArray) { 51 | this.aArray = aArray; 52 | } 53 | 54 | public List getbList() { 55 | return bList; 56 | } 57 | 58 | public void setbList(List bList) { 59 | this.bList = bList; 60 | } 61 | 62 | public Map getMap() { 63 | return map; 64 | } 65 | 66 | public void setMap(Map map) { 67 | this.map = map; 68 | } 69 | 70 | public List[] getcArray() { 71 | return cArray; 72 | } 73 | 74 | public void setcArray(List[] cArray) { 75 | this.cArray = cArray; 76 | } 77 | 78 | public Map, List>[] getD() { 79 | return d; 80 | } 81 | 82 | public void setD(Map, List>[] d) { 83 | this.d = d; 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/BeanMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.MockException; 5 | import com.mock.Mocker; 6 | import com.mock.annotation.MockIgnore; 7 | import com.mock.util.ReflectionUtils; 8 | 9 | import java.lang.reflect.Field; 10 | import java.lang.reflect.Method; 11 | import java.util.Map.Entry; 12 | 13 | public class BeanMocker implements Mocker { 14 | 15 | private final Class clazz; 16 | 17 | BeanMocker(Class clazz) { 18 | this.clazz = clazz; 19 | } 20 | 21 | @Override 22 | public Object mock(MockConfig mockConfig) { 23 | try { 24 | // fixme 解决方案不够优雅 25 | if (mockConfig.isEnabledCircle()) { 26 | Object cacheBean = mockConfig.getcacheBean(clazz.getName()); 27 | if (cacheBean != null) { 28 | return cacheBean; 29 | } 30 | } 31 | Object result = clazz.newInstance(); 32 | mockConfig.cacheBean(clazz.getName(), result); 33 | for (Class currentClass = clazz; currentClass != Object.class; currentClass = currentClass.getSuperclass()) { 34 | // 模拟有setter方法的字段 35 | for (Entry entry : ReflectionUtils.fieldAndSetterMethod(currentClass).entrySet()) { 36 | Field field = entry.getKey(); 37 | if (field.isAnnotationPresent(MockIgnore.class)) { 38 | continue; 39 | } 40 | ReflectionUtils 41 | .setRefValue(result, entry.getValue(), new BaseMocker(field.getGenericType()).mock(mockConfig)); 42 | } 43 | } 44 | return result; 45 | } catch (Exception e) { 46 | throw new MockException(e); 47 | } 48 | } 49 | 50 | } 51 | -------------------------------------------------------------------------------- /src/main/java/com/mock/util/ReflectionUtils.java: -------------------------------------------------------------------------------- 1 | package com.mock.util; 2 | 3 | import java.beans.BeanInfo; 4 | import java.beans.IntrospectionException; 5 | import java.beans.Introspector; 6 | import java.beans.PropertyDescriptor; 7 | import java.lang.reflect.Field; 8 | import java.lang.reflect.Method; 9 | import java.util.LinkedHashMap; 10 | import java.util.Map; 11 | 12 | /** 13 | * 反射工具类 14 | */ 15 | public final class ReflectionUtils { 16 | 17 | private ReflectionUtils() { 18 | } 19 | 20 | /** 21 | * 反射设置值 22 | * 23 | * @param object 对象 24 | * @param method 方法 25 | * @param args 方法参数对象 26 | * @throws ReflectiveOperationException 反射操作异常 27 | */ 28 | public static void setRefValue(Object object, Method method, Object... args) throws ReflectiveOperationException { 29 | method.invoke(object, args); 30 | } 31 | 32 | /** 33 | * 有setter方法的字段及其setter方法 34 | * 35 | * @param clazz Class对象 36 | * @return 有setter方法的 字段及其setter方法 37 | * @throws IntrospectionException 内省异常 38 | */ 39 | public static Map fieldAndSetterMethod(Class clazz) throws IntrospectionException { 40 | Map map = new LinkedHashMap<>(); 41 | BeanInfo beanInfo = Introspector.getBeanInfo(clazz, Object.class); 42 | PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); 43 | for (Field field : clazz.getDeclaredFields()) { 44 | for (PropertyDescriptor propertyDescriptor : propertyDescriptors) { 45 | if (propertyDescriptor.getName().equals(field.getName()) && propertyDescriptor.getWriteMethod() != null) { 46 | map.put(field, propertyDescriptor.getWriteMethod()); 47 | } 48 | } 49 | } 50 | return map; 51 | } 52 | 53 | } 54 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/StringMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | import com.mock.util.StringUtil; 7 | 8 | import java.util.UUID; 9 | 10 | /** 11 | * 模拟String对象 12 | */ 13 | public class StringMocker implements Mocker { 14 | //汉语 种子内容 15 | private static final String STR = StringUtil.readerText(); 16 | 17 | @Override 18 | public String mock(MockConfig mockConfig) { 19 | 20 | if (mockConfig.getStringEnum() == MockConfig.StringEnum.CHARACTER) { 21 | return mockerCharacter(mockConfig); 22 | } 23 | if (mockConfig.getStringEnum() == MockConfig.StringEnum.UUID) { 24 | return UUID.randomUUID().toString(); 25 | } 26 | return mockChinese(mockConfig); 27 | } 28 | 29 | /** 30 | * 随机截取一段中文返回 31 | * 32 | * @param mockConfig 33 | * @return 34 | */ 35 | private String mockChinese(MockConfig mockConfig) { 36 | int size = RandomUtils.nextSize(mockConfig.getSizeRange()[0], mockConfig.getSizeRange()[1]); 37 | int index = RandomUtils.nextInt(0, STR.length() - 1 - size); 38 | return STR.substring(index, index + size); 39 | } 40 | 41 | /** 42 | * 生成随机多个字符 43 | * 44 | * @param mockConfig 45 | * @return 46 | */ 47 | private String mockerCharacter(MockConfig mockConfig) { 48 | int size = RandomUtils.nextSize(mockConfig.getSizeRange()[0], mockConfig.getSizeRange()[1]); 49 | String[] stringSeed = mockConfig.getStringSeed(); 50 | StringBuilder sb = new StringBuilder(size); 51 | for (int i = 0; i < size; i++) { 52 | sb.append(stringSeed[RandomUtils.nextInt(0, stringSeed.length)]); 53 | } 54 | return sb.toString(); 55 | } 56 | 57 | 58 | } 59 | -------------------------------------------------------------------------------- /src/main/resources/String.text: -------------------------------------------------------------------------------- 1 | 滕王阁序唐代：王勃豫章故郡，洪都新府。星分翼轸，地接衡庐。襟三江而带五湖，控蛮荆而引瓯越。物华天宝，龙光射牛斗之墟；人杰地灵，徐孺下陈蕃之榻。雄州雾列，俊采星驰。台隍枕夷夏之交，宾主尽东南之美。都督阎公之雅望，棨戟遥临；宇文新州之懿范，襜帷暂驻。十旬休假，胜友如云；千里逢迎，高朋满座。腾蛟起凤，孟学士之词宗；紫电青霜，王将军之武库。家君作宰，路出名区；童子何知，躬逢胜饯。时维九月，序属三秋。潦水尽而寒潭清，烟光凝而暮山紫。俨骖騑于上路，访风景于崇阿。临帝子之长洲，得仙人之旧馆。层峦耸翠，上出重霄；飞阁流丹，下临无地。鹤汀凫渚，穷岛屿之萦回；桂殿兰宫，即冈峦之体势。披绣闼，俯雕甍，山原旷其盈视，川泽纡其骇瞩。闾阎扑地，钟鸣鼎食之家；舸舰迷津，青雀黄龙之舳。云销雨霁，彩彻区明。落霞与孤鹜齐飞，秋水共长天一色。渔舟唱晚，响穷彭蠡之滨，雁阵惊寒，声断衡阳之浦。遥襟甫畅，逸兴遄飞。爽籁发而清风生，纤歌凝而白云遏。睢园绿竹，气凌彭泽之樽；邺水朱华，光照临川之笔。四美具，二难并。穷睇眄于中天，极娱游于暇日。天高地迥，觉宇宙之无穷；兴尽悲来，识盈虚之有数。望长安于日下，目吴会于云间。地势极而南溟深，天柱高而北辰远。关山难越，谁悲失路之人；萍水相逢，尽是他乡之客。怀帝阍而不见，奉宣室以何年？　　嗟乎！时运不齐，命途多舛。冯唐易老，李广难封。屈贾谊于长沙，非无圣主；窜梁鸿于海曲，岂乏明时？所赖君子见机，达人知命。老当益壮，宁移白首之心？穷且益坚，不坠青云之志。酌贪泉而觉爽，处涸辙以犹欢。北海虽赊，扶摇可接；东隅已逝，桑榆非晚。孟尝高洁，空余报国之情；阮籍猖狂，岂效穷途之哭！勃，三尺微命，一介书生。无路请缨，等终军之弱冠；有怀投笔，慕宗悫之长风。舍簪笏于百龄，奉晨昏于万里。非谢家之宝树，接孟氏之芳邻。他日趋庭，叨陪鲤对；今兹捧袂，喜托龙门。杨意不逢，抚凌云而自惜；钟期既遇，奏流水以何惭？呜乎！胜地不常，盛筵难再；兰亭已矣，梓泽丘墟。临别赠言，幸承恩于伟饯；登高作赋，是所望于群公。敢竭鄙怀，恭疏短引；一言均赋，四韵俱成。请洒潘江，各倾陆海云尔：滕王高阁临江渚，佩玉鸣鸾罢歌舞。画栋朝飞南浦云，珠帘暮卷西山雨。闲云潭影日悠悠，物换星移几度秋。阁中帝子今何在？槛外长江空自流。春朱自清盼望着，盼望着，东风来了，春天脚步近了。一切都像刚睡醒的样子，欣欣然张开了眼。山朗润起来了，水涨起来了，太阳的脸红起来了。小草偷偷地从土里钻出来，嫩嫩的，绿绿的。园子里，田野里，瞧去一大片一大片满是的。坐着，躺着，打两个滚，踢几脚球，赛几趟跑，捉几回迷藏。风轻悄悄的，草软绵绵的。桃树、杏树、梨树，你不让我，我不让你，都开满了花赶趟儿。红的像火，粉的像霞，白的像雪。花里带着甜味儿;闭了眼，村上仿佛已经满是桃儿、杏儿、梨儿。花下成千成百的蜜蜂嗡嗡地闹着，大小的蝴蝶飞来飞去。野花遍地是:杂样儿，有名字的，没名字的，散在草丛里像眼睛，像星星，还眨呀眨的。“吹面不寒杨柳风”，不错的，像母亲的手抚摸着你。风里带来些新翻的泥土的气息，混着青草味儿，还有各种花的香，都在微微润湿的空气里酝酿。鸟儿将巢安在繁花嫩叶当中，高兴起来了，呼朋引伴地卖弄清脆的喉咙，唱出宛转的曲子，跟轻风流水应和着。牛背上牧童的短笛，这时候也成天嘹亮地响着。雨是最寻常的，一下就是三两天。可别恼。看，像牛毛，像花针，像细丝，密密地斜织着，人家屋顶上全笼着一层薄烟。树叶儿却绿得发亮。小草儿也青得逼你的眼。傍晚时候，上灯了，一点点黄晕的光，烘托出一片安静而和平的夜。在乡下，小路上，石桥边，有撑着伞慢慢走着的人;地里还有工作的农民，披着蓑戴着笠。他们的房屋，稀稀疏疏的，在雨里静默着。天上风筝渐渐多了，地上孩子也多了。城里乡下，家家户户，老老小小，也都赶趟儿似的，一个个都出来了。舒活舒活筋骨，抖擞抖擞精神，各做各的一份事儿去。“一年之计在于春”，刚起头儿，有的是工夫，有的是希望。春天像刚落地的娃娃，从头到脚都是新的，它生长着。春天像小姑娘，花枝招展的，笑着，走着。春天像健壮的青年，有铁一般的胳膊和腰脚，他领着我们上前去。将进酒唐代：李白君不见，黄河之水天上来，奔流到海不复回。君不见，高堂明镜悲白发，朝如青丝暮成雪。人生得意须尽欢，莫使金樽空对月。天生我材必有用，千金散尽还复来。烹羊宰牛且为乐，会须一饮三百杯。岑夫子，丹丘生，将进酒，杯莫停。与君歌一曲，请君为我倾耳听。钟鼓馔玉不足贵，但愿长醉不复醒。古来圣贤皆寂寞，惟有饮者留其名。陈王昔时宴平乐，斗酒十千恣欢谑。主人何为言少钱，径须沽取对君酌。五花马，千金裘，呼儿将出换美酒，与尔同销万古愁。 -------------------------------------------------------------------------------- /src/main/java/com/mock/util/StringUtil.java: -------------------------------------------------------------------------------- 1 | package com.mock.util; 2 | 3 | import java.io.*; 4 | 5 | /** 6 | * @author : peng.liu 7 | * @description : 字符串工具 8 | * @date : 2018/7/13 11:09 9 | */ 10 | public class StringUtil { 11 | 12 | 13 | /** 14 | * 去除string的所有空白字符 包括回车，空格，制表符等 15 | * 16 | * @param str 字符串 17 | * @return String 18 | */ 19 | public static String trimAll(String str) { 20 | return str.replaceAll("\\s*", ""); 21 | } 22 | 23 | /** 24 | * 去除指定文件 文件内容的所有空白字符 包括回车，空格，制表符等 25 | * 26 | * @param path 文件路径 27 | * @return String 28 | */ 29 | public static String trimFile(String path) { 30 | StringBuilder text = new StringBuilder(); 31 | //读取文件 32 | File file = new File(path); 33 | if (file.isFile() && file.exists()) { //判断文件是否存在 34 | String line = null; 35 | try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file))) 36 | ) { 37 | while ((line = bufferedReader.readLine()) != null) { 38 | text.append(trimAll(line.toString())); //去除空白字符 39 | } 40 | System.out.println(text); 41 | } catch (IOException e) { 42 | e.printStackTrace(); 43 | } 44 | 45 | //写回文件 46 | try ( 47 | BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file))) 48 | ) { 49 | bufferedWriter.write(text.toString()); 50 | } catch (IOException e) { 51 | e.printStackTrace(); 52 | } 53 | 54 | } else { 55 | System.err.println("找不到指定的文件"); 56 | } 57 | return text.toString(); 58 | } 59 | 60 | /** 61 | * 读取text文本 62 | * 63 | * @return String 64 | */ 65 | public static String readerText() { 66 | StringBuilder text = new StringBuilder(); 67 | //读取文件 68 | InputStream stream = StringUtil.class.getClassLoader().getResourceAsStream("resources/String.text"); 69 | String line = null; 70 | try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(stream)) 71 | ) { 72 | while ((line = bufferedReader.readLine()) != null) { 73 | text.append(line.toString()); //去除空白字符 74 | } 75 | // System.out.println(text); 76 | } catch (IOException e) { 77 | e.printStackTrace(); 78 | } 79 | return text.toString(); 80 | } 81 | 82 | public static void main(String[] args) { 83 | String s = readerText(); 84 | System.out.println(s); 85 | } 86 | } 87 | -------------------------------------------------------------------------------- /pom.xml: -------------------------------------------------------------------------------- 1 | 3 | 4.0.0 4 | 5 | com.mock 6 | mock 7 | 1.0.0 8 | jar 9 | 10 | 11 | UTF-8 12 | UTF-8 13 | 1.8 14 | 1.8 15 | 1.8 16 | 17 | 18 | 19 | 20 | 21 | ali-maven 22 | http://maven.aliyun.com/nexus/content/groups/public 23 | 24 | true 25 | 26 | 27 | true 28 | always 29 | fail 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | junit 38 | junit 39 | 4.12 40 | test 41 | 42 | 43 | com.alibaba 44 | fastjson 45 | 1.2.47 46 | compile 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | src/main 56 | 57 | 58 | **/* 59 | 60 | 63 | false 64 | 65 | 66 | 67 | 68 | 69 | 70 | org.apache.maven.plugins 71 | maven-compiler-plugin 72 | 3.6.1 73 | 74 | ${java.version} 75 | ${java.version} 76 | UTF-8 77 | 78 | 79 | 80 | 81 | org.apache.maven.plugins 82 | maven-surefire-plugin 83 | 84 | true 85 | 86 | 87 | 88 | 89 | 90 | 91 | -------------------------------------------------------------------------------- /src/test/java/com/mock/bean/SelfRefData.java: -------------------------------------------------------------------------------- 1 | package com.mock.bean; 2 | 3 | import java.util.Date; 4 | import java.util.List; 5 | import java.util.Map; 6 | 7 | public class SelfRefData { 8 | 9 | private String id; 10 | private String string; 11 | private Integer Integer; 12 | private Date date; 13 | private SelfRefData parent; 14 | private Map parentMap; 15 | private SelfRefData[] parentArray; 16 | private List list; 17 | private List listArray; 18 | private List> listListArray; 19 | private List[] arrayList; 20 | 21 | private SelfRefData[][][] data; 22 | private Map mapArray; 23 | private Map> mapList; 24 | private Map> mapListArray; 25 | 26 | public String getId() { 27 | return id; 28 | } 29 | 30 | public void setId(String id) { 31 | this.id = id; 32 | } 33 | 34 | public String getString() { 35 | return string; 36 | } 37 | 38 | public void setString(String string) { 39 | this.string = string; 40 | } 41 | 42 | public java.lang.Integer getInteger() { 43 | return Integer; 44 | } 45 | 46 | public void setInteger(java.lang.Integer integer) { 47 | Integer = integer; 48 | } 49 | 50 | public Date getDate() { 51 | return date; 52 | } 53 | 54 | public void setDate(Date date) { 55 | this.date = date; 56 | } 57 | 58 | public SelfRefData getParent() { 59 | return parent; 60 | } 61 | 62 | public void setParent(SelfRefData parent) { 63 | this.parent = parent; 64 | } 65 | 66 | public Map getParentMap() { 67 | return parentMap; 68 | } 69 | 70 | public void setParentMap(Map parentMap) { 71 | this.parentMap = parentMap; 72 | } 73 | 74 | public SelfRefData[] getParentArray() { 75 | return parentArray; 76 | } 77 | 78 | public void setParentArray(SelfRefData[] parentArray) { 79 | this.parentArray = parentArray; 80 | } 81 | 82 | public List getList() { 83 | return list; 84 | } 85 | 86 | public void setList(List list) { 87 | this.list = list; 88 | } 89 | 90 | public List getListArray() { 91 | return listArray; 92 | } 93 | 94 | public void setListArray(List listArray) { 95 | this.listArray = listArray; 96 | } 97 | 98 | public List> getListListArray() { 99 | return listListArray; 100 | } 101 | 102 | public void setListListArray(List> listListArray) { 103 | this.listListArray = listListArray; 104 | } 105 | 106 | public List[] getArrayList() { 107 | return arrayList; 108 | } 109 | 110 | public void setArrayList(List[] arrayList) { 111 | this.arrayList = arrayList; 112 | } 113 | 114 | public SelfRefData[][][] getData() { 115 | return data; 116 | } 117 | 118 | public void setData(SelfRefData[][][] data) { 119 | this.data = data; 120 | } 121 | 122 | public Map getMapArray() { 123 | return mapArray; 124 | } 125 | 126 | public void setMapArray(Map mapArray) { 127 | this.mapArray = mapArray; 128 | } 129 | 130 | public Map> getMapList() { 131 | return mapList; 132 | } 133 | 134 | public void setMapList(Map> mapList) { 135 | this.mapList = mapList; 136 | } 137 | 138 | public Map> getMapListArray() { 139 | return mapListArray; 140 | } 141 | 142 | public void setMapListArray(Map> mapListArray) { 143 | this.mapListArray = mapListArray; 144 | } 145 | } 146 | -------------------------------------------------------------------------------- /src/main/java/com/mock/mocker/ArrayMocker.java: -------------------------------------------------------------------------------- 1 | package com.mock.mocker; 2 | 3 | import com.mock.MockConfig; 4 | import com.mock.Mocker; 5 | import com.mock.util.RandomUtils; 6 | import java.lang.reflect.Array; 7 | import java.lang.reflect.GenericArrayType; 8 | import java.lang.reflect.ParameterizedType; 9 | import java.lang.reflect.Type; 10 | import java.lang.reflect.TypeVariable; 11 | import java.util.ArrayList; 12 | import java.util.HashMap; 13 | import java.util.List; 14 | import java.util.Map; 15 | import java.util.Map.Entry; 16 | 17 | /** 18 | * 数组模拟器 19 | */ 20 | @SuppressWarnings("unchecked") 21 | public class ArrayMocker implements Mocker { 22 | 23 | private Type type; 24 | 25 | ArrayMocker(Type type) { 26 | this.type = type; 27 | } 28 | 29 | @Override 30 | public Object mock(MockConfig mockConfig) { 31 | // 创建有参数化的数组 32 | if (type instanceof GenericArrayType) { 33 | return createGenericArray(mockConfig); 34 | } 35 | return array(mockConfig); 36 | } 37 | 38 | private Object array(MockConfig mockConfig) { 39 | int size = RandomUtils.nextSize(mockConfig.getSizeRange()[0], mockConfig.getSizeRange()[1]); 40 | Class componentClass = ((Class) type).getComponentType(); 41 | Object result = Array.newInstance(componentClass, size); 42 | BaseMocker baseMocker = new BaseMocker(componentClass); 43 | for (int index = 0; index < size; index++) { 44 | Array.set(result, index, baseMocker.mock(mockConfig)); 45 | } 46 | return result; 47 | } 48 | 49 | // TODO 代码还需要整理 50 | // 由于GenericArrayType无法获得Class，所以递归创建多维数组 51 | private Object createGenericArray(MockConfig mockConfig) { 52 | GenericArrayType genericArrayType = (GenericArrayType) this.type; 53 | // 递归获取该数组的维数，以及最后的Class类型 54 | Map> map = map(mockConfig, genericArrayType, 0); 55 | Entry> entry = map.entrySet().iterator().next(); 56 | Entry baseEntry = entry.getValue().entrySet().iterator().next(); 57 | int[] dimensions = new int[entry.getKey()]; 58 | for (int index = 0; index < dimensions.length; index++) { 59 | dimensions[index] = RandomUtils.nextSize(mockConfig.getSizeRange()[0], mockConfig.getSizeRange()[1]); 60 | } 61 | // 创建多维数组每种维度的对象 62 | List list = new ArrayList<>(dimensions.length); 63 | Class clazz = baseEntry.getKey(); 64 | for (int index = dimensions.length - 1; index >= 0; index--) { 65 | Object array = Array.newInstance(clazz, dimensions[index]); 66 | list.add(array); 67 | clazz = array.getClass(); 68 | } 69 | // 实例化多维数组 70 | Object baseResult = new BaseMocker(baseEntry.getKey(), baseEntry.getValue()).mock(mockConfig); 71 | for (int i = 0; i < list.size(); i++) { 72 | Object array = list.get(i); 73 | for (int j = 0; j < dimensions[dimensions.length - i - 1]; j++) { 74 | Array.set(array, j, baseResult); 75 | } 76 | baseResult = array; 77 | } 78 | return baseResult; 79 | } 80 | 81 | private Map> map(MockConfig mockConfig, GenericArrayType genericArrayType, int dimension) { 82 | Map> result = new HashMap<>(); 83 | Type componentType = genericArrayType.getGenericComponentType(); 84 | dimension++; 85 | if (componentType instanceof ParameterizedType) { 86 | ParameterizedType parameterizedType = (ParameterizedType) componentType; 87 | Map map = new HashMap<>(); 88 | map.put((Class) parameterizedType.getRawType(), parameterizedType.getActualTypeArguments()); 89 | result.put(dimension, map); 90 | return result; 91 | } 92 | if (componentType instanceof GenericArrayType) { 93 | return map(mockConfig, (GenericArrayType) componentType, dimension); 94 | } 95 | if (componentType instanceof TypeVariable) { 96 | Map map = new HashMap<>(); 97 | map.put((Class) mockConfig.getVariableType(((TypeVariable) componentType).getName()), null); 98 | result.put(dimension, map); 99 | return result; 100 | } 101 | Map map = new HashMap<>(); 102 | map.put((Class) componentType, null); 103 | result.put(dimension, map); 104 | return result; 105 | } 106 | 107 | } 108 | -------------------------------------------------------------------------------- /src/main/java/com/mock/MockConfig.java: -------------------------------------------------------------------------------- 1 | package com.mock; 2 | 3 | 4 | import com.mock.mocker.BigDecimalMocker; 5 | import com.mock.mocker.BigIntegerMocker; 6 | import com.mock.mocker.BooleanMocker; 7 | import com.mock.mocker.ByteMocker; 8 | import com.mock.mocker.CharacterMocker; 9 | import com.mock.mocker.DateMocker; 10 | import com.mock.mocker.DoubleMocker; 11 | import com.mock.mocker.FloatMocker; 12 | import com.mock.mocker.IntegerMocker; 13 | import com.mock.mocker.LongMocker; 14 | import com.mock.mocker.ShortMocker; 15 | import com.mock.mocker.StringMocker; 16 | 17 | import java.lang.reflect.ParameterizedType; 18 | import java.lang.reflect.Type; 19 | import java.lang.reflect.TypeVariable; 20 | import java.math.BigDecimal; 21 | import java.math.BigInteger; 22 | import java.util.Date; 23 | import java.util.HashMap; 24 | import java.util.Map; 25 | 26 | /** 27 | * 模拟数据配置类 28 | */ 29 | public class MockConfig { 30 | public enum StringEnum { 31 | /** 32 | * uuid 33 | */ 34 | UUID, 35 | /** 36 | * 随机长度的字符 37 | */ 38 | CHARACTER, 39 | /** 40 | * 汉字词语，句子 41 | */ 42 | CHINESE, 43 | /** 44 | * http连接 45 | */ 46 | HTTP, 47 | /** 48 | * https连接 49 | */ 50 | HTTPS, 51 | /** 52 | * 超大文本 53 | */ 54 | TEXT 55 | } 56 | 57 | private static final ByteMocker BYTE_MOCKER = new ByteMocker(); 58 | private static final BooleanMocker BOOLEAN_MOCKER = new BooleanMocker(); 59 | private static final CharacterMocker CHARACTER_MOCKER = new CharacterMocker(); 60 | private static final ShortMocker SHORT_MOCKER = new ShortMocker(); 61 | private static final IntegerMocker INTEGER_MOCKER = new IntegerMocker(); 62 | private static final LongMocker LONG_MOCKER = new LongMocker(); 63 | private static final FloatMocker FLOAT_MOCKER = new FloatMocker(); 64 | private static final DoubleMocker DOUBLE_MOCKER = new DoubleMocker(); 65 | private static final BigIntegerMocker BIG_INTEGER_MOCKER = new BigIntegerMocker(); 66 | private static final BigDecimalMocker BIG_DECIMAL_MOCKER = new BigDecimalMocker(); 67 | private static final StringMocker STRING_MOCKER = new StringMocker(); 68 | private static final DateMocker DATE_MOCKER = new DateMocker("1970-01-01", "2100-12-31"); 69 | 70 | 71 | /** 72 | * 默认为中文 73 | */ 74 | private StringEnum stringEnum = StringEnum.CHINESE; 75 | /** 76 | * Bean缓存 77 | */ 78 | private Map beanCache = new HashMap<>(); 79 | /** 80 | * TypeVariable缓存 81 | */ 82 | private Map typeVariableCache = new HashMap<>(); 83 | /** 84 | * enum缓存 85 | */ 86 | private Map enumCache = new HashMap<>(); 87 | private Map, Mocker> mockerContext = new HashMap<>(); 88 | private byte[] byteRange = {0, 127}; 89 | private short[] shortRange = {0, 1000}; 90 | private int[] intRange = {0, 10000}; 91 | private float[] floatRange = {0.0f, 10000.00f}; 92 | private double[] doubleRange = {0.0, 10000.00}; 93 | private long[] longRange = {0L, 10000L}; 94 | private String[] dateRange = {"1970-01-01", "2100-12-31"}; 95 | private int[] sizeRange = {2, 20}; 96 | private boolean enabledCircle = false; 97 | 98 | private char[] charSeed = 99 | {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 100 | 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 101 | 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'}; 102 | private String[] stringSeed = 103 | {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", 104 | "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", "E", "F", 105 | "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"}; 106 | 107 | public MockConfig() { 108 | registerMocker(BYTE_MOCKER, byte.class, Byte.class); 109 | registerMocker(BOOLEAN_MOCKER, boolean.class, Boolean.class); 110 | registerMocker(CHARACTER_MOCKER, char.class, Character.class); 111 | registerMocker(SHORT_MOCKER, short.class, Short.class); 112 | registerMocker(INTEGER_MOCKER, Integer.class, int.class); 113 | registerMocker(LONG_MOCKER, long.class, Long.class); 114 | registerMocker(FLOAT_MOCKER, float.class, Float.class); 115 | registerMocker(DOUBLE_MOCKER, double.class, Double.class); 116 | registerMocker(BIG_INTEGER_MOCKER, BigInteger.class); 117 | registerMocker(BIG_DECIMAL_MOCKER, BigDecimal.class); 118 | registerMocker(STRING_MOCKER, String.class); 119 | registerMocker(DATE_MOCKER, Date.class); 120 | } 121 | 122 | public void cacheBean(String name, Object bean) { 123 | beanCache.put(name, bean); 124 | } 125 | 126 | public Object getcacheBean(String beanClassName) { 127 | return beanCache.get(beanClassName); 128 | } 129 | 130 | public void cacheEnum(String name, Enum[] enums) { 131 | enumCache.put(name, enums); 132 | } 133 | 134 | public Enum[] getcacheEnum(String enumClassName) { 135 | return enumCache.get(enumClassName); 136 | } 137 | 138 | public MockConfig init(Type type) { 139 | if (type instanceof ParameterizedType) { 140 | Class clazz = (Class) ((ParameterizedType) type).getRawType(); 141 | Type[] types = ((ParameterizedType) type).getActualTypeArguments(); 142 | TypeVariable[] typeVariables = clazz.getTypeParameters(); 143 | if (typeVariables != null && typeVariables.length > 0) { 144 | for (int index = 0; index < typeVariables.length; index++) { 145 | typeVariableCache.put(typeVariables[index].getName(), types[index]); 146 | } 147 | } 148 | } 149 | return this; 150 | } 151 | 152 | public boolean isEnabledCircle() { 153 | return enabledCircle; 154 | } 155 | 156 | public MockConfig setEnabledCircle(boolean enabledCircle) { 157 | this.enabledCircle = enabledCircle; 158 | return this; 159 | } 160 | 161 | public Type getVariableType(String name) { 162 | return typeVariableCache.get(name); 163 | } 164 | 165 | public MockConfig byteRange(byte min, byte max) { 166 | this.byteRange[0] = min; 167 | this.byteRange[1] = max; 168 | return this; 169 | } 170 | 171 | public MockConfig shortRange(short min, short max) { 172 | this.shortRange[0] = min; 173 | this.shortRange[1] = max; 174 | return this; 175 | } 176 | 177 | public MockConfig intRange(int min, int max) { 178 | this.intRange[0] = min; 179 | this.intRange[1] = max; 180 | return this; 181 | } 182 | 183 | public MockConfig floatRange(float min, float max) { 184 | this.floatRange[0] = min; 185 | this.floatRange[1] = max; 186 | return this; 187 | } 188 | 189 | public MockConfig doubleRange(double min, double max) { 190 | this.doubleRange[0] = min; 191 | this.doubleRange[1] = max; 192 | return this; 193 | } 194 | 195 | public MockConfig longRange(long min, long max) { 196 | this.longRange[0] = min; 197 | this.longRange[1] = max; 198 | return this; 199 | } 200 | 201 | public MockConfig dateRange(String min, String max) { 202 | this.dateRange[0] = min; 203 | this.dateRange[1] = max; 204 | registerMocker(new DateMocker(min, max), Date.class); 205 | return this; 206 | } 207 | 208 | public MockConfig sizeRange(int min, int max) { 209 | this.sizeRange[0] = min; 210 | this.sizeRange[1] = max; 211 | return this; 212 | } 213 | 214 | public MockConfig stringSeed(String... stringSeed) { 215 | this.stringSeed = stringSeed; 216 | return this; 217 | } 218 | 219 | public MockConfig charSeed(char... charSeed) { 220 | this.charSeed = charSeed; 221 | return this; 222 | } 223 | 224 | public byte[] getByteRange() { 225 | return byteRange; 226 | } 227 | 228 | public short[] getShortRange() { 229 | return shortRange; 230 | } 231 | 232 | public int[] getIntRange() { 233 | return intRange; 234 | } 235 | 236 | public float[] getFloatRange() { 237 | return floatRange; 238 | } 239 | 240 | public double[] getDoubleRange() { 241 | return doubleRange; 242 | } 243 | 244 | public long[] getLongRange() { 245 | return longRange; 246 | } 247 | 248 | public int[] getSizeRange() { 249 | return sizeRange; 250 | } 251 | 252 | public char[] getCharSeed() { 253 | return charSeed; 254 | } 255 | 256 | public String[] getStringSeed() { 257 | return stringSeed; 258 | } 259 | 260 | public void registerMocker(Mocker mocker, Class... clazzs) { 261 | for (Class clazz : clazzs) { 262 | mockerContext.put(clazz, mocker); 263 | } 264 | } 265 | 266 | public Mocker getMocker(Class clazz) { 267 | return mockerContext.get(clazz); 268 | } 269 | 270 | public StringEnum getStringEnum() { 271 | return stringEnum; 272 | } 273 | 274 | public MockConfig setStringEnum(StringEnum stringEnum) { 275 | this.stringEnum = stringEnum; 276 | return this; 277 | } 278 | } 279 | -------------------------------------------------------------------------------- /src/test/java/com/mock/MockTest.java: -------------------------------------------------------------------------------- 1 | package com.mock; 2 | 3 | import com.mock.bean.*; 4 | import com.mock.bean.circular.AXB; 5 | import com.mock.bean.enums.DayEnum; 6 | import com.mock.util.JsonUtil; 7 | import org.junit.Test; 8 | 9 | import java.lang.reflect.ParameterizedType; 10 | import java.lang.reflect.Type; 11 | import java.math.BigDecimal; 12 | import java.math.BigInteger; 13 | import java.util.*; 14 | 15 | import static org.junit.Assert.*; 16 | 17 | public class MockTest { 18 | 19 | /** 20 | * java基本类型模拟测试 21 | */ 22 | @Test 23 | public void testBasic() { 24 | //基本类型模拟 25 | byte byte1 = Mock.mock(byte.class); 26 | System.err.println(byte1); 27 | 28 | short short1 = Mock.mock(short.class); 29 | System.err.println(short1); 30 | 31 | int int1 = Mock.mock(int.class); 32 | System.err.println(int1); 33 | 34 | long long1 = Mock.mock(long.class); 35 | System.err.println(long1); 36 | 37 | double double1 = Mock.mock(double.class); 38 | System.err.println(double1); 39 | 40 | float float1 = Mock.mock(float.class); 41 | System.err.println(float1); 42 | 43 | char char1 = Mock.mock(char.class); 44 | System.err.println(char1); 45 | 46 | boolean boolean1 = Mock.mock(boolean.class); 47 | System.err.println(boolean1); 48 | 49 | //基本类型封装类模拟 50 | Byte byte2 = Mock.mock(Byte.class); 51 | System.err.println(byte2); 52 | 53 | Short short2 = Mock.mock(Short.class); 54 | System.err.println(short2); 55 | 56 | Integer int2 = Mock.mock(Integer.class); 57 | System.err.println(int2); 58 | 59 | Long long2 = Mock.mock(Long.class); 60 | System.err.println(long2); 61 | 62 | Double double2 = Mock.mock(Double.class); 63 | System.err.println(double2); 64 | 65 | Float float2 = Mock.mock(Float.class); 66 | System.err.println(float2); 67 | 68 | Character char2 = Mock.mock(Character.class); 69 | System.err.println(char2); 70 | 71 | Boolean boolean2 = Mock.mock(Boolean.class); 72 | System.err.println(boolean2); 73 | 74 | //常用类型模拟 75 | //字符串 76 | String string = Mock.mock(String.class); 77 | System.err.println(string); 78 | //大精度 79 | BigDecimal bigDecimal = Mock.mock(BigDecimal.class); 80 | System.err.println(bigDecimal); 81 | //大整形 82 | BigInteger bigInteger = Mock.mock(BigInteger.class); 83 | System.out.println(bigInteger); 84 | //日期 85 | Date date = Mock.mock(Date.class); 86 | System.out.println(date); 87 | //枚举 88 | DayEnum dayEnum = Mock.mock(DayEnum.class); 89 | System.out.println(dayEnum); 90 | } 91 | 92 | /** 93 | * 基本类型的数组类型模拟测试 94 | */ 95 | @Test 96 | public void testArray() { 97 | 98 | //基本类型 数组 模拟 99 | byte[] byte1 = Mock.mock(byte[].class); 100 | System.err.println(JsonUtil.toStr(byte1));//byte转json 这里做了new string 打印是string 101 | //循环打印出来 102 | for (byte b:byte1){ 103 | System.out.println(b); 104 | } 105 | 106 | short[] short1 = Mock.mock(short[].class); 107 | System.err.println(JsonUtil.toStr(short1)); 108 | 109 | int[] int1 = Mock.mock(int[].class); 110 | System.err.println(JsonUtil.toStr(int1)); 111 | 112 | long[] long1 = Mock.mock(long[].class); 113 | System.err.println(JsonUtil.toStr(long1)); 114 | 115 | double[] double1 = Mock.mock(double[].class); 116 | System.err.println(JsonUtil.toStr(double1)); 117 | 118 | float[] float1 = Mock.mock(float[].class); 119 | System.err.println(JsonUtil.toStr(float1)); 120 | 121 | char[] char1 = Mock.mock(char[].class); 122 | System.err.println(JsonUtil.toStr(char1)); 123 | 124 | boolean[] boolean1 = Mock.mock(boolean[].class); 125 | System.err.println(JsonUtil.toStr(boolean1)); 126 | 127 | //基本类型封装类模拟 128 | Byte[] byte2 = Mock.mock(Byte[].class); 129 | System.err.println(JsonUtil.toStr(byte2)); 130 | 131 | Short[] short2 = Mock.mock(Short[].class); 132 | System.err.println(JsonUtil.toStr(short2)); 133 | 134 | Integer[] int2 = Mock.mock(Integer[].class); 135 | System.err.println(JsonUtil.toStr(int2)); 136 | 137 | Long[] long2 = Mock.mock(Long[].class); 138 | System.err.println(JsonUtil.toStr(long2)); 139 | 140 | Double[] double2 = Mock.mock(Double[].class); 141 | System.err.println(JsonUtil.toStr(double2)); 142 | 143 | Float[] float2 = Mock.mock(Float[].class); 144 | System.err.println(JsonUtil.toStr(float2)); 145 | 146 | Character[] char2 = Mock.mock(Character[].class); 147 | System.err.println(JsonUtil.toStr(char2)); 148 | 149 | Boolean[] boolean2 = Mock.mock(Boolean[].class); 150 | System.err.println(JsonUtil.toStr(boolean2)); 151 | 152 | //常用类型 数组 模拟 153 | //字符串 154 | String[] string = Mock.mock(String[].class); 155 | System.err.println(JsonUtil.toStr(string)); 156 | //大精度 157 | BigDecimal[] bigDecimal = Mock.mock(BigDecimal[].class); 158 | System.err.println(JsonUtil.toStr(bigDecimal)); 159 | //大整形 160 | BigInteger[] bigInteger = Mock.mock(BigInteger[].class); 161 | System.out.println(JsonUtil.toStr(bigInteger)); 162 | //日期 163 | Date[] date = Mock.mock(Date[].class); 164 | System.out.println(JsonUtil.toStr(date)); 165 | //枚举 166 | DayEnum[] dayEnum = Mock.mock(DayEnum[].class); 167 | System.out.println(JsonUtil.toStr(dayEnum)); 168 | } 169 | 170 | 171 | /** 172 | * 基本类型的二维数组模拟测试 173 | */ 174 | @Test 175 | public void testArray2() { 176 | 177 | //基本类型 二维数组 模拟 178 | byte[][] byte1 = Mock.mock(byte[][].class); 179 | System.err.println(JsonUtil.toStr(byte1));//byte转json 这里做了new string 打印是string 180 | 181 | short[][] short1 = Mock.mock(short[][].class); 182 | System.err.println(JsonUtil.toStr(short1)); 183 | 184 | int[][] int1 = Mock.mock(int[][].class); 185 | System.err.println(JsonUtil.toStr(int1)); 186 | 187 | long[][] long1 = Mock.mock(long[][].class); 188 | System.err.println(JsonUtil.toStr(long1)); 189 | 190 | double[][] double1 = Mock.mock(double[][].class); 191 | System.err.println(JsonUtil.toStr(double1)); 192 | 193 | float[][] float1 = Mock.mock(float[][].class); 194 | System.err.println(JsonUtil.toStr(float1)); 195 | 196 | char[][] char1 = Mock.mock(char[][].class); 197 | System.err.println(JsonUtil.toStr(char1)); 198 | 199 | boolean[][] boolean1 = Mock.mock(boolean[][].class); 200 | System.err.println(JsonUtil.toStr(boolean1)); 201 | 202 | //基本类型封装类模拟 203 | Byte[][] byte2 = Mock.mock(Byte[][].class); 204 | System.err.println(JsonUtil.toStr(byte2)); 205 | 206 | Short[][] short2 = Mock.mock(Short[][].class); 207 | System.err.println(JsonUtil.toStr(short2)); 208 | 209 | Integer[][] int2 = Mock.mock(Integer[][].class); 210 | System.err.println(JsonUtil.toStr(int2)); 211 | 212 | Long[][] long2 = Mock.mock(Long[][].class); 213 | System.err.println(JsonUtil.toStr(long2)); 214 | 215 | Double[][] double2 = Mock.mock(Double[][].class); 216 | System.err.println(JsonUtil.toStr(double2)); 217 | 218 | Float[][] float2 = Mock.mock(Float[][].class); 219 | System.err.println(JsonUtil.toStr(float2)); 220 | 221 | Character[][] char2 = Mock.mock(Character[][].class); 222 | System.err.println(JsonUtil.toStr(char2)); 223 | 224 | Boolean[][] boolean2 = Mock.mock(Boolean[][].class); 225 | System.err.println(JsonUtil.toStr(boolean2)); 226 | 227 | //常用类型 数组 模拟 228 | //字符串 229 | String[][] string = Mock.mock(String[][].class); 230 | System.err.println(JsonUtil.toStr(string)); 231 | //大精度 232 | BigDecimal[][] bigDecimal = Mock.mock(BigDecimal[][].class); 233 | System.err.println(JsonUtil.toStr(bigDecimal)); 234 | //大整形 235 | BigInteger[][] bigInteger = Mock.mock(BigInteger[][].class); 236 | System.out.println(JsonUtil.toStr(bigInteger)); 237 | //日期 238 | Date[][] date = Mock.mock(Date[][].class); 239 | System.out.println(JsonUtil.toStr(date)); 240 | //枚举 241 | DayEnum[][] dayEnum = Mock.mock(DayEnum[][].class); 242 | System.out.println(JsonUtil.toStr(dayEnum)); 243 | } 244 | 245 | /** 246 | * 基本类型的多维数组测试 247 | */ 248 | @Test 249 | public void testArray3() { 250 | //基本类型 二维数组 模拟 251 | byte[][][] byte1 = Mock.mock(byte[][][].class); 252 | System.err.println(JsonUtil.toStr(byte1));//byte转json 这里做了new string 打印是string 253 | 254 | short[][][] short1 = Mock.mock(short[][][].class); 255 | System.err.println(JsonUtil.toStr(short1)); 256 | 257 | int[][][] int1 = Mock.mock(int[][][].class); 258 | System.err.println(JsonUtil.toStr(int1)); 259 | 260 | long[][][] long1 = Mock.mock(long[][][].class); 261 | System.err.println(JsonUtil.toStr(long1)); 262 | 263 | double[][][] double1 = Mock.mock(double[][][].class); 264 | System.err.println(JsonUtil.toStr(double1)); 265 | 266 | float[][][] float1 = Mock.mock(float[][][].class); 267 | System.err.println(JsonUtil.toStr(float1)); 268 | 269 | char[][][] char1 = Mock.mock(char[][][].class); 270 | System.err.println(JsonUtil.toStr(char1)); 271 | 272 | boolean[][][] boolean1 = Mock.mock(boolean[][][].class); 273 | System.err.println(JsonUtil.toStr(boolean1)); 274 | 275 | //基本类型封装类模拟 276 | Byte[][][] byte2 = Mock.mock(Byte[][][].class); 277 | System.err.println(JsonUtil.toStr(byte2)); 278 | 279 | Short[][][] short2 = Mock.mock(Short[][][].class); 280 | System.err.println(JsonUtil.toStr(short2)); 281 | 282 | Integer[][][] int2 = Mock.mock(Integer[][][].class); 283 | System.err.println(JsonUtil.toStr(int2)); 284 | 285 | Long[][][] long2 = Mock.mock(Long[][][].class); 286 | System.err.println(JsonUtil.toStr(long2)); 287 | 288 | Double[][][] double2 = Mock.mock(Double[][][].class); 289 | System.err.println(JsonUtil.toStr(double2)); 290 | 291 | Float[][][] float2 = Mock.mock(Float[][][].class); 292 | System.err.println(JsonUtil.toStr(float2)); 293 | 294 | Character[][][] char2 = Mock.mock(Character[][][].class); 295 | System.err.println(JsonUtil.toStr(char2)); 296 | 297 | Boolean[][][] boolean2 = Mock.mock(Boolean[][][].class); 298 | System.err.println(JsonUtil.toStr(boolean2)); 299 | 300 | //常用类型 数组 模拟 301 | //字符串 302 | String[][][] string = Mock.mock(String[][][].class); 303 | System.err.println(JsonUtil.toStr(string)); 304 | //大精度 305 | BigDecimal[][][] bigDecimal = Mock.mock(BigDecimal[][][].class); 306 | System.err.println(JsonUtil.toStr(bigDecimal)); 307 | //大整形 308 | BigInteger[][][] bigInteger = Mock.mock(BigInteger[][][].class); 309 | System.out.println(JsonUtil.toStr(bigInteger)); 310 | //日期 311 | Date[][][] date = Mock.mock(Date[][][].class); 312 | System.out.println(JsonUtil.toStr(date)); 313 | //枚举 314 | DayEnum[][][] dayEnum = Mock.mock(DayEnum[][][].class); 315 | System.out.println(JsonUtil.toStr(dayEnum)); 316 | } 317 | 318 | /** 319 | * 任意类型 320 | * 注意TypeReference要加{}才能模拟 321 | */ 322 | @Test 323 | public void testTypeRefrence() { 324 | //模拟基础类型，不建议使用这种方式，参考基础类型章节直接模拟。 325 | Integer integerNum = Mock.mock(new TypeReference() { 326 | }); 327 | System.err.println(JsonUtil.toStr(integerNum)); 328 | Integer[] integerArray = Mock.mock(new TypeReference() { 329 | }); 330 | System.err.println(JsonUtil.toStr(integerArray)); 331 | //模拟集合 332 | List integerList = Mock.mock(new TypeReference>() { 333 | }); 334 | System.err.println(JsonUtil.toStr(integerList)); 335 | //模拟数组集合 336 | List integerArrayList = Mock.mock(new TypeReference>() { 337 | }); 338 | System.err.println(JsonUtil.toStr(integerArrayList)); 339 | //模拟集合数组 340 | List[] integerListArray = Mock.mock(new TypeReference[]>() { 341 | }); 342 | System.err.println(JsonUtil.toStr(integerListArray)); 343 | //模拟集合实体 344 | List basicBeanList = Mock.mock(new TypeReference>() { 345 | }); 346 | System.err.println(JsonUtil.toStr(basicBeanList)); 347 | //各种组合忽略。。。。map同理。下面模拟一个不知道什么类型的map 348 | Map>, Map, Double[]>> some = Mock 349 | .mock(new TypeReference>, Map, Double[]>>>() { 350 | }); 351 | System.err.println(JsonUtil.toStr(some)); 352 | } 353 | 354 | @Test 355 | public void testGenericData() { 356 | GenericData genericData = Mock.mock(new TypeReference>() { 357 | }); 358 | } 359 | 360 | @Test 361 | public void testMockConfig() { 362 | MockConfig mockConfig = new MockConfig() 363 | .byteRange((byte) 0, Byte.MAX_VALUE) 364 | .shortRange((short) 0, Short.MAX_VALUE) 365 | .intRange(0, Integer.MAX_VALUE) 366 | .floatRange(0.0f, Float.MAX_VALUE) 367 | .doubleRange(0.0, Double.MAX_VALUE) 368 | .longRange(0, Long.MAX_VALUE) 369 | .dateRange("2010-01-01", "2020-12-30") 370 | .sizeRange(5, 10) 371 | .stringSeed("a", "b", "c") 372 | .charSeed((char) 97, (char) 98); 373 | BasicBean basicBean = Mock.mock(BasicBean.class, mockConfig); 374 | System.out.println(JsonUtil.toStr(basicBean)); 375 | 376 | } 377 | 378 | 379 | @Test 380 | public void testBasicData() { 381 | BasicBean basicBean = Mock.mock(BasicBean.class); 382 | System.out.println(JsonUtil.toStr(basicBean));; 383 | } 384 | 385 | /** 386 | * 测试忽略属性 387 | */ 388 | @Test 389 | public void testIgnore() { 390 | IgnoreBean a = Mock.mock(IgnoreBean.class); 391 | System.err.println(JsonUtil.toStr(a));; 392 | } 393 | 394 | 395 | 396 | @Test 397 | public void testCircular() { 398 | MockConfig mockConfig = new MockConfig().setEnabledCircle(true); 399 | AXB axb = Mock.mock(AXB.class, mockConfig); 400 | AXB circularAxb = axb.getBXA().getAXB(); 401 | assertSame(axb, circularAxb); 402 | } 403 | 404 | @Test 405 | public void testSelf() { 406 | MockConfig mockConfig = new MockConfig().setEnabledCircle(true); 407 | SelfRefData selfRefData = Mock.mock(SelfRefData.class, mockConfig); 408 | assertSame(selfRefData.getParent(), selfRefData); 409 | } 410 | 411 | /** 412 | * 测试返回汉语句子 413 | */ 414 | @Test 415 | public void testChineseString() { 416 | String mock = Mock.mock(String.class); 417 | System.out.println(mock); 418 | } 419 | 420 | 421 | /** 422 | * 测试返回汉语句子 423 | */ 424 | @Test 425 | public void testChineseStringBean() { 426 | StringBean mock = Mock.mock(StringBean.class); 427 | System.out.println(JsonUtil.toStr(mock)); 428 | } 429 | 430 | /** 431 | * 测试返回汉语句子 432 | */ 433 | @Test 434 | public void testUUID() { 435 | StringBean mock = Mock.mock(StringBean.class,new MockConfig().setStringEnum(MockConfig.StringEnum.UUID)); 436 | System.out.println(JsonUtil.toStr(mock)); 437 | } 438 | 439 | 440 | 441 | //测试识别 是否为 泛型类型 442 | @Test 443 | public void isParamType(){ 444 | Type superClass = new ArrayList().getClass().getGenericSuperclass(); 445 | System.out.println(superClass instanceof ParameterizedType); 446 | 447 | Type genericSuperclass = int.class.getGenericSuperclass(); 448 | System.out.println(genericSuperclass instanceof ParameterizedType); 449 | } 450 | 451 | } 452 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Mock 2 | Mock是一个Java实现的，可以模拟任何数据的框架。 3 | 4 | 5 | ## 特色 6 | * 支持丰富多样的数据类型模拟，包括：Java基本类型、字符串、枚举、日期、数组、多维数组、集合[List|Set|Map]、枚举、Java对象等 7 | * 支持泛型 8 | * 支持继承 9 | * 支持循环依赖、自依赖(手动开启enabledCircle) 10 | * 支持忽略字段 11 | * 支持改变mockConfig来自定义模拟数据策略 12 | * 支持JDK1.8+，无任何第三方依赖 13 | * 源代码仅有60K，很小 14 | 15 | 16 | ### 基础类型 17 | 18 | 支持以下基础类型直接模拟 19 | 20 | | 描述 | 类型 | 21 | | ------ | ---------------------------------------- | 22 | | 基础类型 | ```byte``` ```boolean``` ```char``` ```short``` ```int``` ```long``` ```float``` ```double``` | 23 | | 包装类型包装 | ```Byte``` ```Boolean``` ```Character``` ```Short``` ```Integer``` ```Long``` ```Float``` ```Double``` | 24 | | 常用类型 | ```BigDecimal``` ```BigInteger``` ```Date``` ```String``` 枚举 | 25 | | 自定义类型 | 自定义的任意class，同时支持class的互相嵌套，自嵌套，继承 等等类型 | 26 | | 多维数组 | 以上所有类型的多维数组 如：```int[]``` ```int[][]``` ```int[][][]``` .... 等 | 27 | 28 | ## 快速启动 29 | ```java 30 | T t = Mock.mock(T.class); 31 | ``` 32 | 33 | T可以是任意类型，如果T带有泛型，比如T为List ，那么使用如下方式 34 | 35 | ```java 36 | T t = Mock.mock(new TypeReference>() {}); 37 | ``` 38 | TypeReference是一个封装类，目的是封装要获取的泛型类型 39 | 40 | 其他使用方式，高级模拟方式以及详细使用参考测试代码（标注Maven工程的test包下） 41 | 42 | ## 详细使用 43 | ###基本类型，常用类型，集合（List,Set,Map）类型以及其多维数组类型 44 | ```java 45 | /** 46 | * java基本类型模拟测试 47 | */ 48 | @Test 49 | public void testBasic() { 50 | //基本类型模拟 51 | byte byte1 = Mock.mock(byte.class); 52 | System.err.println(byte1); 53 | 54 | short short1 = Mock.mock(short.class); 55 | System.err.println(short1); 56 | 57 | int int1 = Mock.mock(int.class); 58 | System.err.println(int1); 59 | 60 | long long1 = Mock.mock(long.class); 61 | System.err.println(long1); 62 | 63 | double double1 = Mock.mock(double.class); 64 | System.err.println(double1); 65 | 66 | float float1 = Mock.mock(float.class); 67 | System.err.println(float1); 68 | 69 | char char1 = Mock.mock(char.class); 70 | System.err.println(char1); 71 | 72 | boolean boolean1 = Mock.mock(boolean.class); 73 | System.err.println(boolean1); 74 | 75 | //基本类型封装类模拟 76 | Byte byte2 = Mock.mock(Byte.class); 77 | System.err.println(byte2); 78 | 79 | Short short2 = Mock.mock(Short.class); 80 | System.err.println(short2); 81 | 82 | Integer int2 = Mock.mock(Integer.class); 83 | System.err.println(int2); 84 | 85 | Long long2 = Mock.mock(Long.class); 86 | System.err.println(long2); 87 | 88 | Double double2 = Mock.mock(Double.class); 89 | System.err.println(double2); 90 | 91 | Float float2 = Mock.mock(Float.class); 92 | System.err.println(float2); 93 | 94 | Character char2 = Mock.mock(Character.class); 95 | System.err.println(char2); 96 | 97 | Boolean boolean2 = Mock.mock(Boolean.class); 98 | System.err.println(boolean2); 99 | 100 | //常用类型模拟 101 | //字符串 102 | String string = Mock.mock(String.class); 103 | System.err.println(string); 104 | //大精度 105 | BigDecimal bigDecimal = Mock.mock(BigDecimal.class); 106 | System.err.println(bigDecimal); 107 | //大整形 108 | BigInteger bigInteger = Mock.mock(BigInteger.class); 109 | System.out.println(bigInteger); 110 | //日期 111 | Date date = Mock.mock(Date.class); 112 | System.out.println(date); 113 | //枚举 114 | DayEnum dayEnum = Mock.mock(DayEnum.class); 115 | System.out.println(dayEnum); 116 | } 117 | 118 | /** 119 | * 基本类型的数组类型模拟测试 120 | */ 121 | @Test 122 | public void testArray() { 123 | 124 | //基本类型 数组 模拟 125 | byte[] byte1 = Mock.mock(byte[].class); 126 | System.err.println(JsonUtil.toStr(byte1));//byte转json 这里做了new string 打印是string 127 | //循环打印出来 128 | for (byte b:byte1){ 129 | System.out.println(b); 130 | } 131 | 132 | short[] short1 = Mock.mock(short[].class); 133 | System.err.println(JsonUtil.toStr(short1)); 134 | 135 | int[] int1 = Mock.mock(int[].class); 136 | System.err.println(JsonUtil.toStr(int1)); 137 | 138 | long[] long1 = Mock.mock(long[].class); 139 | System.err.println(JsonUtil.toStr(long1)); 140 | 141 | double[] double1 = Mock.mock(double[].class); 142 | System.err.println(JsonUtil.toStr(double1)); 143 | 144 | float[] float1 = Mock.mock(float[].class); 145 | System.err.println(JsonUtil.toStr(float1)); 146 | 147 | char[] char1 = Mock.mock(char[].class); 148 | System.err.println(JsonUtil.toStr(char1)); 149 | 150 | boolean[] boolean1 = Mock.mock(boolean[].class); 151 | System.err.println(JsonUtil.toStr(boolean1)); 152 | 153 | //基本类型封装类模拟 154 | Byte[] byte2 = Mock.mock(Byte[].class); 155 | System.err.println(JsonUtil.toStr(byte2)); 156 | 157 | Short[] short2 = Mock.mock(Short[].class); 158 | System.err.println(JsonUtil.toStr(short2)); 159 | 160 | Integer[] int2 = Mock.mock(Integer[].class); 161 | System.err.println(JsonUtil.toStr(int2)); 162 | 163 | Long[] long2 = Mock.mock(Long[].class); 164 | System.err.println(JsonUtil.toStr(long2)); 165 | 166 | Double[] double2 = Mock.mock(Double[].class); 167 | System.err.println(JsonUtil.toStr(double2)); 168 | 169 | Float[] float2 = Mock.mock(Float[].class); 170 | System.err.println(JsonUtil.toStr(float2)); 171 | 172 | Character[] char2 = Mock.mock(Character[].class); 173 | System.err.println(JsonUtil.toStr(char2)); 174 | 175 | Boolean[] boolean2 = Mock.mock(Boolean[].class); 176 | System.err.println(JsonUtil.toStr(boolean2)); 177 | 178 | //常用类型 数组 模拟 179 | //字符串 180 | String[] string = Mock.mock(String[].class); 181 | System.err.println(JsonUtil.toStr(string)); 182 | //大精度 183 | BigDecimal[] bigDecimal = Mock.mock(BigDecimal[].class); 184 | System.err.println(JsonUtil.toStr(bigDecimal)); 185 | //大整形 186 | BigInteger[] bigInteger = Mock.mock(BigInteger[].class); 187 | System.out.println(JsonUtil.toStr(bigInteger)); 188 | //日期 189 | Date[] date = Mock.mock(Date[].class); 190 | System.out.println(JsonUtil.toStr(date)); 191 | //枚举 192 | DayEnum[] dayEnum = Mock.mock(DayEnum[].class); 193 | System.out.println(JsonUtil.toStr(dayEnum)); 194 | } 195 | 196 | 197 | /** 198 | * 基本类型的二维数组模拟测试 199 | */ 200 | @Test 201 | public void testArray2() { 202 | 203 | //基本类型 二维数组 模拟 204 | byte[][] byte1 = Mock.mock(byte[][].class); 205 | System.err.println(JsonUtil.toStr(byte1));//byte转json 这里做了new string 打印是string 206 | 207 | short[][] short1 = Mock.mock(short[][].class); 208 | System.err.println(JsonUtil.toStr(short1)); 209 | 210 | int[][] int1 = Mock.mock(int[][].class); 211 | System.err.println(JsonUtil.toStr(int1)); 212 | 213 | long[][] long1 = Mock.mock(long[][].class); 214 | System.err.println(JsonUtil.toStr(long1)); 215 | 216 | double[][] double1 = Mock.mock(double[][].class); 217 | System.err.println(JsonUtil.toStr(double1)); 218 | 219 | float[][] float1 = Mock.mock(float[][].class); 220 | System.err.println(JsonUtil.toStr(float1)); 221 | 222 | char[][] char1 = Mock.mock(char[][].class); 223 | System.err.println(JsonUtil.toStr(char1)); 224 | 225 | boolean[][] boolean1 = Mock.mock(boolean[][].class); 226 | System.err.println(JsonUtil.toStr(boolean1)); 227 | 228 | //基本类型封装类模拟 229 | Byte[][] byte2 = Mock.mock(Byte[][].class); 230 | System.err.println(JsonUtil.toStr(byte2)); 231 | 232 | Short[][] short2 = Mock.mock(Short[][].class); 233 | System.err.println(JsonUtil.toStr(short2)); 234 | 235 | Integer[][] int2 = Mock.mock(Integer[][].class); 236 | System.err.println(JsonUtil.toStr(int2)); 237 | 238 | Long[][] long2 = Mock.mock(Long[][].class); 239 | System.err.println(JsonUtil.toStr(long2)); 240 | 241 | Double[][] double2 = Mock.mock(Double[][].class); 242 | System.err.println(JsonUtil.toStr(double2)); 243 | 244 | Float[][] float2 = Mock.mock(Float[][].class); 245 | System.err.println(JsonUtil.toStr(float2)); 246 | 247 | Character[][] char2 = Mock.mock(Character[][].class); 248 | System.err.println(JsonUtil.toStr(char2)); 249 | 250 | Boolean[][] boolean2 = Mock.mock(Boolean[][].class); 251 | System.err.println(JsonUtil.toStr(boolean2)); 252 | 253 | //常用类型 数组 模拟 254 | //字符串 255 | String[][] string = Mock.mock(String[][].class); 256 | System.err.println(JsonUtil.toStr(string)); 257 | //大精度 258 | BigDecimal[][] bigDecimal = Mock.mock(BigDecimal[][].class); 259 | System.err.println(JsonUtil.toStr(bigDecimal)); 260 | //大整形 261 | BigInteger[][] bigInteger = Mock.mock(BigInteger[][].class); 262 | System.out.println(JsonUtil.toStr(bigInteger)); 263 | //日期 264 | Date[][] date = Mock.mock(Date[][].class); 265 | System.out.println(JsonUtil.toStr(date)); 266 | //枚举 267 | DayEnum[][] dayEnum = Mock.mock(DayEnum[][].class); 268 | System.out.println(JsonUtil.toStr(dayEnum)); 269 | } 270 | 271 | /** 272 | * 基本类型的多维数组测试 273 | */ 274 | @Test 275 | public void testArray3() { 276 | //基本类型 三维数组 模拟 277 | byte[][][] byte1 = Mock.mock(byte[][][].class); 278 | System.err.println(JsonUtil.toStr(byte1));//byte转json 这里做了new string 打印是string 279 | 280 | short[][][] short1 = Mock.mock(short[][][].class); 281 | System.err.println(JsonUtil.toStr(short1)); 282 | 283 | int[][][] int1 = Mock.mock(int[][][].class); 284 | System.err.println(JsonUtil.toStr(int1)); 285 | 286 | long[][][] long1 = Mock.mock(long[][][].class); 287 | System.err.println(JsonUtil.toStr(long1)); 288 | 289 | double[][][] double1 = Mock.mock(double[][][].class); 290 | System.err.println(JsonUtil.toStr(double1)); 291 | 292 | float[][][] float1 = Mock.mock(float[][][].class); 293 | System.err.println(JsonUtil.toStr(float1)); 294 | 295 | char[][][] char1 = Mock.mock(char[][][].class); 296 | System.err.println(JsonUtil.toStr(char1)); 297 | 298 | boolean[][][] boolean1 = Mock.mock(boolean[][][].class); 299 | System.err.println(JsonUtil.toStr(boolean1)); 300 | 301 | //基本类型封装类模拟 302 | Byte[][][] byte2 = Mock.mock(Byte[][][].class); 303 | System.err.println(JsonUtil.toStr(byte2)); 304 | 305 | Short[][][] short2 = Mock.mock(Short[][][].class); 306 | System.err.println(JsonUtil.toStr(short2)); 307 | 308 | Integer[][][] int2 = Mock.mock(Integer[][][].class); 309 | System.err.println(JsonUtil.toStr(int2)); 310 | 311 | Long[][][] long2 = Mock.mock(Long[][][].class); 312 | System.err.println(JsonUtil.toStr(long2)); 313 | 314 | Double[][][] double2 = Mock.mock(Double[][][].class); 315 | System.err.println(JsonUtil.toStr(double2)); 316 | 317 | Float[][][] float2 = Mock.mock(Float[][][].class); 318 | System.err.println(JsonUtil.toStr(float2)); 319 | 320 | Character[][][] char2 = Mock.mock(Character[][][].class); 321 | System.err.println(JsonUtil.toStr(char2)); 322 | 323 | Boolean[][][] boolean2 = Mock.mock(Boolean[][][].class); 324 | System.err.println(JsonUtil.toStr(boolean2)); 325 | 326 | //常用类型 数组 模拟 327 | //字符串 328 | String[][][] string = Mock.mock(String[][][].class); 329 | System.err.println(JsonUtil.toStr(string)); 330 | //大精度 331 | BigDecimal[][][] bigDecimal = Mock.mock(BigDecimal[][][].class); 332 | System.err.println(JsonUtil.toStr(bigDecimal)); 333 | //大整形 334 | BigInteger[][][] bigInteger = Mock.mock(BigInteger[][][].class); 335 | System.out.println(JsonUtil.toStr(bigInteger)); 336 | //日期 337 | Date[][][] date = Mock.mock(Date[][][].class); 338 | System.out.println(JsonUtil.toStr(date)); 339 | //枚举 340 | DayEnum[][][] dayEnum = Mock.mock(DayEnum[][][].class); 341 | System.out.println(JsonUtil.toStr(dayEnum)); 342 | } 343 | 344 | ``` 345 | ### 任意类型 346 | ```java 347 | /** 348 | * 任意类型 349 | * 注意TypeReference要加{}才能模拟 350 | */ 351 | @Test 352 | public void testTypeRefrence() { 353 | //模拟基础类型，不建议使用这种方式，参考基础类型章节直接模拟。 354 | Integer integerNum = Mock.mock(new TypeReference() { 355 | }); 356 | System.err.println(JsonUtil.toStr(integerNum)); 357 | Integer[] integerArray = Mock.mock(new TypeReference() { 358 | }); 359 | System.err.println(JsonUtil.toStr(integerArray)); 360 | //模拟集合 361 | List integerList = Mock.mock(new TypeReference>() { 362 | }); 363 | System.err.println(JsonUtil.toStr(integerList)); 364 | //模拟数组集合 365 | List integerArrayList = Mock.mock(new TypeReference>() { 366 | }); 367 | System.err.println(JsonUtil.toStr(integerArrayList)); 368 | //模拟集合数组 369 | List[] integerListArray = Mock.mock(new TypeReference[]>() { 370 | }); 371 | System.err.println(JsonUtil.toStr(integerListArray)); 372 | //模拟集合实体 373 | List basicBeanList = Mock.mock(new TypeReference>() { 374 | }); 375 | System.err.println(JsonUtil.toStr(basicBeanList)); 376 | //各种组合忽略。。。。map同理。下面模拟一个不知道什么类型的map 377 | Map>, Map, Double[]>> some = Mock 378 | .mock(new TypeReference>, Map, Double[]>>>() { 379 | }); 380 | System.err.println(JsonUtil.toStr(some)); 381 | } 382 | ``` 383 | 384 | ### JAVA对象类型 385 | 386 | - 模拟bean，被模拟的数据必须是plain bean，底层采用了java自带的内省方法来获取字段和对应的setter方法。 387 | 388 | - 支持模拟继承而来的属性。 389 | 390 | ```java 391 | //模拟Java对象 392 | public class BasicBean { 393 | 394 | //基本类型 395 | private byte byteNum; 396 | private boolean booleanNum; 397 | private char charNum; 398 | private short shortNum; 399 | private int integerNum; 400 | private long longNum; 401 | private float floatNum; 402 | private double doubleNum; 403 | 404 | //基本包装类型 405 | private Byte byteBoxing; 406 | private Boolean booleanBoxing; 407 | private Character charBoxing; 408 | private Short shortBoxing; 409 | private Integer integerBoxing; 410 | private Long longBoxing; 411 | private Float floatBoxing; 412 | private Double doubleBoxing; 413 | 414 | //基本类型数组 415 | private byte[] byteNumArray; 416 | private boolean[] booleanNumArray; 417 | private char[] charNumArray; 418 | private short[] shortNumArray; 419 | private int[] integerNumArray; 420 | private long[] longNumArray; 421 | private float[] floatNumArray; 422 | private double[] doubleNumArray; 423 | 424 | //基本类型二维数组 425 | private byte[][] byteNumDoubleArray; 426 | private boolean[][] booleanNumDoubleArray; 427 | private char[][] charNumDoubleArray; 428 | private short[][] shortNumDoubleArray; 429 | private int[][] integerNumDoubleArray; 430 | private long[][] longNumDoubleArray; 431 | private float[][] floatNumDoubleArray; 432 | private double[][] doubleNumDoubleArray; 433 | 434 | //基本包装类型数组 435 | private Byte[] byteBoxingArray; 436 | private Boolean[] booleanBoxingArray; 437 | private Character[] charBoxingArray; 438 | private Short[] shortBoxingArray; 439 | private Integer[] integerBoxingArray; 440 | private Long[] longBoxingArray; 441 | private Float[] floatBoxingArray; 442 | private Double[] doubleBoxingArray; 443 | 444 | //基本包装类型二维数组 445 | private Byte[][] byteBoxingDoubleArray; 446 | private Boolean[][] booleanBoxingDoubleArray; 447 | private Character[][] charBoxingDoubleArray; 448 | private Short[][] shortBoxingDoubleArray; 449 | private Integer[][] integerBoxingDoubleArray; 450 | private Long[][] longBoxingDoubleArray; 451 | private Float[][] floatBoxingDoubleArray; 452 | private Double[][] doubleBoxingDoubleArray; 453 | 454 | //其他常用类型 455 | private BigDecimal bigDecimal; 456 | private BigInteger bigInteger; 457 | private Date date; 458 | private String string; 459 | private DayEnum dayEnum; 460 | private TimeUnit timeUnit; 461 | 462 | //其他常用类型数组 463 | private BigDecimal[] bigDecimalArray; 464 | private BigInteger[] bigIntegerArray; 465 | private Date[] dateArray; 466 | private String[] stringArray; 467 | private DayEnum[] dayEnumArray; 468 | 469 | //其他常用类型二维数组 470 | private BigDecimal[][] bigDecimalDoubleArray; 471 | private BigInteger[][] bigIntegerDoubleArray; 472 | private Date[][] dateDoubleArray; 473 | private String[][] stringDoubleArray; 474 | private DayEnum[][] dayEnumDoubleArray; 475 | 476 | //集合、MAP数组 477 | private List[] listArray; 478 | private Set[] setArray; 479 | private Map[] mapArray; 480 | 481 | //集合、MAP二维数组 482 | private List[][] listDoubleArray; 483 | private Set[][] setDoubleArray; 484 | private Map[][] mapDoubleArray; 485 | 486 | //集合、MAP二维数组(内部数组) 487 | private List[][] listInnerArrayDoubleArray; 488 | private Set[][] setInnerArrayDoubleArray; 489 | private Map[][] mapInnerArrayDoubleArray; 490 | 491 | //集合、MAP二维数组(内部二维数组) 492 | private List[][] listInnerDoubleArrayDoubleArray; 493 | private Set[][] setInnerDoubleArrayDoubleArray; 494 | private Map[][] mapInnerDoubleArrayDoubleArray; 495 | 496 | //LIST 497 | private List byteBoxingList; 498 | private List booleanBoxingList; 499 | private List charBoxingList; 500 | private List shortBoxingList; 501 | private List integerBoxingList; 502 | private List longBoxingList; 503 | private List floatBoxingList; 504 | private List doubleBoxingList; 505 | private List bigDecimalList; 506 | private List bigIntegerList; 507 | private List dateList; 508 | private List stringList; 509 | private List> stringListList; 510 | private List> stringSetList; 511 | private List> mapList; 512 | 513 | //数组LIST 514 | private List byteBoxingArrayList; 515 | private List booleanBoxingArrayList; 516 | private List charBoxingArrayList; 517 | private List shortBoxingArrayList; 518 | private List integerBoxingArrayList; 519 | private List longBoxingArrayList; 520 | private List floatBoxingArrayList; 521 | private List doubleBoxingArrayList; 522 | private List bigDecimalArrayList; 523 | private List bigIntegerArrayList; 524 | private List dateArrayList; 525 | private List stringArrayList; 526 | 527 | //二维数组LIST 528 | private List byteBoxingDoubleArrayList; 529 | private List booleanBoxingDoubleArrayList; 530 | private List charBoxingDoubleArrayList; 531 | private List shortBoxingDoubleArrayList; 532 | private List integerBoxingDoubleArrayList; 533 | private List longBoxingDoubleArrayList; 534 | private List floatBoxingDoubleArrayList; 535 | private List doubleBoxingDoubleArrayList; 536 | private List bigDecimalDoubleArrayList; 537 | private List bigIntegerDoubleArrayList; 538 | private List dateDoubleArrayList; 539 | private List stringDoubleArrayList; 540 | 541 | //SET 542 | private Set byteBoxingSet; 543 | private Set booleanBoxingSet; 544 | private Set charBoxingSet; 545 | private Set shortBoxingSet; 546 | private Set integerBoxingSet; 547 | private Set longBoxingSet; 548 | private Set floatBoxingSet; 549 | private Set doubleBoxingSet; 550 | private Set bigDecimalSet; 551 | private Set bigIntegerSet; 552 | private Set dateSet; 553 | private Set stringSet; 554 | private Set> stringListSet; 555 | private Set> stringSetSet; 556 | private Set> mapSet; 557 | 558 | //数组SET 559 | private Set byteBoxingArraySet; 560 | private Set booleanBoxingArraySet; 561 | private Set charBoxingArraySet; 562 | private Set shortBoxingArraySet; 563 | private Set integerBoxingArraySet; 564 | private Set longBoxingArraySet; 565 | private Set floatBoxingArraySet; 566 | private Set doubleBoxingArraySet; 567 | private Set bigDecimalArraySet; 568 | private Set bigIntegerArraySet; 569 | private Set dateArraySet; 570 | private Set stringArraySet; 571 | 572 | //二维数组SET 573 | private Set byteBoxingDoubleArraySet; 574 | private Set booleanBoxingDoubleArraySet; 575 | private Set charBoxingDoubleArraySet; 576 | private Set shortBoxingDoubleArraySet; 577 | private Set integerBoxingDoubleArraySet; 578 | private Set longBoxingDoubleArraySet; 579 | private Set floatBoxingDoubleArraySet; 580 | private Set doubleBoxingDoubleArraySet; 581 | private Set bigDecimalDoubleArraySet; 582 | private Set bigIntegerDoubleArraySet; 583 | private Set dateDoubleArraySet; 584 | private Set stringDoubleArraySet; 585 | 586 | //Map 587 | private Map basicMap; 588 | private Map keyArrayMap; 589 | private Map valueArrayMap; 590 | private Map keyValueArrayMap; 591 | private Map keyValueDoubleArrayMap; 592 | private Map, Map> keyListValueMapMap; 593 | private Map[], Map[]> keyArrayListValueArrayMapMap; 594 | 595 | //todo 省略了get/set方法 596 | } 597 | //调用模拟数据的方法模拟Java对象 598 | BasicBean basicBean = Mock.mock(BasicBean.class); 599 | ``` 600 | 601 | ### 忽略某个属性 602 | 603 | 在需要忽略的字段上添加注解@MockIgnore即可 604 | ```java 605 | 606 | /** 607 | * @author : peng.liu 608 | * @description : 测试忽略 属性 的bean 609 | * @date : 2018/7/16 10:13 610 | */ 611 | public class IgnoreBean { 612 | @MockIgnore 613 | private String ignore; 614 | private int notIgnore; 615 | 616 | //省略get/set方法 617 | } 618 | 619 | /** 620 | * 测试忽略属性 621 | */ 622 | @Test 623 | public void testIgnore() { 624 | IgnoreBean a = Mock.mock(IgnoreBean.class); 625 | System.err.println(JsonUtil.toStr(a));; 626 | } 627 | 628 | ``` 629 | 630 | 631 | ### 更改随机范围 632 | ```java 633 | MockConfig mockConfig = new MockConfig() 634 | .byteRange((byte) 0, Byte.MAX_VALUE) 635 | .shortRange((short) 0, Short.MAX_VALUE) 636 | .intRange(0, Integer.MAX_VALUE) 637 | .floatRange(0.0f, Float.MAX_EXPONENT) 638 | .doubleRange(0.0, Double.MAX_VALUE) 639 | .longRange(0, Long.MAX_VALUE) 640 | .dateRange("2010-01-01", "2020-12-30") 641 | .sizeRange(5, 10) 642 | .stringSeed("a", "b", "c") 643 | .charSeed((char) 97, (char) 98); 644 | BasicBean basicBean = Mock.mock(BasicBean.class, mockConfig); 645 | ``` 646 | 647 | ## 高级特性 648 | ### 循环依赖 649 | 650 | ```java 651 | public class AXB { 652 | private BXA BXA; 653 | private String name; 654 | //getter setter省略... 655 | } 656 | public class BXA { 657 | private AXB AXB; 658 | private String name; 659 | //getter setter省略... 660 | } 661 | @Test 662 | public void testCircular() { 663 | AXB axb = Mock.mock(AXB.class); 664 | AXB circularAxb = axb.getBXA().getAXB(); 665 | assertSame(axb, circularAxb); 666 | } 667 | ``` 668 | 669 | ### 自依赖 670 | 671 | ```java 672 | public class SelfRefData { 673 | 674 | private Integer id; 675 | private String name; 676 | private SelfRefData parent; 677 | private Map parentMap; 678 | private SelfRefData[] parentArray; 679 | private List list; 680 | private List listArray; 681 | private List> listListArray; 682 | private List[] arrayList; 683 | 684 | private SelfRefData[][][] data; 685 | private Map mapArray; 686 | private Map> mapList; 687 | private Map> mapListArray; 688 | //getter setter省略... 689 | } 690 | @Test 691 | public void testSelf() { 692 | SelfRefData selfRefData = Mock.mock(SelfRefData.class); 693 | assertSame(selfRefData.getParent(), selfRefData); 694 | } 695 | ``` 696 | 697 | ### 泛型继承 698 | 699 | ```java 700 | //定义一个泛型父类 701 | public class GenericData { 702 | private A a; 703 | private B b; 704 | private C c; 705 | private A[] aArray; 706 | private List bList; 707 | private Map map; 708 | private List[] cArray; 709 | private Map, List>[] d; 710 | //getter setter省略... 711 | } 712 | 713 | @Test 714 | public void testGenericData() { 715 | GenericData genericData = Mock.mock(new TypeReference>() {}); 716 | assertNotNull(genericData); 717 | } 718 | ``` 719 | ### String类型的特殊处理 720 | 目前支持： 721 | 1. 返回随机长度的英文字符 722 | 2. 返回随机长度的中文（实际是返回随机截取的一段话，种子文件我选用了朱自清的《春》，李白的《将进酒》和《滕王阁序》，在String.text文件中，你可以替换你喜欢的任何汉字，比如你希望用美国独立宣言或者水浒传都没有问题） 723 | 3. 返回uuid 724 | 预计实现： 725 | 1. url 类型，图片类型，http/https类型 其他协议类型 726 | 2. 随机生成 人名，地名 727 | 3. 生成超长文本，字符串大于65535个字符 728 | 4. 生成各种文字的混合体，默认编码utf-8 729 | 其他骚操作，以后用到再说吧 730 | # Mock来源 731 | 732 | 公司技术架构为前后台分类开发，在后端接口没有完成时需要返回模拟数据，测试时也需要模拟数据，于是需要一个可以模拟任意数据的工具，企业开发种从头写自己实现是不现实的，太浪费时间，于是github找了一个适合的进行修改，于是有了现在的mock。 733 | 734 | 修改自jsonzou的[jmockdata](https://github.com/jsonzou/jmockdata) 735 | 736 | 再次感谢大佬的源代码，阅读收益良多，也帮我快速解决了数据模拟的问题https://github.com/jsonzou/jmockdata 737 | #### 加入qq群交流 317896269 738 | 739 | -------------------------------------------------------------------------------- /src/test/java/com/mock/bean/BasicBean.java: -------------------------------------------------------------------------------- 1 | package com.mock.bean; 2 | 3 | import com.mock.bean.enums.DayEnum; 4 | 5 | import java.math.BigDecimal; 6 | import java.math.BigInteger; 7 | import java.util.Date; 8 | import java.util.List; 9 | import java.util.Map; 10 | import java.util.Set; 11 | import java.util.concurrent.TimeUnit; 12 | 13 | public class BasicBean { 14 | 15 | //基本类型 16 | private byte byteNum; 17 | private boolean booleanNum; 18 | private char charNum; 19 | private short shortNum; 20 | private int integerNum; 21 | private long longNum; 22 | private float floatNum; 23 | private double doubleNum; 24 | 25 | //基本包装类型 26 | private Byte byteBoxing; 27 | private Boolean booleanBoxing; 28 | private Character charBoxing; 29 | private Short shortBoxing; 30 | private Integer integerBoxing; 31 | private Long longBoxing; 32 | private Float floatBoxing; 33 | private Double doubleBoxing; 34 | 35 | //基本类型数组 36 | private byte[] byteNumArray; 37 | private boolean[] booleanNumArray; 38 | private char[] charNumArray; 39 | private short[] shortNumArray; 40 | private int[] integerNumArray; 41 | private long[] longNumArray; 42 | private float[] floatNumArray; 43 | private double[] doubleNumArray; 44 | 45 | //基本类型二维数组 46 | private byte[][] byteNumDoubleArray; 47 | private boolean[][] booleanNumDoubleArray; 48 | private char[][] charNumDoubleArray; 49 | private short[][] shortNumDoubleArray; 50 | private int[][] integerNumDoubleArray; 51 | private long[][] longNumDoubleArray; 52 | private float[][] floatNumDoubleArray; 53 | private double[][] doubleNumDoubleArray; 54 | 55 | //基本包装类型数组 56 | private Byte[] byteBoxingArray; 57 | private Boolean[] booleanBoxingArray; 58 | private Character[] charBoxingArray; 59 | private Short[] shortBoxingArray; 60 | private Integer[] integerBoxingArray; 61 | private Long[] longBoxingArray; 62 | private Float[] floatBoxingArray; 63 | private Double[] doubleBoxingArray; 64 | 65 | //基本包装类型二维数组 66 | private Byte[][] byteBoxingDoubleArray; 67 | private Boolean[][] booleanBoxingDoubleArray; 68 | private Character[][] charBoxingDoubleArray; 69 | private Short[][] shortBoxingDoubleArray; 70 | private Integer[][] integerBoxingDoubleArray; 71 | private Long[][] longBoxingDoubleArray; 72 | private Float[][] floatBoxingDoubleArray; 73 | private Double[][] doubleBoxingDoubleArray; 74 | 75 | //其他常用类型 76 | private BigDecimal bigDecimal; 77 | private BigInteger bigInteger; 78 | private Date date; 79 | private String string; 80 | private DayEnum dayEnum; 81 | private TimeUnit timeUnit; 82 | 83 | //其他常用类型数组 84 | private BigDecimal[] bigDecimalArray; 85 | private BigInteger[] bigIntegerArray; 86 | private Date[] dateArray; 87 | private String[] stringArray; 88 | private DayEnum[] dayEnumArray; 89 | 90 | //其他常用类型二维数组 91 | private BigDecimal[][] bigDecimalDoubleArray; 92 | private BigInteger[][] bigIntegerDoubleArray; 93 | private Date[][] dateDoubleArray; 94 | private String[][] stringDoubleArray; 95 | private DayEnum[][] dayEnumDoubleArray; 96 | 97 | //集合、MAP数组 98 | private List[] listArray; 99 | private Set[] setArray; 100 | private Map[] mapArray; 101 | 102 | //集合、MAP二维数组 103 | private List[][] listDoubleArray; 104 | private Set[][] setDoubleArray; 105 | private Map[][] mapDoubleArray; 106 | 107 | //集合、MAP二维数组(内部数组) 108 | private List[][] listInnerArrayDoubleArray; 109 | private Set[][] setInnerArrayDoubleArray; 110 | private Map[][] mapInnerArrayDoubleArray; 111 | 112 | //集合、MAP二维数组(内部二维数组) 113 | private List[][] listInnerDoubleArrayDoubleArray; 114 | private Set[][] setInnerDoubleArrayDoubleArray; 115 | private Map[][] mapInnerDoubleArrayDoubleArray; 116 | 117 | //LIST 118 | private List byteBoxingList; 119 | private List booleanBoxingList; 120 | private List charBoxingList; 121 | private List shortBoxingList; 122 | private List integerBoxingList; 123 | private List longBoxingList; 124 | private List floatBoxingList; 125 | private List doubleBoxingList; 126 | private List bigDecimalList; 127 | private List bigIntegerList; 128 | private List dateList; 129 | private List stringList; 130 | private List> stringListList; 131 | private List> stringSetList; 132 | private List> mapList; 133 | 134 | //数组LIST 135 | private List byteBoxingArrayList; 136 | private List booleanBoxingArrayList; 137 | private List charBoxingArrayList; 138 | private List shortBoxingArrayList; 139 | private List integerBoxingArrayList; 140 | private List longBoxingArrayList; 141 | private List floatBoxingArrayList; 142 | private List doubleBoxingArrayList; 143 | private List bigDecimalArrayList; 144 | private List bigIntegerArrayList; 145 | private List dateArrayList; 146 | private List stringArrayList; 147 | 148 | //二维数组LIST 149 | private List byteBoxingDoubleArrayList; 150 | private List booleanBoxingDoubleArrayList; 151 | private List charBoxingDoubleArrayList; 152 | private List shortBoxingDoubleArrayList; 153 | private List integerBoxingDoubleArrayList; 154 | private List longBoxingDoubleArrayList; 155 | private List floatBoxingDoubleArrayList; 156 | private List doubleBoxingDoubleArrayList; 157 | private List bigDecimalDoubleArrayList; 158 | private List bigIntegerDoubleArrayList; 159 | private List dateDoubleArrayList; 160 | private List stringDoubleArrayList; 161 | 162 | //SET 163 | private Set byteBoxingSet; 164 | private Set booleanBoxingSet; 165 | private Set charBoxingSet; 166 | private Set shortBoxingSet; 167 | private Set integerBoxingSet; 168 | private Set longBoxingSet; 169 | private Set floatBoxingSet; 170 | private Set doubleBoxingSet; 171 | private Set bigDecimalSet; 172 | private Set bigIntegerSet; 173 | private Set dateSet; 174 | private Set stringSet; 175 | private Set> stringListSet; 176 | private Set> stringSetSet; 177 | private Set> mapSet; 178 | 179 | //数组SET 180 | private Set byteBoxingArraySet; 181 | private Set booleanBoxingArraySet; 182 | private Set charBoxingArraySet; 183 | private Set shortBoxingArraySet; 184 | private Set integerBoxingArraySet; 185 | private Set longBoxingArraySet; 186 | private Set floatBoxingArraySet; 187 | private Set doubleBoxingArraySet; 188 | private Set bigDecimalArraySet; 189 | private Set bigIntegerArraySet; 190 | private Set dateArraySet; 191 | private Set stringArraySet; 192 | 193 | //二维数组SET 194 | private Set byteBoxingDoubleArraySet; 195 | private Set booleanBoxingDoubleArraySet; 196 | private Set charBoxingDoubleArraySet; 197 | private Set shortBoxingDoubleArraySet; 198 | private Set integerBoxingDoubleArraySet; 199 | private Set longBoxingDoubleArraySet; 200 | private Set floatBoxingDoubleArraySet; 201 | private Set doubleBoxingDoubleArraySet; 202 | private Set bigDecimalDoubleArraySet; 203 | private Set bigIntegerDoubleArraySet; 204 | private Set dateDoubleArraySet; 205 | private Set stringDoubleArraySet; 206 | 207 | //Map 208 | private Map basicMap; 209 | private Map keyArrayMap; 210 | private Map valueArrayMap; 211 | private Map keyValueArrayMap; 212 | private Map keyValueDoubleArrayMap; 213 | private Map, Map> keyListValueMapMap; 214 | private Map[], Map[]> keyArrayListValueArrayMapMap; 215 | 216 | public byte getByteNum() { 217 | return byteNum; 218 | } 219 | 220 | public void setByteNum(byte byteNum) { 221 | this.byteNum = byteNum; 222 | } 223 | 224 | public boolean isBooleanNum() { 225 | return booleanNum; 226 | } 227 | 228 | public void setBooleanNum(boolean booleanNum) { 229 | this.booleanNum = booleanNum; 230 | } 231 | 232 | public char getCharNum() { 233 | return charNum; 234 | } 235 | 236 | public void setCharNum(char charNum) { 237 | this.charNum = charNum; 238 | } 239 | 240 | public short getShortNum() { 241 | return shortNum; 242 | } 243 | 244 | public void setShortNum(short shortNum) { 245 | this.shortNum = shortNum; 246 | } 247 | 248 | public int getIntegerNum() { 249 | return integerNum; 250 | } 251 | 252 | public void setIntegerNum(int integerNum) { 253 | this.integerNum = integerNum; 254 | } 255 | 256 | public long getLongNum() { 257 | return longNum; 258 | } 259 | 260 | public void setLongNum(long longNum) { 261 | this.longNum = longNum; 262 | } 263 | 264 | public float getFloatNum() { 265 | return floatNum; 266 | } 267 | 268 | public void setFloatNum(float floatNum) { 269 | this.floatNum = floatNum; 270 | } 271 | 272 | public double getDoubleNum() { 273 | return doubleNum; 274 | } 275 | 276 | public void setDoubleNum(double doubleNum) { 277 | this.doubleNum = doubleNum; 278 | } 279 | 280 | public Byte getByteBoxing() { 281 | return byteBoxing; 282 | } 283 | 284 | public void setByteBoxing(Byte byteBoxing) { 285 | this.byteBoxing = byteBoxing; 286 | } 287 | 288 | public Boolean getBooleanBoxing() { 289 | return booleanBoxing; 290 | } 291 | 292 | public void setBooleanBoxing(Boolean booleanBoxing) { 293 | this.booleanBoxing = booleanBoxing; 294 | } 295 | 296 | public Character getCharBoxing() { 297 | return charBoxing; 298 | } 299 | 300 | public void setCharBoxing(Character charBoxing) { 301 | this.charBoxing = charBoxing; 302 | } 303 | 304 | public Short getShortBoxing() { 305 | return shortBoxing; 306 | } 307 | 308 | public void setShortBoxing(Short shortBoxing) { 309 | this.shortBoxing = shortBoxing; 310 | } 311 | 312 | public Integer getIntegerBoxing() { 313 | return integerBoxing; 314 | } 315 | 316 | public void setIntegerBoxing(Integer integerBoxing) { 317 | this.integerBoxing = integerBoxing; 318 | } 319 | 320 | public Long getLongBoxing() { 321 | return longBoxing; 322 | } 323 | 324 | public void setLongBoxing(Long longBoxing) { 325 | this.longBoxing = longBoxing; 326 | } 327 | 328 | public Float getFloatBoxing() { 329 | return floatBoxing; 330 | } 331 | 332 | public void setFloatBoxing(Float floatBoxing) { 333 | this.floatBoxing = floatBoxing; 334 | } 335 | 336 | public Double getDoubleBoxing() { 337 | return doubleBoxing; 338 | } 339 | 340 | public void setDoubleBoxing(Double doubleBoxing) { 341 | this.doubleBoxing = doubleBoxing; 342 | } 343 | 344 | public byte[] getByteNumArray() { 345 | return byteNumArray; 346 | } 347 | 348 | public void setByteNumArray(byte[] byteNumArray) { 349 | this.byteNumArray = byteNumArray; 350 | } 351 | 352 | public boolean[] getBooleanNumArray() { 353 | return booleanNumArray; 354 | } 355 | 356 | public void setBooleanNumArray(boolean[] booleanNumArray) { 357 | this.booleanNumArray = booleanNumArray; 358 | } 359 | 360 | public char[] getCharNumArray() { 361 | return charNumArray; 362 | } 363 | 364 | public void setCharNumArray(char[] charNumArray) { 365 | this.charNumArray = charNumArray; 366 | } 367 | 368 | public short[] getShortNumArray() { 369 | return shortNumArray; 370 | } 371 | 372 | public void setShortNumArray(short[] shortNumArray) { 373 | this.shortNumArray = shortNumArray; 374 | } 375 | 376 | public int[] getIntegerNumArray() { 377 | return integerNumArray; 378 | } 379 | 380 | public void setIntegerNumArray(int[] integerNumArray) { 381 | this.integerNumArray = integerNumArray; 382 | } 383 | 384 | public long[] getLongNumArray() { 385 | return longNumArray; 386 | } 387 | 388 | public void setLongNumArray(long[] longNumArray) { 389 | this.longNumArray = longNumArray; 390 | } 391 | 392 | public float[] getFloatNumArray() { 393 | return floatNumArray; 394 | } 395 | 396 | public void setFloatNumArray(float[] floatNumArray) { 397 | this.floatNumArray = floatNumArray; 398 | } 399 | 400 | public double[] getDoubleNumArray() { 401 | return doubleNumArray; 402 | } 403 | 404 | public void setDoubleNumArray(double[] doubleNumArray) { 405 | this.doubleNumArray = doubleNumArray; 406 | } 407 | 408 | public byte[][] getByteNumDoubleArray() { 409 | return byteNumDoubleArray; 410 | } 411 | 412 | public void setByteNumDoubleArray(byte[][] byteNumDoubleArray) { 413 | this.byteNumDoubleArray = byteNumDoubleArray; 414 | } 415 | 416 | public boolean[][] getBooleanNumDoubleArray() { 417 | return booleanNumDoubleArray; 418 | } 419 | 420 | public void setBooleanNumDoubleArray(boolean[][] booleanNumDoubleArray) { 421 | this.booleanNumDoubleArray = booleanNumDoubleArray; 422 | } 423 | 424 | public char[][] getCharNumDoubleArray() { 425 | return charNumDoubleArray; 426 | } 427 | 428 | public void setCharNumDoubleArray(char[][] charNumDoubleArray) { 429 | this.charNumDoubleArray = charNumDoubleArray; 430 | } 431 | 432 | public short[][] getShortNumDoubleArray() { 433 | return shortNumDoubleArray; 434 | } 435 | 436 | public void setShortNumDoubleArray(short[][] shortNumDoubleArray) { 437 | this.shortNumDoubleArray = shortNumDoubleArray; 438 | } 439 | 440 | public int[][] getIntegerNumDoubleArray() { 441 | return integerNumDoubleArray; 442 | } 443 | 444 | public void setIntegerNumDoubleArray(int[][] integerNumDoubleArray) { 445 | this.integerNumDoubleArray = integerNumDoubleArray; 446 | } 447 | 448 | public long[][] getLongNumDoubleArray() { 449 | return longNumDoubleArray; 450 | } 451 | 452 | public void setLongNumDoubleArray(long[][] longNumDoubleArray) { 453 | this.longNumDoubleArray = longNumDoubleArray; 454 | } 455 | 456 | public float[][] getFloatNumDoubleArray() { 457 | return floatNumDoubleArray; 458 | } 459 | 460 | public void setFloatNumDoubleArray(float[][] floatNumDoubleArray) { 461 | this.floatNumDoubleArray = floatNumDoubleArray; 462 | } 463 | 464 | public double[][] getDoubleNumDoubleArray() { 465 | return doubleNumDoubleArray; 466 | } 467 | 468 | public void setDoubleNumDoubleArray(double[][] doubleNumDoubleArray) { 469 | this.doubleNumDoubleArray = doubleNumDoubleArray; 470 | } 471 | 472 | public Byte[] getByteBoxingArray() { 473 | return byteBoxingArray; 474 | } 475 | 476 | public void setByteBoxingArray(Byte[] byteBoxingArray) { 477 | this.byteBoxingArray = byteBoxingArray; 478 | } 479 | 480 | public Boolean[] getBooleanBoxingArray() { 481 | return booleanBoxingArray; 482 | } 483 | 484 | public void setBooleanBoxingArray(Boolean[] booleanBoxingArray) { 485 | this.booleanBoxingArray = booleanBoxingArray; 486 | } 487 | 488 | public Character[] getCharBoxingArray() { 489 | return charBoxingArray; 490 | } 491 | 492 | public void setCharBoxingArray(Character[] charBoxingArray) { 493 | this.charBoxingArray = charBoxingArray; 494 | } 495 | 496 | public Short[] getShortBoxingArray() { 497 | return shortBoxingArray; 498 | } 499 | 500 | public void setShortBoxingArray(Short[] shortBoxingArray) { 501 | this.shortBoxingArray = shortBoxingArray; 502 | } 503 | 504 | public Integer[] getIntegerBoxingArray() { 505 | return integerBoxingArray; 506 | } 507 | 508 | public void setIntegerBoxingArray(Integer[] integerBoxingArray) { 509 | this.integerBoxingArray = integerBoxingArray; 510 | } 511 | 512 | public Long[] getLongBoxingArray() { 513 | return longBoxingArray; 514 | } 515 | 516 | public void setLongBoxingArray(Long[] longBoxingArray) { 517 | this.longBoxingArray = longBoxingArray; 518 | } 519 | 520 | public Float[] getFloatBoxingArray() { 521 | return floatBoxingArray; 522 | } 523 | 524 | public void setFloatBoxingArray(Float[] floatBoxingArray) { 525 | this.floatBoxingArray = floatBoxingArray; 526 | } 527 | 528 | public Double[] getDoubleBoxingArray() { 529 | return doubleBoxingArray; 530 | } 531 | 532 | public void setDoubleBoxingArray(Double[] doubleBoxingArray) { 533 | this.doubleBoxingArray = doubleBoxingArray; 534 | } 535 | 536 | public Byte[][] getByteBoxingDoubleArray() { 537 | return byteBoxingDoubleArray; 538 | } 539 | 540 | public void setByteBoxingDoubleArray(Byte[][] byteBoxingDoubleArray) { 541 | this.byteBoxingDoubleArray = byteBoxingDoubleArray; 542 | } 543 | 544 | public Boolean[][] getBooleanBoxingDoubleArray() { 545 | return booleanBoxingDoubleArray; 546 | } 547 | 548 | public void setBooleanBoxingDoubleArray(Boolean[][] booleanBoxingDoubleArray) { 549 | this.booleanBoxingDoubleArray = booleanBoxingDoubleArray; 550 | } 551 | 552 | public Character[][] getCharBoxingDoubleArray() { 553 | return charBoxingDoubleArray; 554 | } 555 | 556 | public void setCharBoxingDoubleArray(Character[][] charBoxingDoubleArray) { 557 | this.charBoxingDoubleArray = charBoxingDoubleArray; 558 | } 559 | 560 | public Short[][] getShortBoxingDoubleArray() { 561 | return shortBoxingDoubleArray; 562 | } 563 | 564 | public void setShortBoxingDoubleArray(Short[][] shortBoxingDoubleArray) { 565 | this.shortBoxingDoubleArray = shortBoxingDoubleArray; 566 | } 567 | 568 | public Integer[][] getIntegerBoxingDoubleArray() { 569 | return integerBoxingDoubleArray; 570 | } 571 | 572 | public void setIntegerBoxingDoubleArray(Integer[][] integerBoxingDoubleArray) { 573 | this.integerBoxingDoubleArray = integerBoxingDoubleArray; 574 | } 575 | 576 | public Long[][] getLongBoxingDoubleArray() { 577 | return longBoxingDoubleArray; 578 | } 579 | 580 | public void setLongBoxingDoubleArray(Long[][] longBoxingDoubleArray) { 581 | this.longBoxingDoubleArray = longBoxingDoubleArray; 582 | } 583 | 584 | public Float[][] getFloatBoxingDoubleArray() { 585 | return floatBoxingDoubleArray; 586 | } 587 | 588 | public void setFloatBoxingDoubleArray(Float[][] floatBoxingDoubleArray) { 589 | this.floatBoxingDoubleArray = floatBoxingDoubleArray; 590 | } 591 | 592 | public Double[][] getDoubleBoxingDoubleArray() { 593 | return doubleBoxingDoubleArray; 594 | } 595 | 596 | public void setDoubleBoxingDoubleArray(Double[][] doubleBoxingDoubleArray) { 597 | this.doubleBoxingDoubleArray = doubleBoxingDoubleArray; 598 | } 599 | 600 | public BigDecimal getBigDecimal() { 601 | return bigDecimal; 602 | } 603 | 604 | public void setBigDecimal(BigDecimal bigDecimal) { 605 | this.bigDecimal = bigDecimal; 606 | } 607 | 608 | public BigInteger getBigInteger() { 609 | return bigInteger; 610 | } 611 | 612 | public void setBigInteger(BigInteger bigInteger) { 613 | this.bigInteger = bigInteger; 614 | } 615 | 616 | public Date getDate() { 617 | return date; 618 | } 619 | 620 | public void setDate(Date date) { 621 | this.date = date; 622 | } 623 | 624 | public String getString() { 625 | return string; 626 | } 627 | 628 | public void setString(String string) { 629 | this.string = string; 630 | } 631 | 632 | public DayEnum getDayEnum() { 633 | return dayEnum; 634 | } 635 | 636 | public void setDayEnum(DayEnum dayEnum) { 637 | this.dayEnum = dayEnum; 638 | } 639 | 640 | public TimeUnit getTimeUnit() { 641 | return timeUnit; 642 | } 643 | 644 | public void setTimeUnit(TimeUnit timeUnit) { 645 | this.timeUnit = timeUnit; 646 | } 647 | 648 | public BigDecimal[] getBigDecimalArray() { 649 | return bigDecimalArray; 650 | } 651 | 652 | public void setBigDecimalArray(BigDecimal[] bigDecimalArray) { 653 | this.bigDecimalArray = bigDecimalArray; 654 | } 655 | 656 | public BigInteger[] getBigIntegerArray() { 657 | return bigIntegerArray; 658 | } 659 | 660 | public void setBigIntegerArray(BigInteger[] bigIntegerArray) { 661 | this.bigIntegerArray = bigIntegerArray; 662 | } 663 | 664 | public Date[] getDateArray() { 665 | return dateArray; 666 | } 667 | 668 | public void setDateArray(Date[] dateArray) { 669 | this.dateArray = dateArray; 670 | } 671 | 672 | public String[] getStringArray() { 673 | return stringArray; 674 | } 675 | 676 | public void setStringArray(String[] stringArray) { 677 | this.stringArray = stringArray; 678 | } 679 | 680 | public DayEnum[] getDayEnumArray() { 681 | return dayEnumArray; 682 | } 683 | 684 | public void setDayEnumArray(DayEnum[] dayEnumArray) { 685 | this.dayEnumArray = dayEnumArray; 686 | } 687 | 688 | public BigDecimal[][] getBigDecimalDoubleArray() { 689 | return bigDecimalDoubleArray; 690 | } 691 | 692 | public void setBigDecimalDoubleArray(BigDecimal[][] bigDecimalDoubleArray) { 693 | this.bigDecimalDoubleArray = bigDecimalDoubleArray; 694 | } 695 | 696 | public BigInteger[][] getBigIntegerDoubleArray() { 697 | return bigIntegerDoubleArray; 698 | } 699 | 700 | public void setBigIntegerDoubleArray(BigInteger[][] bigIntegerDoubleArray) { 701 | this.bigIntegerDoubleArray = bigIntegerDoubleArray; 702 | } 703 | 704 | public Date[][] getDateDoubleArray() { 705 | return dateDoubleArray; 706 | } 707 | 708 | public void setDateDoubleArray(Date[][] dateDoubleArray) { 709 | this.dateDoubleArray = dateDoubleArray; 710 | } 711 | 712 | public String[][] getStringDoubleArray() { 713 | return stringDoubleArray; 714 | } 715 | 716 | public void setStringDoubleArray(String[][] stringDoubleArray) { 717 | this.stringDoubleArray = stringDoubleArray; 718 | } 719 | 720 | public DayEnum[][] getDayEnumDoubleArray() { 721 | return dayEnumDoubleArray; 722 | } 723 | 724 | public void setDayEnumDoubleArray(DayEnum[][] dayEnumDoubleArray) { 725 | this.dayEnumDoubleArray = dayEnumDoubleArray; 726 | } 727 | 728 | public List[] getListArray() { 729 | return listArray; 730 | } 731 | 732 | public void setListArray(List[] listArray) { 733 | this.listArray = listArray; 734 | } 735 | 736 | public Set[] getSetArray() { 737 | return setArray; 738 | } 739 | 740 | public void setSetArray(Set[] setArray) { 741 | this.setArray = setArray; 742 | } 743 | 744 | public Map[] getMapArray() { 745 | return mapArray; 746 | } 747 | 748 | public void setMapArray(Map[] mapArray) { 749 | this.mapArray = mapArray; 750 | } 751 | 752 | public List[][] getListDoubleArray() { 753 | return listDoubleArray; 754 | } 755 | 756 | public void setListDoubleArray(List[][] listDoubleArray) { 757 | this.listDoubleArray = listDoubleArray; 758 | } 759 | 760 | public Set[][] getSetDoubleArray() { 761 | return setDoubleArray; 762 | } 763 | 764 | public void setSetDoubleArray(Set[][] setDoubleArray) { 765 | this.setDoubleArray = setDoubleArray; 766 | } 767 | 768 | public Map[][] getMapDoubleArray() { 769 | return mapDoubleArray; 770 | } 771 | 772 | public void setMapDoubleArray(Map[][] mapDoubleArray) { 773 | this.mapDoubleArray = mapDoubleArray; 774 | } 775 | 776 | public List[][] getListInnerArrayDoubleArray() { 777 | return listInnerArrayDoubleArray; 778 | } 779 | 780 | public void setListInnerArrayDoubleArray(List[][] listInnerArrayDoubleArray) { 781 | this.listInnerArrayDoubleArray = listInnerArrayDoubleArray; 782 | } 783 | 784 | public Set[][] getSetInnerArrayDoubleArray() { 785 | return setInnerArrayDoubleArray; 786 | } 787 | 788 | public void setSetInnerArrayDoubleArray(Set[][] setInnerArrayDoubleArray) { 789 | this.setInnerArrayDoubleArray = setInnerArrayDoubleArray; 790 | } 791 | 792 | public Map[][] getMapInnerArrayDoubleArray() { 793 | return mapInnerArrayDoubleArray; 794 | } 795 | 796 | public void setMapInnerArrayDoubleArray(Map[][] mapInnerArrayDoubleArray) { 797 | this.mapInnerArrayDoubleArray = mapInnerArrayDoubleArray; 798 | } 799 | 800 | public List[][] getListInnerDoubleArrayDoubleArray() { 801 | return listInnerDoubleArrayDoubleArray; 802 | } 803 | 804 | public void setListInnerDoubleArrayDoubleArray(List[][] listInnerDoubleArrayDoubleArray) { 805 | this.listInnerDoubleArrayDoubleArray = listInnerDoubleArrayDoubleArray; 806 | } 807 | 808 | public Set[][] getSetInnerDoubleArrayDoubleArray() { 809 | return setInnerDoubleArrayDoubleArray; 810 | } 811 | 812 | public void setSetInnerDoubleArrayDoubleArray(Set[][] setInnerDoubleArrayDoubleArray) { 813 | this.setInnerDoubleArrayDoubleArray = setInnerDoubleArrayDoubleArray; 814 | } 815 | 816 | public Map[][] getMapInnerDoubleArrayDoubleArray() { 817 | return mapInnerDoubleArrayDoubleArray; 818 | } 819 | 820 | public void setMapInnerDoubleArrayDoubleArray(Map[][] mapInnerDoubleArrayDoubleArray) { 821 | this.mapInnerDoubleArrayDoubleArray = mapInnerDoubleArrayDoubleArray; 822 | } 823 | 824 | public List getByteBoxingList() { 825 | return byteBoxingList; 826 | } 827 | 828 | public void setByteBoxingList(List byteBoxingList) { 829 | this.byteBoxingList = byteBoxingList; 830 | } 831 | 832 | public List getBooleanBoxingList() { 833 | return booleanBoxingList; 834 | } 835 | 836 | public void setBooleanBoxingList(List booleanBoxingList) { 837 | this.booleanBoxingList = booleanBoxingList; 838 | } 839 | 840 | public List getCharBoxingList() { 841 | return charBoxingList; 842 | } 843 | 844 | public void setCharBoxingList(List charBoxingList) { 845 | this.charBoxingList = charBoxingList; 846 | } 847 | 848 | public List getShortBoxingList() { 849 | return shortBoxingList; 850 | } 851 | 852 | public void setShortBoxingList(List shortBoxingList) { 853 | this.shortBoxingList = shortBoxingList; 854 | } 855 | 856 | public List getIntegerBoxingList() { 857 | return integerBoxingList; 858 | } 859 | 860 | public void setIntegerBoxingList(List integerBoxingList) { 861 | this.integerBoxingList = integerBoxingList; 862 | } 863 | 864 | public List getLongBoxingList() { 865 | return longBoxingList; 866 | } 867 | 868 | public void setLongBoxingList(List longBoxingList) { 869 | this.longBoxingList = longBoxingList; 870 | } 871 | 872 | public List getFloatBoxingList() { 873 | return floatBoxingList; 874 | } 875 | 876 | public void setFloatBoxingList(List floatBoxingList) { 877 | this.floatBoxingList = floatBoxingList; 878 | } 879 | 880 | public List getDoubleBoxingList() { 881 | return doubleBoxingList; 882 | } 883 | 884 | public void setDoubleBoxingList(List doubleBoxingList) { 885 | this.doubleBoxingList = doubleBoxingList; 886 | } 887 | 888 | public List getBigDecimalList() { 889 | return bigDecimalList; 890 | } 891 | 892 | public void setBigDecimalList(List bigDecimalList) { 893 | this.bigDecimalList = bigDecimalList; 894 | } 895 | 896 | public List getBigIntegerList() { 897 | return bigIntegerList; 898 | } 899 | 900 | public void setBigIntegerList(List bigIntegerList) { 901 | this.bigIntegerList = bigIntegerList; 902 | } 903 | 904 | public List getDateList() { 905 | return dateList; 906 | } 907 | 908 | public void setDateList(List dateList) { 909 | this.dateList = dateList; 910 | } 911 | 912 | public List getStringList() { 913 | return stringList; 914 | } 915 | 916 | public void setStringList(List stringList) { 917 | this.stringList = stringList; 918 | } 919 | 920 | public List> getStringListList() { 921 | return stringListList; 922 | } 923 | 924 | public void setStringListList(List> stringListList) { 925 | this.stringListList = stringListList; 926 | } 927 | 928 | public List> getStringSetList() { 929 | return stringSetList; 930 | } 931 | 932 | public void setStringSetList(List> stringSetList) { 933 | this.stringSetList = stringSetList; 934 | } 935 | 936 | public List> getMapList() { 937 | return mapList; 938 | } 939 | 940 | public void setMapList(List> mapList) { 941 | this.mapList = mapList; 942 | } 943 | 944 | public List getByteBoxingArrayList() { 945 | return byteBoxingArrayList; 946 | } 947 | 948 | public void setByteBoxingArrayList(List byteBoxingArrayList) { 949 | this.byteBoxingArrayList = byteBoxingArrayList; 950 | } 951 | 952 | public List getBooleanBoxingArrayList() { 953 | return booleanBoxingArrayList; 954 | } 955 | 956 | public void setBooleanBoxingArrayList(List booleanBoxingArrayList) { 957 | this.booleanBoxingArrayList = booleanBoxingArrayList; 958 | } 959 | 960 | public List getCharBoxingArrayList() { 961 | return charBoxingArrayList; 962 | } 963 | 964 | public void setCharBoxingArrayList(List charBoxingArrayList) { 965 | this.charBoxingArrayList = charBoxingArrayList; 966 | } 967 | 968 | public List getShortBoxingArrayList() { 969 | return shortBoxingArrayList; 970 | } 971 | 972 | public void setShortBoxingArrayList(List shortBoxingArrayList) { 973 | this.shortBoxingArrayList = shortBoxingArrayList; 974 | } 975 | 976 | public List getIntegerBoxingArrayList() { 977 | return integerBoxingArrayList; 978 | } 979 | 980 | public void setIntegerBoxingArrayList(List integerBoxingArrayList) { 981 | this.integerBoxingArrayList = integerBoxingArrayList; 982 | } 983 | 984 | public List getLongBoxingArrayList() { 985 | return longBoxingArrayList; 986 | } 987 | 988 | public void setLongBoxingArrayList(List longBoxingArrayList) { 989 | this.longBoxingArrayList = longBoxingArrayList; 990 | } 991 | 992 | public List getFloatBoxingArrayList() { 993 | return floatBoxingArrayList; 994 | } 995 | 996 | public void setFloatBoxingArrayList(List floatBoxingArrayList) { 997 | this.floatBoxingArrayList = floatBoxingArrayList; 998 | } 999 | 1000 | public List getDoubleBoxingArrayList() { 1001 | return doubleBoxingArrayList; 1002 | } 1003 | 1004 | public void setDoubleBoxingArrayList(List doubleBoxingArrayList) { 1005 | this.doubleBoxingArrayList = doubleBoxingArrayList; 1006 | } 1007 | 1008 | public List getBigDecimalArrayList() { 1009 | return bigDecimalArrayList; 1010 | } 1011 | 1012 | public void setBigDecimalArrayList(List bigDecimalArrayList) { 1013 | this.bigDecimalArrayList = bigDecimalArrayList; 1014 | } 1015 | 1016 | public List getBigIntegerArrayList() { 1017 | return bigIntegerArrayList; 1018 | } 1019 | 1020 | public void setBigIntegerArrayList(List bigIntegerArrayList) { 1021 | this.bigIntegerArrayList = bigIntegerArrayList; 1022 | } 1023 | 1024 | public List getDateArrayList() { 1025 | return dateArrayList; 1026 | } 1027 | 1028 | public void setDateArrayList(List dateArrayList) { 1029 | this.dateArrayList = dateArrayList; 1030 | } 1031 | 1032 | public List getStringArrayList() { 1033 | return stringArrayList; 1034 | } 1035 | 1036 | public void setStringArrayList(List stringArrayList) { 1037 | this.stringArrayList = stringArrayList; 1038 | } 1039 | 1040 | public List getByteBoxingDoubleArrayList() { 1041 | return byteBoxingDoubleArrayList; 1042 | } 1043 | 1044 | public void setByteBoxingDoubleArrayList(List byteBoxingDoubleArrayList) { 1045 | this.byteBoxingDoubleArrayList = byteBoxingDoubleArrayList; 1046 | } 1047 | 1048 | public List getBooleanBoxingDoubleArrayList() { 1049 | return booleanBoxingDoubleArrayList; 1050 | } 1051 | 1052 | public void setBooleanBoxingDoubleArrayList(List booleanBoxingDoubleArrayList) { 1053 | this.booleanBoxingDoubleArrayList = booleanBoxingDoubleArrayList; 1054 | } 1055 | 1056 | public List getCharBoxingDoubleArrayList() { 1057 | return charBoxingDoubleArrayList; 1058 | } 1059 | 1060 | public void setCharBoxingDoubleArrayList(List charBoxingDoubleArrayList) { 1061 | this.charBoxingDoubleArrayList = charBoxingDoubleArrayList; 1062 | } 1063 | 1064 | public List getShortBoxingDoubleArrayList() { 1065 | return shortBoxingDoubleArrayList; 1066 | } 1067 | 1068 | public void setShortBoxingDoubleArrayList(List shortBoxingDoubleArrayList) { 1069 | this.shortBoxingDoubleArrayList = shortBoxingDoubleArrayList; 1070 | } 1071 | 1072 | public List getIntegerBoxingDoubleArrayList() { 1073 | return integerBoxingDoubleArrayList; 1074 | } 1075 | 1076 | public void setIntegerBoxingDoubleArrayList(List integerBoxingDoubleArrayList) { 1077 | this.integerBoxingDoubleArrayList = integerBoxingDoubleArrayList; 1078 | } 1079 | 1080 | public List getLongBoxingDoubleArrayList() { 1081 | return longBoxingDoubleArrayList; 1082 | } 1083 | 1084 | public void setLongBoxingDoubleArrayList(List longBoxingDoubleArrayList) { 1085 | this.longBoxingDoubleArrayList = longBoxingDoubleArrayList; 1086 | } 1087 | 1088 | public List getFloatBoxingDoubleArrayList() { 1089 | return floatBoxingDoubleArrayList; 1090 | } 1091 | 1092 | public void setFloatBoxingDoubleArrayList(List floatBoxingDoubleArrayList) { 1093 | this.floatBoxingDoubleArrayList = floatBoxingDoubleArrayList; 1094 | } 1095 | 1096 | public List getDoubleBoxingDoubleArrayList() { 1097 | return doubleBoxingDoubleArrayList; 1098 | } 1099 | 1100 | public void setDoubleBoxingDoubleArrayList(List doubleBoxingDoubleArrayList) { 1101 | this.doubleBoxingDoubleArrayList = doubleBoxingDoubleArrayList; 1102 | } 1103 | 1104 | public List getBigDecimalDoubleArrayList() { 1105 | return bigDecimalDoubleArrayList; 1106 | } 1107 | 1108 | public void setBigDecimalDoubleArrayList(List bigDecimalDoubleArrayList) { 1109 | this.bigDecimalDoubleArrayList = bigDecimalDoubleArrayList; 1110 | } 1111 | 1112 | public List getBigIntegerDoubleArrayList() { 1113 | return bigIntegerDoubleArrayList; 1114 | } 1115 | 1116 | public void setBigIntegerDoubleArrayList(List bigIntegerDoubleArrayList) { 1117 | this.bigIntegerDoubleArrayList = bigIntegerDoubleArrayList; 1118 | } 1119 | 1120 | public List getDateDoubleArrayList() { 1121 | return dateDoubleArrayList; 1122 | } 1123 | 1124 | public void setDateDoubleArrayList(List dateDoubleArrayList) { 1125 | this.dateDoubleArrayList = dateDoubleArrayList; 1126 | } 1127 | 1128 | public List getStringDoubleArrayList() { 1129 | return stringDoubleArrayList; 1130 | } 1131 | 1132 | public void setStringDoubleArrayList(List stringDoubleArrayList) { 1133 | this.stringDoubleArrayList = stringDoubleArrayList; 1134 | } 1135 | 1136 | public Set getByteBoxingSet() { 1137 | return byteBoxingSet; 1138 | } 1139 | 1140 | public void setByteBoxingSet(Set byteBoxingSet) { 1141 | this.byteBoxingSet = byteBoxingSet; 1142 | } 1143 | 1144 | public Set getBooleanBoxingSet() { 1145 | return booleanBoxingSet; 1146 | } 1147 | 1148 | public void setBooleanBoxingSet(Set booleanBoxingSet) { 1149 | this.booleanBoxingSet = booleanBoxingSet; 1150 | } 1151 | 1152 | public Set getCharBoxingSet() { 1153 | return charBoxingSet; 1154 | } 1155 | 1156 | public void setCharBoxingSet(Set charBoxingSet) { 1157 | this.charBoxingSet = charBoxingSet; 1158 | } 1159 | 1160 | public Set getShortBoxingSet() { 1161 | return shortBoxingSet; 1162 | } 1163 | 1164 | public void setShortBoxingSet(Set shortBoxingSet) { 1165 | this.shortBoxingSet = shortBoxingSet; 1166 | } 1167 | 1168 | public Set getIntegerBoxingSet() { 1169 | return integerBoxingSet; 1170 | } 1171 | 1172 | public void setIntegerBoxingSet(Set integerBoxingSet) { 1173 | this.integerBoxingSet = integerBoxingSet; 1174 | } 1175 | 1176 | public Set getLongBoxingSet() { 1177 | return longBoxingSet; 1178 | } 1179 | 1180 | public void setLongBoxingSet(Set longBoxingSet) { 1181 | this.longBoxingSet = longBoxingSet; 1182 | } 1183 | 1184 | public Set getFloatBoxingSet() { 1185 | return floatBoxingSet; 1186 | } 1187 | 1188 | public void setFloatBoxingSet(Set floatBoxingSet) { 1189 | this.floatBoxingSet = floatBoxingSet; 1190 | } 1191 | 1192 | public Set getDoubleBoxingSet() { 1193 | return doubleBoxingSet; 1194 | } 1195 | 1196 | public void setDoubleBoxingSet(Set doubleBoxingSet) { 1197 | this.doubleBoxingSet = doubleBoxingSet; 1198 | } 1199 | 1200 | public Set getBigDecimalSet() { 1201 | return bigDecimalSet; 1202 | } 1203 | 1204 | public void setBigDecimalSet(Set bigDecimalSet) { 1205 | this.bigDecimalSet = bigDecimalSet; 1206 | } 1207 | 1208 | public Set getBigIntegerSet() { 1209 | return bigIntegerSet; 1210 | } 1211 | 1212 | public void setBigIntegerSet(Set bigIntegerSet) { 1213 | this.bigIntegerSet = bigIntegerSet; 1214 | } 1215 | 1216 | public Set getDateSet() { 1217 | return dateSet; 1218 | } 1219 | 1220 | public void setDateSet(Set dateSet) { 1221 | this.dateSet = dateSet; 1222 | } 1223 | 1224 | public Set getStringSet() { 1225 | return stringSet; 1226 | } 1227 | 1228 | public void setStringSet(Set stringSet) { 1229 | this.stringSet = stringSet; 1230 | } 1231 | 1232 | public Set> getStringListSet() { 1233 | return stringListSet; 1234 | } 1235 | 1236 | public void setStringListSet(Set> stringListSet) { 1237 | this.stringListSet = stringListSet; 1238 | } 1239 | 1240 | public Set> getStringSetSet() { 1241 | return stringSetSet; 1242 | } 1243 | 1244 | public void setStringSetSet(Set> stringSetSet) { 1245 | this.stringSetSet = stringSetSet; 1246 | } 1247 | 1248 | public Set> getMapSet() { 1249 | return mapSet; 1250 | } 1251 | 1252 | public void setMapSet(Set> mapSet) { 1253 | this.mapSet = mapSet; 1254 | } 1255 | 1256 | public Set getByteBoxingArraySet() { 1257 | return byteBoxingArraySet; 1258 | } 1259 | 1260 | public void setByteBoxingArraySet(Set byteBoxingArraySet) { 1261 | this.byteBoxingArraySet = byteBoxingArraySet; 1262 | } 1263 | 1264 | public Set getBooleanBoxingArraySet() { 1265 | return booleanBoxingArraySet; 1266 | } 1267 | 1268 | public void setBooleanBoxingArraySet(Set booleanBoxingArraySet) { 1269 | this.booleanBoxingArraySet = booleanBoxingArraySet; 1270 | } 1271 | 1272 | public Set getCharBoxingArraySet() { 1273 | return charBoxingArraySet; 1274 | } 1275 | 1276 | public void setCharBoxingArraySet(Set charBoxingArraySet) { 1277 | this.charBoxingArraySet = charBoxingArraySet; 1278 | } 1279 | 1280 | public Set getShortBoxingArraySet() { 1281 | return shortBoxingArraySet; 1282 | } 1283 | 1284 | public void setShortBoxingArraySet(Set shortBoxingArraySet) { 1285 | this.shortBoxingArraySet = shortBoxingArraySet; 1286 | } 1287 | 1288 | public Set getIntegerBoxingArraySet() { 1289 | return integerBoxingArraySet; 1290 | } 1291 | 1292 | public void setIntegerBoxingArraySet(Set integerBoxingArraySet) { 1293 | this.integerBoxingArraySet = integerBoxingArraySet; 1294 | } 1295 | 1296 | public Set getLongBoxingArraySet() { 1297 | return longBoxingArraySet; 1298 | } 1299 | 1300 | public void setLongBoxingArraySet(Set longBoxingArraySet) { 1301 | this.longBoxingArraySet = longBoxingArraySet; 1302 | } 1303 | 1304 | public Set getFloatBoxingArraySet() { 1305 | return floatBoxingArraySet; 1306 | } 1307 | 1308 | public void setFloatBoxingArraySet(Set floatBoxingArraySet) { 1309 | this.floatBoxingArraySet = floatBoxingArraySet; 1310 | } 1311 | 1312 | public Set getDoubleBoxingArraySet() { 1313 | return doubleBoxingArraySet; 1314 | } 1315 | 1316 | public void setDoubleBoxingArraySet(Set doubleBoxingArraySet) { 1317 | this.doubleBoxingArraySet = doubleBoxingArraySet; 1318 | } 1319 | 1320 | public Set getBigDecimalArraySet() { 1321 | return bigDecimalArraySet; 1322 | } 1323 | 1324 | public void setBigDecimalArraySet(Set bigDecimalArraySet) { 1325 | this.bigDecimalArraySet = bigDecimalArraySet; 1326 | } 1327 | 1328 | public Set getBigIntegerArraySet() { 1329 | return bigIntegerArraySet; 1330 | } 1331 | 1332 | public void setBigIntegerArraySet(Set bigIntegerArraySet) { 1333 | this.bigIntegerArraySet = bigIntegerArraySet; 1334 | } 1335 | 1336 | public Set getDateArraySet() { 1337 | return dateArraySet; 1338 | } 1339 | 1340 | public void setDateArraySet(Set dateArraySet) { 1341 | this.dateArraySet = dateArraySet; 1342 | } 1343 | 1344 | public Set getStringArraySet() { 1345 | return stringArraySet; 1346 | } 1347 | 1348 | public void setStringArraySet(Set stringArraySet) { 1349 | this.stringArraySet = stringArraySet; 1350 | } 1351 | 1352 | public Set getByteBoxingDoubleArraySet() { 1353 | return byteBoxingDoubleArraySet; 1354 | } 1355 | 1356 | public void setByteBoxingDoubleArraySet(Set byteBoxingDoubleArraySet) { 1357 | this.byteBoxingDoubleArraySet = byteBoxingDoubleArraySet; 1358 | } 1359 | 1360 | public Set getBooleanBoxingDoubleArraySet() { 1361 | return booleanBoxingDoubleArraySet; 1362 | } 1363 | 1364 | public void setBooleanBoxingDoubleArraySet(Set booleanBoxingDoubleArraySet) { 1365 | this.booleanBoxingDoubleArraySet = booleanBoxingDoubleArraySet; 1366 | } 1367 | 1368 | public Set getCharBoxingDoubleArraySet() { 1369 | return charBoxingDoubleArraySet; 1370 | } 1371 | 1372 | public void setCharBoxingDoubleArraySet(Set charBoxingDoubleArraySet) { 1373 | this.charBoxingDoubleArraySet = charBoxingDoubleArraySet; 1374 | } 1375 | 1376 | public Set getShortBoxingDoubleArraySet() { 1377 | return shortBoxingDoubleArraySet; 1378 | } 1379 | 1380 | public void setShortBoxingDoubleArraySet(Set shortBoxingDoubleArraySet) { 1381 | this.shortBoxingDoubleArraySet = shortBoxingDoubleArraySet; 1382 | } 1383 | 1384 | public Set getIntegerBoxingDoubleArraySet() { 1385 | return integerBoxingDoubleArraySet; 1386 | } 1387 | 1388 | public void setIntegerBoxingDoubleArraySet(Set integerBoxingDoubleArraySet) { 1389 | this.integerBoxingDoubleArraySet = integerBoxingDoubleArraySet; 1390 | } 1391 | 1392 | public Set getLongBoxingDoubleArraySet() { 1393 | return longBoxingDoubleArraySet; 1394 | } 1395 | 1396 | public void setLongBoxingDoubleArraySet(Set longBoxingDoubleArraySet) { 1397 | this.longBoxingDoubleArraySet = longBoxingDoubleArraySet; 1398 | } 1399 | 1400 | public Set getFloatBoxingDoubleArraySet() { 1401 | return floatBoxingDoubleArraySet; 1402 | } 1403 | 1404 | public void setFloatBoxingDoubleArraySet(Set floatBoxingDoubleArraySet) { 1405 | this.floatBoxingDoubleArraySet = floatBoxingDoubleArraySet; 1406 | } 1407 | 1408 | public Set getDoubleBoxingDoubleArraySet() { 1409 | return doubleBoxingDoubleArraySet; 1410 | } 1411 | 1412 | public void setDoubleBoxingDoubleArraySet(Set doubleBoxingDoubleArraySet) { 1413 | this.doubleBoxingDoubleArraySet = doubleBoxingDoubleArraySet; 1414 | } 1415 | 1416 | public Set getBigDecimalDoubleArraySet() { 1417 | return bigDecimalDoubleArraySet; 1418 | } 1419 | 1420 | public void setBigDecimalDoubleArraySet(Set bigDecimalDoubleArraySet) { 1421 | this.bigDecimalDoubleArraySet = bigDecimalDoubleArraySet; 1422 | } 1423 | 1424 | public Set getBigIntegerDoubleArraySet() { 1425 | return bigIntegerDoubleArraySet; 1426 | } 1427 | 1428 | public void setBigIntegerDoubleArraySet(Set bigIntegerDoubleArraySet) { 1429 | this.bigIntegerDoubleArraySet = bigIntegerDoubleArraySet; 1430 | } 1431 | 1432 | public Set getDateDoubleArraySet() { 1433 | return dateDoubleArraySet; 1434 | } 1435 | 1436 | public void setDateDoubleArraySet(Set dateDoubleArraySet) { 1437 | this.dateDoubleArraySet = dateDoubleArraySet; 1438 | } 1439 | 1440 | public Set getStringDoubleArraySet() { 1441 | return stringDoubleArraySet; 1442 | } 1443 | 1444 | public void setStringDoubleArraySet(Set stringDoubleArraySet) { 1445 | this.stringDoubleArraySet = stringDoubleArraySet; 1446 | } 1447 | 1448 | public Map getBasicMap() { 1449 | return basicMap; 1450 | } 1451 | 1452 | public void setBasicMap(Map basicMap) { 1453 | this.basicMap = basicMap; 1454 | } 1455 | 1456 | public Map getKeyArrayMap() { 1457 | return keyArrayMap; 1458 | } 1459 | 1460 | public void setKeyArrayMap(Map keyArrayMap) { 1461 | this.keyArrayMap = keyArrayMap; 1462 | } 1463 | 1464 | public Map getValueArrayMap() { 1465 | return valueArrayMap; 1466 | } 1467 | 1468 | public void setValueArrayMap(Map valueArrayMap) { 1469 | this.valueArrayMap = valueArrayMap; 1470 | } 1471 | 1472 | public Map getKeyValueArrayMap() { 1473 | return keyValueArrayMap; 1474 | } 1475 | 1476 | public void setKeyValueArrayMap(Map keyValueArrayMap) { 1477 | this.keyValueArrayMap = keyValueArrayMap; 1478 | } 1479 | 1480 | public Map getKeyValueDoubleArrayMap() { 1481 | return keyValueDoubleArrayMap; 1482 | } 1483 | 1484 | public void setKeyValueDoubleArrayMap(Map keyValueDoubleArrayMap) { 1485 | this.keyValueDoubleArrayMap = keyValueDoubleArrayMap; 1486 | } 1487 | 1488 | public Map, Map> getKeyListValueMapMap() { 1489 | return keyListValueMapMap; 1490 | } 1491 | 1492 | public void setKeyListValueMapMap(Map, Map> keyListValueMapMap) { 1493 | this.keyListValueMapMap = keyListValueMapMap; 1494 | } 1495 | 1496 | public Map[], Map[]> getKeyArrayListValueArrayMapMap() { 1497 | return keyArrayListValueArrayMapMap; 1498 | } 1499 | 1500 | public void setKeyArrayListValueArrayMapMap(Map[], Map[]> keyArrayListValueArrayMapMap) { 1501 | this.keyArrayListValueArrayMapMap = keyArrayListValueArrayMapMap; 1502 | } 1503 | } 1504 | --------------------------------------------------------------------------------