当前位置: 首页>前端>正文

rpc接口Mock测试 rpc mock

mock平台支持三种方式(URI、方法、RPC)

 

URI:当前端需要根据接口的各种状态来进行不同的展示时,而后端还没有写完完整的代码时,可以在项目开发初期通过该方式进行自定义设置接口返回结果。

 

方法:当后端需要某个方法返回某些特定的值时,而这时真实的情况又很难构造这个值时,就可以采用该方式。

 

RPC:当后端要与别的服务进行合作时,而别的服务方接口提供较慢或有问题时,可以采用该方式进行自测。

 

mock平台的数据存储可以是数据库或者其他平台等等,主要存储对应关系,key可以为URI或方法的全限定名和参数,value为具体的json结构,为了防止影响别人,用用户ID进行区分,如用户ID和key组成唯一键,这些数据是从控制台进行设置。

 

下面是具体代码过程:

模拟上下文配置,包括当前所处环境,spring容器,存储当前用户登陆状态的ThreadLocal,类方法参数拼接key的方法,获取mock平台数据的方法,平台数据存储采用数据库,以及自动生成指定类方法所代表的key的方法,方便使用者在控制台进行key-value添加。

@Configuration
public class MockContext implements ApplicationContextAware {

    private static final boolean online = !EnvUtils.isOffline();
    private static FastThreadLocal<LoginUser> fastThreadLocal = new FastThreadLocal<>();
    private static ApplicationContext instance;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        instance = applicationContext;
    }

    public static ApplicationContext getInstance() {
        return instance;
    }

    /**
     * 是否是线上环境
     */
    public static boolean online() {
        return online;
    }

    public static void set(LoginUser loginUser) {
        fastThreadLocal.set(loginUser);
    }

    public static LoginUser get() {
        return fastThreadLocal.get();
    }

    public static void remove() {
        fastThreadLocal.remove();
    }

    /**
     * 唯一url(类,方法,参数拼接)
     */
    public static String getUrl(String className, String methodName, Class<?>[] parameterTypes) {
        StringBuilder sb = new StringBuilder(className);
        sb.append(".").append(methodName);
        StringJoiner stringJoiner = new StringJoiner(",", "(", ")");
        if (parameterTypes != null) {
            for (Class<?> parameterType : parameterTypes) {
                if (parameterType != null) {
                    stringJoiner.add(parameterType.getName());
                }
            }
        }
        return sb.append(stringJoiner.toString()).toString();
    }

    /**
     * 数据库配置
     * 可以替换为http形式等等
     */
    public static MockDO getMockConfigDO(String url) {
        LoginUser loginUser = MockContext.get();
        if (loginUser == null) {
            return null;
        }
        return MockContext.getInstance().getBean(MockService.class).loadByUserIdUrl(loginUser.getUserId(), url);
    }

    public static Pair<String, MockDO> getMockConfigDO(String className, String methodName, Class<?>[] parameterTypes) {
        String url = getUrl(className, methodName, parameterTypes);
        return Pair.of(url, getMockConfigDO(url));
    }

    public static boolean notContent(MockDO mockDO) {
        return mockDO == null;
    }

    public static boolean notReturnType(Class<?> returnType) {
        return returnType == null || returnType == void.class || returnType == Void.class;
    }

    /**
     * 获取唯一key
     * 第一个参数为类的全限定名(必填),第二个参数为该类的方法名(选填)
     * 控制台方式:用英文逗号分割
     */
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String val;
        do {
            System.out.print("请输入:");
            val = input.next();
            print(val.split(","));
        } while (!"exit".equals(val));
        System.out.println("程序退出!");
        input.close();
    }

    public static void print(String[] args) {
        if (args == null || args.length < 1 || "exit".equals(args[0])) {
            return;
        }
        Class<?> c;
        try {
            c = Class.forName(args[0]);
        } catch (ClassNotFoundException ignore) {
            System.out.println("类不存在!" + ignore.fillInStackTrace());
            return;
        }
        Method[] methods = c.getMethods();
        String m = args.length > 1 ? args[1] : null;
        for (Method method : methods) {
            if (StringUtils.isBlank(m)) {
                System.out.println(getUrl(c.getName(), method.getName(), method.getParameterTypes()));
            } else if (method.getName().equals(m)) {
                System.out.println(getUrl(c.getName(), method.getName(), method.getParameterTypes()));
            }
        }
    }
}

针对URI形式的拦截器,判断环境,设置登陆状态,根据uri从mock平台中获取对应的配置,有配置就返回,没有的话就继续正常流程。

@Configuration
public class PH3636MockInterceptor extends HandlerInterceptorAdapter {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (MockContext.online()) {
            return true;
        }
        if (!(handler instanceof HandlerMethod)) {
            return false;
        }

        LoginUser loginUser = (LoginUser) request.getAttribute(Constants.LOGIN_USER);
        if (loginUser == null) {
            return true;
        }
        MockContext.set(loginUser);
        String uri = request.getRequestURI();
        MockDO mockDO = MockContext.getMockConfigDO(uri);
        if (MockContext.notContent(mockDO)) {
            return true;
        }
        response.setContentType("application/json;charset=UTF-8");
        response.setHeader("Cache-Control", "no-cache");
        PrintWriter pw = response.getWriter();
        try {
            pw.write(mockDO.getContent());
        } finally {
            pw.flush();
            pw.close();
        }
        return false;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
                                @Nullable Exception ex) throws Exception {
        if (MockContext.online()) {
            return;
        }
        MockContext.remove();
    }
}

针对方法形式的代理,判断环境,判断当前bean的方法中有没有mock注解,生成代理。

@Configuration
public class PH3636MockBeanPostProcessor implements BeanPostProcessor {

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (MockContext.online()) {
            return bean;
        }
        Mock mock = null;
        for (Method method : bean.getClass().getMethods()) {
            mock = method.getAnnotation(Mock.class);
            if (mock != null) {
                break;
            }
        }
        if (mock == null) {
            return bean;
        }
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setProxyTargetClass(true);
        proxyFactory.setExposeProxy(true);
        proxyFactory.setTarget(bean);
        proxyFactory.addAdvisor(new DefaultPointcutAdvisor(new PH3636MockMethodInterceptor()));
        return proxyFactory.getProxy();
    }
}

判断当前方法是否有mock注解,组装key,获取配置,转化json为对应的对象

public class PH3636MockMethodInterceptor implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Mock mock = invocation.getMethod().getAnnotation(Mock.class);
        if (mock == null) {
            return invocation.proceed();
        }
        Pair<String, MockDO> pair = MockContext.getMockConfigDO(invocation.getThis().getClass().getName(), invocation.getMethod().getName(), invocation.getMethod().getParameterTypes());
        if (MockContext.notContent(pair.getRight())) {
            return invocation.proceed();
        }
        Class<?> returnType = invocation.getMethod().getReturnType();
        if (MockContext.notReturnType(returnType)) {
            return invocation.proceed();
        }
        return JsonUtil.fromJsonToType(pair.getRight().getContent(), invocation.getMethod().getGenericReturnType());
    }
}

针对RPC(DUBBO)形式的Cluster扩展wrapper形式,在无提供者的情况下正常起作用,不需要额外修改,其他的一些形式都各有弊端,比如filter形式必须要有提供者,ProxyFactory代理需要额外配置,ClusterInterceptor要求版本较高等等。

public class PH3636MockClusterWrapper implements Cluster {

    private Cluster cluster;

    public PH3636MockClusterWrapper(Cluster cluster) {
        this.cluster = cluster;
    }

    @Override
    public <T> Invoker<T> join(Directory<T> directory) throws RpcException {
        return new PH3636MockClusterInvoker<T>(directory, this.cluster.join(directory));
    }
}

判断环境,组装key,获取配置,转化json为对应的对象

public class PH3636MockClusterInvoker<T> implements Invoker<T> {

    private final Directory<T> directory;

    private final Invoker<T> invoker;

    public PH3636MockClusterInvoker(Directory<T> directory, Invoker<T> invoker) {
        this.directory = directory;
        this.invoker = invoker;
    }

    @Override
    public URL getUrl() {
        return directory.getUrl();
    }

    @Override
    public boolean isAvailable() {
        return directory.isAvailable();
    }

    @Override
    public void destroy() {
        this.invoker.destroy();
    }

    @Override
    public Class<T> getInterface() {
        return directory.getInterface();
    }

    @Override
    public Result invoke(Invocation invocation) throws RpcException {
        if (MockContext.online()) {
            return invoker.invoke(invocation);
        }
        Pair<String, MockDO> pair = MockContext.getMockConfigDO(invoker.getInterface().getName(), invocation.getMethodName(), invocation.getParameterTypes());
        if (MockContext.notContent(pair.getRight())) {
            return invoker.invoke(invocation);
        }
        Method method;
        try {
            method = invoker.getInterface().getMethod(invocation.getMethodName(), invocation.getParameterTypes());
        } catch (NoSuchMethodException e) {
            return invoker.invoke(invocation);
        }
        if (method == null) {
            return invoker.invoke(invocation);
        }
        Class<?> returnType = method.getReturnType();
        if (MockContext.notReturnType(returnType)) {
            return invoker.invoke(invocation);
        }
        return new RpcResult((Object) JsonUtil.fromJsonToType(pair.getRight().getContent(), method.getGenericReturnType()));
    }
}

 


https://www.xamrdz.com/web/2s71960196.html

相关文章: