mock生成java对象(支持集合嵌套)

最新推荐文章于 2024-08-23 09:46:15 发布
最新推荐文章于 2024-08-23 09:46:15 发布
阅读量1.6k 收藏 5
点赞数
分类专栏： java 代码生成
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhujianlin1990/article/details/102922085
版权 


import org.reflections.ReflectionUtils;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.*;

/**
 * 描述：mock对象
 *  注意：
 *   1、StackOverflow异常，一般是由于尝试mock自包含的类，比如菜单树
 *   2、暂时不支持Map中的key为Set或者List或者Map类型
 *
 * @author jianlin.zhu
 * @create 2019-11-05 11:25
 **/
public class MockUtil {

    private static final Boolean[] bools                 = new Boolean[] { true, false };

    private static final char[]    words                 = new char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
                                                                        'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
                                                                        's', 't', 'u', 'v', 'w', 'x', 'y', 'z' };

    private static final Random    r                     = new Random();

    private static final int       MAX_COLLECTION_LENGTH = 3;

    private static final int       MAX_STRING_LENGTH     = 15;

    @SuppressWarnings({ "unchecked", "rawtypes" })
    public static <T> T mock(Class<T> clazz) {
        if (clazz == Character.class || clazz == Character.TYPE) {
            return (T) (Character) words[r.nextInt(words.length)];
        } else if (clazz == Boolean.class || clazz == Boolean.TYPE) {
            return (T) (Boolean) bools[r.nextInt(bools.length)];
        } else if (clazz == Long.class || clazz == Long.TYPE) {
            return (T) (Long) r.nextLong();
        } else if (clazz == Integer.class || clazz == Integer.TYPE) {
            return (T) (Integer) r.nextInt();
        } else if (clazz == Short.class || clazz == Short.TYPE) {
            return (T) (Short) new Integer(r.nextInt(127)).shortValue();
        } else if (clazz == Float.class || clazz == Float.TYPE) {
            return (T) (Float) r.nextFloat();
        } else if (clazz == Double.class || clazz == Double.TYPE) {
            return (T) (Double) r.nextDouble();
        } else if (clazz == String.class) {
            return (T) randString(r.nextInt(MAX_STRING_LENGTH));
        }

        try {
            T instance = clazz.newInstance();

            for (Field f : ReflectionUtils.getAllFields(clazz)) {// getAllFields 返回本类和超类全部字段,getFields仅返回当前类成员
                f.setAccessible(true);
field长度

                if (f.getType() == Character.TYPE) {
                    f.setChar(instance, words[r.nextInt(words.length)]);
                } else if (f.getType() == Character.class) {
                    f.set(instance, words[r.nextInt(words.length)]);
                } else if (f.getType() == Boolean.TYPE) {
                    f.setBoolean(instance, bools[r.nextInt(bools.length)]);
                } else if (f.getType() == Boolean.class) {
                    f.set(instance, bools[r.nextInt(bools.length)]);
                } else if (f.getType() == Long.TYPE) {
                    f.setLong(instance, r.nextLong());
                } else if (f.getType() == Long.class) {
                    f.set(instance, r.nextLong());
                } else if (f.getType() == Integer.TYPE) {
                    f.setInt(instance, r.nextInt());
                } else if (f.getType() == Integer.class) {
                    f.set(instance, r.nextInt());
                } else if (f.getType() == Short.TYPE) {
                    f.setShort(instance, new Integer(r.nextInt(127)).shortValue());
                } else if (f.getType() == Short.class) {
                    f.set(instance, new Integer(r.nextInt(127)).shortValue());
                } else if (f.getType() == Float.TYPE) {
                    f.setFloat(instance, r.nextFloat());
                } else if (f.getType() == Float.class) {
                    f.set(instance, r.nextFloat());
                } else if (f.getType() == Double.TYPE) {
                    f.setDouble(instance, r.nextDouble());
                } else if (f.getType() == Double.class) {
                    f.set(instance, r.nextDouble());
                } else if (f.getType() == String.class) {
                    f.set(instance, randString(r.nextInt(MAX_STRING_LENGTH)));
                } else if (f.getType() == List.class) {
                    f.set(instance, generateList((ParameterizedType)f.getGenericType()));
                }else if (f.getType() == Set.class) {
                    f.set(instance, generateSet((ParameterizedType)f.getGenericType()));
                }  else if (f.getType() == Map.class) {
                    ParameterizedType pt = (ParameterizedType) f.getGenericType();
                    f.set(instance, generateMap(pt));
                } else if (f.getType() == Date.class) {
                    f.set(instance, new Date());
                }  else if (f.getType().isArray()) {// 处理数组
                    f.set(instance, generateArray( f.getType()));
                }else {
                    f.set(instance, mock(f.getType()));
                }
            }

            return instance;
        } catch (Exception e) {
            throw new IllegalArgumentException(e);
        }
    }


    private static Map<Object, Object> generateMap( ParameterizedType pt) {
        Map<Object, Object> map = new HashMap<>();
        int size = r.nextInt(MAX_COLLECTION_LENGTH)+1;
        for (int i = 0; i < size; i++) {
            Object key = null,value = null;

            //生成key,假设key不可能为List或者Map
            if(pt.getActualTypeArguments()[0] instanceof Class){
                key = mock((Class) pt.getActualTypeArguments()[0]);
            }else{
                throw new IllegalArgumentException("not supported key type:"+pt.getActualTypeArguments()[0].getTypeName());
            }

            // 生成value
            if(pt.getActualTypeArguments()[1] instanceof Class){
                value =  mock((Class) pt.getActualTypeArguments()[1]);
            }else if(pt.getActualTypeArguments()[1] instanceof ParameterizedType){
                ParameterizedType ptype = (ParameterizedType) pt.getActualTypeArguments()[1];
                if(ptype.getRawType() == List.class){
                    List<Object> list = generateList(ptype);
                    value = list;
                }else if(ptype.getRawType() == Map.class){
                    value = generateMap((ParameterizedType) ptype.getRawType());
                }else if(ptype.getRawType() == Set.class){
                    value = generateSet(ptype);
                }
            }else{
                throw new IllegalArgumentException("not supported value type:"+pt.getActualTypeArguments()[1].getTypeName());
            }

            // 给map赋值
            map.put(key, value);
        }
        return map;

    }

    private static Object[] generateArray(Class f) {
        int sizeInner = r.nextInt(MAX_COLLECTION_LENGTH)+1;

        Object[] objects = (Object[]) Array.newInstance(f.getComponentType(),sizeInner);
        for (int i=0;i<objects.length;++i) {
             objects[i] = mock(f.getComponentType());
        }
        return objects;
    }

    private static List<Object> generateList(ParameterizedType f) {
        int sizeInner = r.nextInt(MAX_COLLECTION_LENGTH)+1;
        List<Object> list = new ArrayList<Object>(sizeInner);
        ParameterizedType ptInner = f;
        for (int ii = 0; ii < sizeInner; ii++) {
            if (ptInner.getActualTypeArguments()[0] instanceof Class) {
                list.add(mock((Class) ptInner.getActualTypeArguments()[0]));
            } else if (ptInner.getActualTypeArguments()[0] instanceof ParameterizedType) {
                ParameterizedType ptype = (ParameterizedType) ptInner.getActualTypeArguments()[0];
                if(ptype.getRawType() == List.class){
                    List<Object> obj = generateList(ptype);
                    list.add(obj);
                }else if(ptype.getRawType() == Map.class){
                    list.add(generateMap(ptype));
                }else if(ptype.getRawType() == Set.class){
                    list.add(generateSet(ptype));
                }else {
                    throw new IllegalArgumentException("not supported type:"+ptype.getTypeName());
                }
            }
        }
        return list;
    }

    private static Set<Object> generateSet(ParameterizedType f) {
        int sizeInner = r.nextInt(MAX_COLLECTION_LENGTH)+1;
        Set<Object> set = new HashSet<>(sizeInner);
        ParameterizedType ptInner = f;
        for (int ii = 0; ii < sizeInner; ii++) {
            if (ptInner.getActualTypeArguments()[0] instanceof Class) {
                set.add(mock((Class) ptInner.getActualTypeArguments()[0]));
            } else if (ptInner.getActualTypeArguments()[0] instanceof ParameterizedType) {
                ParameterizedType ptype = (ParameterizedType) ptInner.getActualTypeArguments()[0];
                if(ptype.getRawType() == List.class){
                    set.add( generateList(ptype));
                }else if(ptype.getRawType() == Map.class){
                    set.add(generateMap(ptype));
                }else if(ptype.getRawType() == Set.class){
                    set.add(generateSet(ptype));
                }else {
                    throw new IllegalArgumentException("not supported type:"+ptype.getTypeName());
                }
            }
        }
        return set;
    }


    private static String randString(int count) {
        if (count == 0) {
            count = 1;
        }

        int length = words.length;
        char[] text = new char[count];
        for (int i = 0; i < count; i++) {
            text[i] = words[r.nextInt(length)];
        }

        return new String(text);
    }

}

测试case

import lombok.Data;

import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 描述：
 *
 * @author jianlin.zhu
 * @create 2019-11-05 16:33
 **/
@Data
public class Person {
    private Long id;
    private String name;
    private Date birth;
    private List<Set<Address>> addressList;
    private Favor[] favors;
    private List<Order> orderList;
    private Set<Map<String,List<Set<Favor>>>> favorSet;


    @Data
    public static class Favor{
        private String title;
        private String describe;
        private double score;
    }

    @Data
    public static class Address{
        private String country;
        private String province;
        private String city;
        private String street;
        private String contract;
        private String phone;
        private Boolean isDefault;
    }

    @Data
    public static class Order{
        private Double totalPrice;
        private Address address;
        private Map<Long,List<Favor>> goodsFavor;
        private List<SubOrder> subOrders;
    }

    @Data
    public static class SubOrder{
        private Long   goodId;
        private Double salePrice;
        private Double originalPrice;
        private float benefit;
        private String   title;
    }

}

import com.alibaba.fastjson.JSONObject;

/**
 * 描述：
 *
 * @author jianlin.zhu
 * @create 2019-11-05 15:34
 **/
public class MockUtilTest {

    public static void  main(String[] args){


        Person person  = MockUtil.mock(Person.class);
        System.out.println(JSONObject.toJSONString(person,true));
    }
}

输出：

{
	"addressList":[
		[{
			"city":"tpy",
			"contract":"dpmkqimffy",
			"country":"ubt",
			"isDefault":true,
			"phone":"yiykfamdydmsqb",
			"province":"yjh",
			"street":"lhbypp"
		},{
			"city":"kifyy",
			"contract":"vofaxshgqvyqan",
			"country":"bquuqw",
			"isDefault":false,
			"phone":"aawrrcwetiyfma",
			"province":"ewnvbahrh",
			"street":"saxkvomlzd"
		},{
			"city":"b",
			"contract":"utzj",
			"country":"tp",
			"isDefault":false,
			"phone":"wljlhuq",
			"province":"gqa",
			"street":"e"
		}],
		[{
			"city":"vtlyiururjzz",
			"contract":"j",
			"country":"jvqoq",
			"isDefault":false,
			"phone":"anhtftdmenvbzr",
			"province":"t",
			"street":"fjsie"
		}],
		[{
			"city":"nyjgbsd",
			"contract":"u",
			"country":"hbte",
			"isDefault":true,
			"phone":"qki",
			"province":"jzyxiulfcxhen",
			"street":"tzgieshs"
		}]
	],
	"birth":1572952177324,
	"favorSet":[{
		"mdkzowbaiqakn":[
			[{
				"describe":"e",
				"score":0.33512498126200196,
				"title":"znmqsbv"
			},{
				"describe":"exrqliayt",
				"score":0.12957477455951116,
				"title":"v"
			}],
			[{
				"describe":"vmqvruep",
				"score":0.683872055817606,
				"title":"fidlau"
			},{
				"describe":"teztqfps",
				"score":0.8187798858446599,
				"title":"k"
			},{
				"describe":"jhhhnbxcxr",
				"score":0.3977010007177091,
				"title":"pubvbtkouch"
			}],
			[{
				"describe":"zrhoe",
				"score":0.3080511445840518,
				"title":"lh"
			},{
				"describe":"y",
				"score":0.4601439044338964,
				"title":"vonwufve"
			}]
		],
		"bdhym":[
			[{
				"describe":"ajf",
				"score":0.09017641017885825,
				"title":"q"
			},{
				"describe":"gcfpryvijftwnh",
				"score":0.3630178607696227,
				"title":"q"
			},{
				"describe":"i",
				"score":0.2649214029318562,
				"title":"dqhfigmcy"
			}],
			[{
				"describe":"pf",
				"score":0.08199816360236223,
				"title":"idwfkuykl"
			},{
				"describe":"mkibroz",
				"score":0.30136369114027095,
				"title":"ynfghdzudtyf"
			}]
		]
	},{
		"r":[
			[{
				"describe":"fhlwiznpi",
				"score":0.36563747375982836,
				"title":"cfevfjl"
			},{
				"describe":"tzkbvttinhgte",
				"score":0.3904462585509223,
				"title":"ig"
			}],
			[{
				"describe":"bgdlcvlimf",
				"score":0.7455985339369536,
				"title":"pewbslviq"
			},{
				"describe":"mrlwcxnx",
				"score":0.12461240816408914,
				"title":"wmyamocfhlrd"
			},{
				"describe":"mhocivyk",
				"score":0.8834363617313298,
				"title":"cnyslmne"
			}]
		],
		"us":[
			[{
				"describe":"wxvryqej",
				"score":0.2748961395007401,
				"title":"u"
			},{
				"describe":"cbzbcogiylecvt",
				"score":0.4711109057074666,
				"title":"jwecatawnhde"
			}]
		]
	},{
		"qffrbrnr":[
			[{
				"describe":"ybcopufhpep",
				"score":0.43450414896786926,
				"title":"xzl"
			}]
		],
		"ahlgptw":[
			[{
				"describe":"zlqc",
				"score":0.17386372799530847,
				"title":"k"
			},{
				"describe":"jv",
				"score":0.9977639709707106,
				"title":"hqficilftsbf"
			},{
				"describe":"ehhlkpirtapys",
				"score":0.9750584197570653,
				"title":"rottraq"
			}],
			[{
				"describe":"wak",
				"score":0.4156394594053854,
				"title":"lozvmtztpezru"
			},{
				"describe":"bvquwxuomayzc",
				"score":0.2989801382638073,
				"title":"k"
			}]
		],
		"ojnhettqcr":[
			[{
				"describe":"uubwgkzuug",
				"score":0.47959497074873303,
				"title":"cxdgcqq"
			}]
		]
	}],
	"favors":[{
		"describe":"kbdea",
		"score":0.27751810255617315,
		"title":"wmqhyxquev"
	},{
		"describe":"btilnrkqwqsyz",
		"score":0.1762719693155328,
		"title":"x"
	},{
		"describe":"h",
		"score":0.7253306812757867,
		"title":"bidbtih"
	}],
	"id":-8110089797562012842,
	"name":"drioyjnq",
	"orderList":[
		{
			"address":{
				"city":"mepkyfwsi",
				"contract":"d",
				"country":"ycaotih",
				"isDefault":true,
				"phone":"fft",
				"province":"b",
				"street":"gxavrmsrsms"
			},
			"goodsFavor":{1169207484603786370:[
					{
						"describe":"ou",
						"score":0.8277121621050381,
						"title":"ttcitrr"
					},
					{
						"describe":"ovzs",
						"score":0.03187424071317824,
						"title":"jflhyky"
					}
				],8152713560997322139:[
					{
						"describe":"inuvfodmyb",
						"score":0.4988076295011178,
						"title":"xqiwxwlzqzuhc"
					},
					{
						"describe":"xnhgxhy",
						"score":0.11535246421995216,
						"title":"jbjpfvxpeuyrbw"
					}
				]
			},
			"subOrders":[
				{
					"benefit":0.6409404,
					"goodId":-2489116054044592929,
					"originalPrice":0.7165577881107803,
					"salePrice":0.7082018344414069,
					"title":"osyokfadesgp"
				}
			],
			"totalPrice":0.6517598699982142
		}
	]
}

参考资料：

https://blog.csdn.net/xupeng874395012/article/details/61205434

https://blog.csdn.net/hexingen/article/details/79355672

沸腾的可乐
关注
专栏目录
java单元测试之Mock测试编写
ai_goodStudent的博客
12-06 1692
mock框架官方文档地址:https://javadoc.io/static/org.mockito/mockito-core/3.2.0/org/mockito/Mockito.html#verification 1. Mock一个对象 //Let's import Mockito statically so that the code looks clearer import sta...
Java测试框架系列：Mockito 详解：第一部分：对象创建
阿星君
06-25 4202
Mockito 详解：第一部分：对象创建 零：前提条件 先明确一个词：存根(或者说是打桩），指的是对某个方法指定返回策略的操作（具体表现为两种：1指定返回值，2使用doCallRealMethod()或者thenCallRealMethod()指定当方法被调用时执行实际代码逻辑），功能就是当测试执行到此方法时直接返回我们指定的返回值（此时不会执行此方法的实际代码逻辑）或者执行此方法的实际代码逻辑并返回。比如: 我们先定义一个对象： public class Mock { public S
使用Mockito创建mock对象
qq_21434809的博客
02-07 645
使用Mockito创建mock对象。搭建Mockito测试环境。使用静态方法 mock()使用注解 @Mock 标注。
mock测试类方法内部一new的对象如何操作
最新发布
newbrid007的博客
08-23 661
注解，其中xxx.class 为你要测试的类。比如你你写了一个 入下 然后你要测试XXX.A的方法 所以 你要在注解把xxx.class 加上。1 在mock 类上 增加。
[笔记]-mockito对于多层泛型嵌套对象的mock方案
31415926535x的博客
09-21 1430
多层泛型类的mock
Springboot框架开发微服务Mock平台之集合框架
我先测了
04-29 2201
背景：采用springboot相关技术，开发mock平台以备联调使用。基本类就是几个请求/响应参数及返回结果；mock就是模拟接口测试，有问题的就是根据不同的场景获取不同的响应参数满足开发或测试工作。下面先看几行代码: @RequestMapping(value = "/Order.loanCalculate", method = RequestMethod.GET) public Res...
powerMock的测试样例集合
07-27
学习powermock实战手册，自己写的若干例子，mock static、final ，mock 局部变量、成员变量、Answer接口、ArgumentMatcher
javabiginteger源码-mock:java版的可以模拟生成任意数据的框架
06-04
支持丰富多样的数据类型模拟，包括：Java基本类型、字符串、枚举、日期、数组、多维数组、集合[List|Set|Map]、枚举、Java对象等 支持泛型 支持继承 支持循环依赖、自依赖(手动开启enabledCircle) 支持忽略字段 支持...
Java测试框架系列：Mockito使用手册
阿星君
06-28 3313
Mockito 使用手册（需要源码的加我QQ3177181324） 零：概述 一：创建mock/spy对象 0：概述 Mockito可以帮助我们方便的创建被测对象、mock对象和spy对象。 创建被测对象： 先解释一下被测对象：就是单元测试中我们想要测试的那个类。如xxxService、xxxUtils等等。 使用@InjectMocks注解创建： 配合@RunWith(MockitoJUnitRunner.class)使用或在@Before方法中使用MockitoAnnotations
自动生成测试类，并填充测试数据（一）
chenahong0201的博客
05-31 803
自动生成测试类，并填充测试数据（一）一 说明二 设计思路三 上代码1 工具类 GenStrUtil2 生成类 GenServiceTest四 结语五 感谢关注 一 说明 在日常开发过程中，需要对功能做单元测试，还需要制造测试数据。在测试的过程中，造数是比较蛋疼的事情，并且需要编写大量的set方法。所以就有感制作一个自动生成测试用例的代码。 二 设计思路 内容其实很简单，就是通过固定的字符串拼接 + 反射机制来实现功能。其中有几个需要注意的地方是，判断基本数据类型，List，Map，存在泛型的类，这些是否有.
Java-基础选择题
qq_48019875的博客
11-16 5250
标题Java(八）Java（九）Java(十） Java(八） 以下关于构造函数的描述错误的是 （ ） A.每个类有且只能有一个构造函数。 B.构造函数是类的一种特殊函数，它的方法名必须与类名相同 C.构造函数的主要作用是完成对类的对象的初始化工作 D.一般在创建新对象时，系统会自动调用构造函数 答案： A 解析： 类除了无参构造方法，还有有参构造方法，有参构造方法还可以通过重载写出多参的构造方法（2参，3参，4参） 方法重载：同一个类中方法名称相同，而参数的类型或个数不同 2.在面向对象编程里，经
java反射工具类 ReflectionUtils
08-02
该工具类下载后拷贝到你要用的包，只需该包名即可
反射工具类ReflectionUtils.java
01-19
进行数据库查询操作经常用到，包括getDeclaredField、getDeclaredMethod、getFieldValue、getSuperClassGenricType、getSuperGenericType、invokeMethod、makeAccessible、setFieldValue
关于list对象的mockito
dianbokong3184的博客
03-02 1397
由于项目中用到了 list.contains() ，所以写单元测试时，用到了 List<String> typeAll = Mockito.mock(List.class); 然后一直尝试怎么add值，结果一直没写出来，然后请教后结果发现应该如下写： private List<String> getTypeAll2(){ List<Stri...
@Mock与@InjectMocks的区别,mock对象注入另一个mock
Mia的博客
04-12 2万+
@Mock: 创建一个Mock. @InjectMocks: 创建一个实例，简单的说是这个Mock可以调用真实代码的方法，其余用@Mock（或@Spy）注解创建的mock将被注入到用该实例中。 请注意：必须使用@RunWith(MockitoJUnitRunner.class)或Mockito.initMocks(this)初始化这些模拟并注入它们。 //@RunWith(PowerMockRun...
Mockito核心源码分析总结
Blossom
02-28 1531
Mockito核心源码分析总结 Mockito使用示例 在开始看mockito的源码之前，首先看一下下面两个mockito的使用示例。 简单使用示例 @Test public void mockitoTest(){ // 1.生成一个mock对象 List<String> mockedList = Mockito.mock(List.class); // 查看mock对象的类名: $java.util.List$$Enha
mock
Xiaowo
10-25 2441
mock的由来一开始，没有mock的时候，人们测试的时候只能自己mock。比如需要一个PersonDao类的对象，其中有连接数据库查询数据库当前存储人数的方法getPersonNum()。但是可能因为数据库不存在等问题，其中的操作并不能正确执行，这时候一般：public PerSonDaoMock extends PersonDao{ @Override public int get
使用MOCK对象进行单元测试
零零零
08-08 1198
 使用MOCK对象进行单元测试  1.出了什么问题？      单元测试的目标是一次只验证一个方法，小步的前进，细粒度的测试，但是假如某个方法依赖于其他一些难以操控的东东，比如说网络连接，数据库连接，或者是Servlet容器，那么我们该怎么办呢？      要是你的测试依赖于系统的其他部分，甚至是系统的多个其他部分呢？在这种情况下，倘若不小心，你最终可能会发现自己几乎初始化了系
Spring 反射工具类ReflectionUtils
热门推荐
柳清风的专栏
11-26 2万+
public static final int PUBLIC = 0x00000001; public static final int PRIVATE = 0x00000002; public static final int PROTECTED = 0x00000004; public sta
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值