揭秘系统远程调用思想

前言

在xxl-job中存在调度中心远程调用执行器的过程， 在此可以很清晰的学习到远程调用的思想。  

常规的远程调用协议，dubbo， thrift , Protocol Buffer， 以及更轻量级的hessian协议。 这些市面上大同小异的

框架，在我们集成这些框架的时候，我们总会在调用端引用服务端暴露出来的接口，然后通过代理工厂创建代理对象

最终通过spring的自动注入的方式，在我们的容器里面生成代理对象，然后当我们需要使用的时候，直接使用代理对象，

就可以调用到另一个系统里面的服务了， 常规的配置我们都知道，但是真正内部是怎么实现的，为何我们调用代理

对象的方法，就能调用到远程系统的服务，这是我们值得思考的。 此处主要以xxl-job为原型，讲解这种模式， 其他专业

的RPC框架肯定比这个更加复杂， 所以这里主要是讲解一个思想。 

 

 

例：当A系统需要调用B系统的方法时，我们通常的做法是这样的。

B系统 暴露一个interface， 如：   exampleInterface.jar 

A系统引用exampleInterface.jar ,   同时在spring.xml 文件中配置B系统暴露出来的接口类（例：userService）

最终我们的使用方式如下： 

Example

@Authwired   UserService userService ;    public User getUsers(){     return userService.getUsers() }

上面那一段，非常简短的代码， 还原了一个非常简短的系统之间的调用， 但是为什么在A系统调用userService.getUsers() , 

这个方法最终就能调用到B系统去呢？ 

 

代理对象生成

在xxl-job中调度中心需要调用执行器的代码， 下面来仔细分析一下、 

获取代理对象

public static ExecutorBiz getExecutorBiz(String address) throws Exception {     // valid     if (address==null || address.trim().length()==0) {         return null;     }       // load-cache     address = address.trim();     // 从内存中获取执行器对象     ExecutorBiz executorBiz = executorBizRepository.get(address);     if (executorBiz != null) {         return executorBiz;     }       // 通过代理类，创建代理对象，主要看这个创建过程     executorBiz = (ExecutorBiz) new NetComClientProxy(ExecutorBiz.class, address, accessToken).getObject();     // 放入内存中，以便下次调用     executorBizRepository.put(address, executorBiz);     return executorBiz; }

从下面的代码中，可以看到NetComClientProxy 这个代理类，是一个factoryBean， 所以主要看他的getObject方法即可

NetComClientProxy

public class NetComClientProxy implements FactoryBean<Object> {    private static final Logger logger = LoggerFactory.getLogger(NetComClientProxy.class);        private Class<?> iface;    private String serverAddress;    private String accessToken;    private JettyClient client = new JettyClient();    public NetComClientProxy(Class<?> iface, String serverAddress, String accessToken) {       this.iface = iface;       this.serverAddress = serverAddress;       this.accessToken = accessToken;    }      @Override    public Object getObject() throws Exception {       return Proxy.newProxyInstance(Thread.currentThread()             .getContextClassLoader(), new Class[] { iface },             new InvocationHandler() {                @Override                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                     // filter method like "Object.toString()"                     if (Object.class.getName().equals(method.getDeclaringClass().getName())) {                      logger.error(">>>>>>>>>>> xxl-rpc proxy class-method not support [{}.{}]", method.getDeclaringClass().getName(), method.getName());                      throw new RuntimeException("xxl-rpc proxy class-method not support");                   }                                          //生成这个代理对象的invoke方法里面，并没有调用目标类的方法，而是将目标的信息发送给远程服务器。                     RpcRequest request = new RpcRequest();                     request.setServerAddress(serverAddress); // 服务器地址                     request.setCreateMillisTime(System.currentTimeMillis()); // 创建时间， 用于判断请求是否超时                     request.setAccessToken(accessToken);  // 数据校验                     request.setClassName(method.getDeclaringClass().getName()); // 将目标类的class名称传给执行器，让那边来创建对象，并执行逻辑代码                     request.setMethodName(method.getName());   // 方法名称为run                     request.setParameterTypes(method.getParameterTypes());  // 参数类型                     request.setParameters(args); // 参数                     RpcResponse response = client.send(request); // 发送HTTP请求                                                 // valid response                   if (response == null) {                      logger.error(">>>>>>>>>>> xxl-rpc netty response not found.");                      throw new Exception(">>>>>>>>>>> xxl-rpc netty response not found.");                    }                        if (response.isError()) {                            throw new RuntimeException(response.getError());                        } else {                            return response.getResult();                        }                                        }             });    }    @Override    public Class<?> getObjectType() {       return iface;    }    @Override    public boolean isSingleton() {       return false;    }   }

从上面可以清晰的看到，生成的代理对象里面的 InvocationHandler 中的invoke方法，并没有真实的执行方法，而是将类名，方法名，参数等信息发送给远程服务器。 

仅仅只是做了这些操作而已。 这就是他的设计比较巧妙的地方。 

下面可以看一下，远程服务器拿到请求之后如何处理的。 

public static RpcResponse invokeService(RpcRequest request, Object serviceBean) {    // request中的数据结构    if (serviceBean==null) {       //  这个serviceBean 就是在执行器启动的时候，initExecutorServer （） 这个方法中，将一个ExecutorBiz的实例放进去了，此处通过       // classname来获取这个实例       serviceBean = serviceMap.get(request.getClassName());    }    if (serviceBean == null) {       // TODO    }       RpcResponse response = new RpcResponse();   // 判断是否超时    if (System.currentTimeMillis() - request.getCreateMillisTime() > 180000) {       response.setResult(new ReturnT<String>(ReturnT.FAIL_CODE, "The timestamp difference between admin and executor exceeds the limit."));       return response;    }     // 数据校验，验证token是否匹配，前提是token不为空    if (accessToken!=null && accessToken.trim().length()>0 && !accessToken.trim().equals(request.getAccessToken())) {       response.setResult(new ReturnT<String>(ReturnT.FAIL_CODE, "The access token[" + request.getAccessToken() + "] is wrong."));       return response;    }       try {       // 获取class       Class<?> serviceClass = serviceBean.getClass();       // 拿到请求中的方法名字， 此处这个值 是  run 方法       String methodName = request.getMethodName();         //方法类型       Class<?>[] parameterTypes = request.getParameterTypes();       // 方法参数       Object[] parameters = request.getParameters();       // spring的工具类， 创建一个fastClass 实例       FastClass serviceFastClass = FastClass.create(serviceClass);       FastMethod serviceFastMethod = serviceFastClass.getMethod(methodName, parameterTypes);        // 拿到方法之后执行方法的invoke ,       Object result = serviceFastMethod.invoke(serviceBean, parameters);          // 返回执行结果       response.setResult(result);    } catch (Throwable t) {       t.printStackTrace();       response.setError(t.getMessage());    }       return response; }

 

由此我们就可以知道，远程调用的大致思想。 

sharedCode源码交流群，欢迎喜欢阅读源码的朋友加群，添加下面的微信， 备注”加群“ 。