(十四) 测试类

由于某些原因, 鄙人所在的公司在sonar 上禁用了springBootTest, 他们说这是为了避免集成测试.怎么办, 当然是自己写一套了.

public class RerviceImplTest extends BaseUT2<RServiceImpl> {
    @Test
    public void testData(){
        Assertions.assertEquals(32, t.loadData());
    }
}

这里t就是装载好了所有bean的一个RServiceImpl 实例对象.
我们来看看是怎么去实现的

public class BaseUT2<T> {
    protected T t;

    public BaseUT2() {
        Type genericType = ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        try {
            Class<T> clazz = (Class<T>) Class.forName(genericType.getTypeName());
            t = clazz.newInstance();//实例化
            BaseProxyUtil.setBean(t);//加载需要的bean
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class BaseProxyUtil {
    private static Set<Class> classes = new HashSet<>();
    private static Set<Class> repositoryClasses = new HashSet<>();
    private static final Set<Class> mockAnnotations = Stream.of(Service.class, Component.class, MockBean.class).collect(Collectors.toSet());
    public static String PACKAGE_NAME = "配置扫描包路径";

    static {

        Set<Class> mockClasses = null;
        try {
            mockClasses = ComponentUtil.getAllClasses(PACKAGE_NAME);
        } catch (IOException e) {
            e.printStackTrace();
        }
        Set<Class> finalMockClasses = mockClasses;

        //add mock beans
        mockAnnotations.forEach(annotation -> {
            finalMockClasses.stream()
                    .filter(clazz -> clazz.getAnnotation(annotation) != null)
                    .forEach(classes::add);
        });

        //add auto generated repositories;
        finalMockClasses.stream()
                .filter(clazz -> clazz.getAnnotation(Repository.class) != null)
                .forEach(repositoryClasses::add);


    }

    private static Map<Type, List<Object>> getBeanMap() {
        Map<Type, List<Object>> resultMap = new HashMap<>();

        classes.forEach(clazz -> {
            try {
                ProxyFactory.getProxyInstance(clazz).forEach((k, v) -> {
                    List list = resultMap.getOrDefault(k, new ArrayList());
                    list.addAll(v);
                    resultMap.put(k, list);
                });
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            }
        });

        repositoryClasses.stream()
                .filter(Class::isInterface)
                .filter(clazz -> !resultMap.containsKey(clazz))
                .forEach(clazz -> {
                    Object instance = new JDKProxyFactory(clazz, new Object()).getProxyInstance();
                    resultMap.put(clazz, Stream.of(instance).collect(Collectors.toList()));
                });

        return resultMap;
    }

    public static void setBean(Object object) {
        Map<Type, List<Object>> beanMap = getBeanMap();
        ComponentUtil.getAllFields(object.getClass()).forEach(field -> {
            Type fieldType = field.getGenericType();
            if (fieldType.equals(List.class) || fieldType instanceof ParameterizedType && ((ParameterizedType) fieldType).getRawType().equals(List.class))
                fieldType = ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0];

            Set<Object> beans = new HashSet<>(beanMap.getOrDefault(fieldType, new ArrayList<>()));

            if (field.getType().equals(List.class))
                fillField(field, object, new ArrayList<>(beans));

            else if (1 == beans.size())
                fillField(field, object, beans.stream().findFirst().get());

            else
                beans.stream()
                        .filter(bean -> null != ProxyFactory.getProxyClass(bean).getAnnotation(MockBean.class))
                        .findFirst()
                        .ifPresent(bean -> fillField(field, object, bean));
        });
    }

    private static void fillField(Field field, Object obj, Object value) {
        field.setAccessible(true);
        try {
            field.set(obj, value);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

需要的覆盖别人的bean

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MockBean {
    Class value();
}

覆盖的例子

@MockGenericBean(LoadingCache.class)
@MockBean(LoadingCache.class)
public class MockLoadingCache implements LoadingCache<SnapshotEntity, String> {
    @Override
    public String get(SnapshotEntity snapshotEntity) throws ExecutionException {
        return null;
    }

    @Override
    public String getUnchecked(SnapshotEntity snapshotEntity) {
        return "test";
    }

    @Override
    public ImmutableMap<SnapshotEntity, String> getAll(Iterable<? extends SnapshotEntity> iterable) throws ExecutionException {
        return null;
    }

    @Override
    public String apply(SnapshotEntity snapshotEntity) {
        return null;
    }

    @Override
    public void refresh(SnapshotEntity snapshotEntity) {

    }

    @Nullable
    @Override
    public String getIfPresent(Object o) {
        return null;
    }

    @Override
    public String get(SnapshotEntity snapshotEntity, Callable<? extends String> callable) throws ExecutionException {
        return null;
    }

    @Override
    public ImmutableMap<SnapshotEntity, String> getAllPresent(Iterable<?> iterable) {
        return null;
    }

    @Override
    public void put(SnapshotEntity snapshotEntity, String s) {

    }

    @Override
    public void putAll(Map<? extends SnapshotEntity, ? extends String> map) {

    }

    @Override
    public void invalidate(Object o) {

    }

    @Override
    public void invalidateAll(Iterable<?> iterable) {

    }

    @Override
    public void invalidateAll() {

    }

    @Override
    public long size() {
        return 0;
    }

    @Override
    public CacheStats stats() {
        return null;
    }

    @Override
    public ConcurrentMap<SnapshotEntity, String> asMap() {
        return null;
    }

    @Override
    public void cleanUp() {

    }
}

注意getBeanMap()这个方法里面有个动态代理

public class ProxyFactory {

    public static Class getProxyClass(Object bean) {
        Object handler = Proxy.getInvocationHandler(bean);
        if (handler instanceof JDKProxyFactory) {
            return ((JDKProxyFactory) handler).getClazz();
        } else {
            return ((CglibProxyFactory) handler).getClazz();
        }
    }

    public static Map<Type, List> getProxyInstance(Class clazz) throws IllegalAccessException, InstantiationException {
        Map<Type, List> map = new HashMap<>();
        Set<Type> types = new HashSet<>();
        if (clazz.getGenericInterfaces() != null) {
            types.addAll(Arrays.asList(clazz.getGenericInterfaces()));
        }

        Class parent = clazz;
        while (parent != Object.class && parent != null) {
            if (parent.getGenericInterfaces() != null) {
                types.addAll(Arrays.asList(parent.getGenericInterfaces()));
            }
            parent = parent.getSuperclass();
        }
        if (types.size() > 0) {
            for (Type type : types) {
                if (type instanceof Class) {
                    List list = map.getOrDefault(type, new ArrayList());
                    list.add(new JDKProxyFactory((Class) type, clazz.newInstance()).getProxyInstance());
                    map.put(type, list);
                } else if (type instanceof ParameterizedType) {
                    Class proxyClass = (Class) ((ParameterizedType) type).getRawType();
                    List list = map.getOrDefault(type, new ArrayList());
                    list.add(new JDKProxyFactory(proxyClass, clazz.newInstance()).getProxyInstance());
                    map.put(type, list);
                }
            }
        }
        if (!clazz.isInterface()) {
            List list = map.getOrDefault(clazz, new ArrayList());
            list.add(new CglibProxyFactory(clazz.newInstance()).getProxyInstance());
            map.put(clazz, list);
        }
        return map;
    }
}

动态代理相关逻辑:
接口走cglib, 类走jdk

public class ProxyFactory {

    public static Class getProxyClass(Object bean) {
        Object handler = Proxy.getInvocationHandler(bean);
        if (handler instanceof JDKProxyFactory) {
            return ((JDKProxyFactory) handler).getClazz();
        } else {
            return ((CglibProxyFactory) handler).getClazz();
        }
    }

    public static Map<Type, List> getProxyInstance(Class clazz) throws IllegalAccessException, InstantiationException {
        Map<Type, List> map = new HashMap<>();
        Set<Type> types = new HashSet<>();
        if (clazz.getGenericInterfaces() != null) {
            types.addAll(Arrays.asList(clazz.getGenericInterfaces()));
        }

        Class parent = clazz;
        while (parent != Object.class && parent != null) {
            if (parent.getGenericInterfaces() != null) {
                types.addAll(Arrays.asList(parent.getGenericInterfaces()));
            }
            parent = parent.getSuperclass();
        }
        if (types.size() > 0) {
            for (Type type : types) {
                if (type instanceof Class) {
                    List list = map.getOrDefault(type, new ArrayList());
                    list.add(new JDKProxyFactory((Class) type, clazz.newInstance()).getProxyInstance());
                    map.put(type, list);
                } else if (type instanceof ParameterizedType) {
                    Class proxyClass = (Class) ((ParameterizedType) type).getRawType();
                    List list = map.getOrDefault(type, new ArrayList());
                    list.add(new JDKProxyFactory(proxyClass, clazz.newInstance()).getProxyInstance());
                    map.put(type, list);
                }
            }
        }
        if (!clazz.isInterface()) {
            List list = map.getOrDefault(clazz, new ArrayList());
            list.add(new CglibProxyFactory(clazz.newInstance()).getProxyInstance());
            map.put(clazz, list);
        }
        return map;
    }
}

public class CglibProxyFactory implements MethodInterceptor {

    private Object target;

    public CglibProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxyInstance() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();

    }

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        BaseProxyUtil.setBean(o);
        return methodProxy.invokeSuper(o, args);
    }

    public Class getClazz() {
        return target.getClass();
    }
}

public class JDKProxyFactory implements InvocationHandler {
    private Object target;
    private Class clazz;

    public JDKProxyFactory(Class clazz, Object target) {
        this.target = target;
        this.clazz = clazz;
    }

    public Object getProxyInstance() {
        return Proxy.newProxyInstance(getClass().getClassLoader(), new Class<?>[]{clazz}, this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (Object.class.equals(ProxyFactory.getProxyClass(proxy))) {
            AutoRepository autoRepository = new AutoRepository(clazz);
            if (void.class.equals(method.getReturnType())) {
                return null;
            } else if (autoRepository.isJpaRepository()) {
                Object object = getReturn(autoRepository.getEntityClass());
                if (List.class.equals(method.getReturnType())) {
                    List list = new ArrayList();
                    list.add(object);
                    return list;
                } else if (Optional.class.equals(method.getReturnType())) {
                    Method genericMethod = clazz.getMethod(method.getName(), method.getParameterTypes());
                    return Optional.of(getReturn(((Class) ComponentUtil.getGenericTypes(genericMethod.getReturnType())[0])));
                } else {
                    return getReturn(method.getReturnType());
                }
            } else {
                return getReturn(method.getReturnType());
            }
        } else {
            BaseProxyUtil.setBean(target);
            return method.invoke(target, args);
        }
    }

    private Object getReturn(Class clazz) {
        try {
            Method getMockMethod = MockObjectsTest.class.getMethod("getMock" + clazz.getSimpleName());
            return getMockMethod.invoke(null);
        } catch (NoSuchMethodException e) {} catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        if (ClassTypeInitValue.INIT_VALUE_MAP.containsKey(clazz)) {
            return ClassTypeInitValue.INIT_VALUE_MAP.get(clazz);
        } else if (clazz.isArray()) {
            return new Object[0];
        }
        return null;
    }

    public Class getClazz() {
        return target.getClass();
    }
}