dubbo学习之事件通知实践

在调用之前、调用之后、出现异常时，会触发 oninvoke、onreturn、onthrow 三个事件，可以配置当事件发生时，通知哪个类的哪个方法.

/**
 * @author wx
 * @date 2020/9/8 1:44 下午
 * 测试事件通知
 */
public interface UserNotifyService {
    /**
     * 获取用户名字
     * @param userId
     * @return
     */
    String getUserName(String userId);
}

/**
 * @author wx
 * @date 2020/9/8 1:46 下午
 */
@Service
public class UserNotifyServiceImpl implements UserNotifyService {

    private static final String USER_ID  = "1503892";
    @Override
    public String getUserName(String userId) {
        if (StringUtils.isBlank(userId)) {
            throw new RpcException("userId is null");
        }
        return USER_ID.equals(userId) ? "溪～源" : "";
    }
}

/**
     * 事件通知
     * @throws IOException
     */
    private static void notifyTest() throws IOException {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/notify-provider.xml");
        context.start();
        System.in.read();
    }

1. oninvoke方法：
	必须具有与真实的被调用方法sayHello相同的入参列表：例如，oninvoke(String name)
2. onreturn方法：
	2.1 至少要有一个入参且第一个入参必须与getUserName的返回类型相同，接收返回结果：例如，onReturnWithoutParam(String result)；
	2.2 可以有多个参数，多个参数的情况下，第一个后边的所有参数都是用来接收getUserName入参的：例如， onreturn(String result, String name)
3. onthrow方法：
	3.1 至少要有一个入参且第一个入参类型为Throwable或其子类，接收返回结果；例如，onthrow(Throwable ex);
	3.2 可以有多个参数，多个参数的情况下，第一个后边的所有参数都是用来接收getUserName入参的：例如，onthrow(Throwable ex, String name);
4. 如果是consumer在调用provider的过程中，出现异常时不会走onthrow方法的，onthrow方法只会在provider返回的RpcResult中含有Exception对象时，才会执行。（dubbo中下层服务的Exception会被放在响应RpcResult的exception对象中传递给上层服务）

/**
 * @author wx
 * @date 2020/9/8 1:53 下午
 */
public interface ConsumerNotifyService {
    /**
     * 调用之前
     * @param name
     */
    void onInvoke(String name);

    /**
     * 无参数：调用之后
     * @param result 参数用于接收 [事件通知]服务接口的方法返回值类型保持一致
     */
    void onReturnWithoutParam(String result);

    /**
     * 有参数：调用之后
     * @param result 第一个参数 接收 [事件通知]服务接口的方法返回值类型保持一致
     * @param name 第二个或者之后，与[事件通知]服务接口的方法入参保持一致
     */
    void onReturn(String result, String name);

    /**
     * 抛异常
     * @param ex
     * @param name
     */
    void onThrow(Throwable ex, String name);
}

/**
 * @author wx
 * @date 2020/9/8 1:59 下午
 */
@Service
public class ConsumerNotifyServiceImpl implements ConsumerNotifyService{
    @Override
    public void onInvoke(String name) {
        System.out.println("[事件通知]执行onInvoke方法，参数：" + name);
    }

    @Override
    public void onReturnWithoutParam(String result) {
        System.out.println("[事件通知]执行onReturnWithoutParam方法，返回结果：" + result);
    }

    @Override
    public void onReturn(String result, String name) {
        System.out.println("[事件通知]执行onReturn方法，参数：" + name + ", 返回结果：" + result);
    }

    @Override
    public void onThrow(Throwable ex, String name) {
        System.out.println("[事件通知]执行onThrow方法，参数：" + name + ", 异常信息：" + ex.getMessage());
    }
}

 private static void notifyTest() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/notify-consumer.xml");
        UserNotifyService notifyService = context.getBean(UserNotifyService.class);
        String userName = notifyService.getUserName("1503892");
        System.out.println(userName);

    }

private void fireReturnCallback(final Invoker<?> invoker, final Invocation invocation, final Object result) {
        ....//省略部分代码
        Object[] params;
        //获取方法参数类型
        Class<?>[] rParaTypes = onReturnMethod.getParameterTypes();
        if (rParaTypes.length > 1) {
        //两个参数：第一个参数与真实方法getUserName方法返回结果类型相同，第二个接收所有的真实请求参数
            if (rParaTypes.length == 2 && rParaTypes[1].isAssignableFrom(Object[].class)) {
                params = new Object[2];
                // 真实方法的返回结果
                params[0] = result;
                //执行方法入参
                params[1] = args;
            } else {
            //多个参数：第一个参数与真实方法getUserName结果类型相同，后边几个接收所有的真实请求参数
                params = new Object[args.length + 1];
                params[0] = result;
                System.arraycopy(args, 0, params, 1, args.length);
            }
        } else {
        //只有一个参数：接收返回执行结果
            params = new Object[]{result};
        }
        try {
            onReturnMethod.invoke(onReturnInst, params);
        } catch (InvocationTargetException e) {
            fireThrowCallback(invoker, invocation, e.getTargetException());
        } catch (Throwable e) {
            fireThrowCallback(invoker, invocation, e);
        }
    }