Spring远端调用的实现Spring Http调用的实现

1：Spring Http设计思想

最近在研究公司自己的一套rpc远程调用框架，看到其内部实现的设计思想依赖于spring的远端调用的思想，所以闲来无事，就想学习下，并记录下。

作为spring远端调用的实现，最为简单的应该是通过http调用的实现，在这种依赖中不会依赖第三方等相关组件，调用者只需要配置相关http的协议

就可以实现，简单的配置，就可以使用spring的 IOC  容器的bean的定义等等思想去调用，简单，方便，无需写更多的http相关的代码，

比较适合内部通信系统之间的调用。

在日常开发中，经常会遇到各种内部系统之间的通讯调用，其实可以使用如下几种设计方式。不过，最简单的应该是spring自带的http模式，然后自己封装

打包成客户端jar等等，共客户端调用

其实在日常调用实现中，可以通过若干种设计 都可以完成客户端与服务端之间的调用，如

阿里的db中间件就是使用的是类似的通讯模式，不过没有研究过

公司内部使用的是如下的方式进行通讯，可以通过监控软件来进行对Q的跟踪，在处理大数据高并发的时候，良好的Q中间件及Java中封装异步处理，解决了数据库以及各方面的瓶颈压力，不过，也有缺点，各个应用之间的事务是无法控制，只能通过事后补偿处理。综合来看，还是很好的设计

先来说说springHttp协议吧.

2:客户端

在客户端中设计了HttpInvokerProxyFactoryBean ,这是一个代理工厂bean(ProxyFactoryBean),它会使用spring aop来对http调用器的客户端进行封装，既然使用了aop，就会使用到代理对象，并为代理方法设置相应的拦截器。HttpInvokerProxyFactoryBean 中，通过afterPropertiesSet来启动远端调用基础设施的建立等,代理拦截器HttpInvokerClientInterceptor,HttpInvokerClientInterceptor中会封装客户端的基本实现，如http请求链接，请求对象序列化，请求传送到服务端，在收到拦截器的时候，同样也会将服务器端发送过来http响应反序列化，并且把远端调用的服务器端返回的对象交给应用使用，完成一个http请求的基本实现。

Http调用器是基于http协议提供的远端调用方案，使用http调用器和使用Java rmi一样的基础配置模块

HttpInvokerProxyFactoryBean 具体实现如下图 继承了FactoryBean,使用HttpInvokerProxyFactoryBean 需要设置相应的bean对代理工厂的配置
设置远程服务的url地址，设置远端服务的的接口,然后把这个代理工厂设置到客户端应用的bean的remoteService属性中，有了这个设置，客户端应用配置就已经配置好了,就可以像调用本地一样，享用远端服务了

<bean id="proxy" class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
   <property name="serviceUrl">http://localhost:8080/xxxx/xxx</property><!--请求的服务端url-->
   <property name="serviceInterface">com.abc.cc.ddd.ee</property><!--具体的服务端调用接口路径-->
</bean>
<bean id="test" class="abc.sss.ssss">
   <property name="remoteService" ref="proxy"/> <!--引入到代理工厂中-->
</bean>

HttpInvokerProxyFactoryBean中封装对应的远端服务信息，域名，端口，服务所在URL，这些都是远端服务调用所需要的信息，同时，由于使用httpInvoker，所以在URL指定的协议中是http协议，对访问远端服务调用的客户端而言，只要持有HttpInvokerProxyFactoryBean提供的代理对象，就可以方便的使用远端调用，使用起来如本地一样，远端调用发送的数据通信及远端服务交互，都被proxy代理类进行了封装，对客户端是透明的，这些封装主要都是在HttpInvokerProxyFactoryBean进行封装处理的 。

从图可以知道，当服务启动，系统在spring容器里面自动初始化该代理对象，自动执行afterPropertiesSet相关方法
HttpInvokerProxyFactoryBean 是如何封装并将数据传输到服务端的？

public class HttpInvokerProxyFactoryBean extends HttpInvokerClientInterceptor implements FactoryBean<Object> {

    private Object serviceProxy;

    //代码省去若干  代码省去若干  代码省去若干  代码省去若干  
    @Override
    public void afterPropertiesSet() {
        //初始化执行 http配置加载等，为后续发送到服务端做准备工作
        super.afterPropertiesSet();
        //获取在客户端配置的接口，判断接口是否配置，此处的父类进行了类的加载配置等，
        //在此处，不是一个配置，而是一个具体的接口类
        if (getServiceInterface() == null) {
            throw new IllegalArgumentException("Property 'serviceInterface' is required");
        }
        //将相关参数，相应的类加载的信息，以及指定具体的客户端实现类代理
        this.serviceProxy = new ProxyFactory(getServiceInterface(), this).getProxy(getBeanClassLoader());
    }


    public Object getObject() {
        return this.serviceProxy;
    }

    public Class<?> getObjectType() {
        return getServiceInterface();
    }

    public boolean isSingleton() {
        return true;
    }
}

ProxyFactory所指定的HttpInvokerClientInterceptor 拦截器中执行的invoke方法

//具体调用执行的方法
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        if (AopUtils.isToStringMethod(methodInvocation.getMethod())) {
            return "HTTP invoker proxy for service URL [" + getServiceUrl() + "]";
        }
        //创建远端服务所需要的参数信息等 ，格式是spring自己实现的 ，创建工厂等
        RemoteInvocation invocation = createRemoteInvocation(methodInvocation);
        RemoteInvocationResult result;
        try {
            //调用服务端，发送请求
            result = executeRequest(invocation, methodInvocation);
        }
        catch (Throwable ex) {
            throw convertHttpInvokerAccessException(ex);
        }
        try {
            //将服务端的返回信息所需要的对象等
            return recreateRemoteInvocationResult(result);
        }
        catch (Throwable ex) {
            if (result.hasInvocationTargetException()) {
                throw ex;
            }
            else {
                throw new RemoteInvocationFailureException("Invocation of method [" + methodInvocation.getMethod() +
                        "] failed in HTTP invoker remote service at [" + getServiceUrl() + "]", ex);
            }
        }
}

上述代码中主要操作：封装发送的接口等
RemoteInvocationFactory  >> createRemoteInvocation(MethodInvocation methodInvocation);
RemoteInvocation    >>（RemoteInvocation(String methodName, Class[] parameterTypes, Object[] arguments)）
DefaultRemoteInvocationFactory   >> createRemoteInvocation(MethodInvocation methodInvocation)

    /**
     * Create a new RemoteInvocation for the given AOP method invocation.
     * @param methodInvocation the AOP invocation to convert
     */

     RemoteInvocation    >>（RemoteInvocation(String methodName, Class[] parameterTypes, Object[] arguments)） 具体实现

   public RemoteInvocation(MethodInvocation methodInvocation) {
        this.methodName = methodInvocation.getMethod().getName();
        this.parameterTypes = methodInvocation.getMethod().getParameterTypes();
        this.arguments = methodInvocation.getArguments();
   }
   执行发送
   HttpInvokerRequestExecutor -->>  AbstractHttpInvokerRequestExecutor类 具体实现
   public final RemoteInvocationResult executeRequest(
            HttpInvokerClientConfiguration config, RemoteInvocation invocation) throws Exception {

        ByteArrayOutputStream baos = getByteArrayOutputStream(invocation);
        if (logger.isDebugEnabled()) {
            logger.debug("Sending HTTP invoker request for service at [" + config.getServiceUrl() +
                    "], with size " + baos.size());
        }
        return doExecuteRequest(config, baos);
    }

具体流程图如下:
客户端请求配置发送请求

3:服务端

在服务端中设计了HttpInvokerServiceExporter，通过ServiceExporter来导出远端的服务对象，由于需要处理http请求，所以其需要依赖springMVC模块来实现，会封装mvc框架的dispatchServlet，并设置相应的控制器。这个控制器执行相应的http请求处理，比如接收服务请求，将服务请求对象反序列化，交给服务端对象完成请求，最后把生成的结果通过序列化通过http协议返回到客户端。

服务端配置：

<bean id="helloService" class="com.logcd.server.service.impl.HelloService"/>  
      
 <bean name="/xxxService" class="org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter" lazy-init="false">  
        <property name="service">  
            <ref bean="xxxService"/>  
        </property>  
        <property name="serviceInterface">  
            <value>com.abc.cc.ddd.ee</value>  
        </property>  
  </bean>

spring http的服务端接收是如何响应的？主要是使用HttpInvokerServiceExporter

public void handleRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException { 

        try {
            //封装请求对象，将其转换成远程调用对象
            RemoteInvocation invocation = readRemoteInvocation(request);
            //执行请求并创建返回对象
            RemoteInvocationResult result = invokeAndCreateResult(invocation, getProxy());
            //返回到客户端
            writeRemoteInvocationResult(request, response, result);
        }
        catch (ClassNotFoundException ex) {
            throw new NestedServletException("Class not found during deserialization", ex);
        }
    }

执行代码的逻辑 并返回，此处代码如下

RemoteInvocation 

 public Object invoke(Object targetObject)
            throws NoSuchMethodException, IllegalAccessException, InvocationTargetException { 

        Method method = targetObject.getClass().getMethod(this.methodName, this.parameterTypes);
        return method.invoke(targetObject, this.arguments);
    }

写入返回到客户端

HttpInvokerServiceExporter
    protected void writeRemoteInvocationResult(
            HttpServletRequest request, HttpServletResponse response, RemoteInvocationResult result, OutputStream os)
            throws IOException { 

        ObjectOutputStream oos = createObjectOutputStream(decorateOutputStream(request, response, os));
        try {
            doWriteRemoteInvocationResult(result, oos);//调用父类RemoteInvocationSerializingExporter
        }
        finally {
            oos.close();
        }
    } 

RemoteInvocationSerializingExporter 

    protected void doWriteRemoteInvocationResult(RemoteInvocationResult result, ObjectOutputStream oos)
            throws IOException { 

        oos.writeObject(result);
    }

服务端具体的执行代码的流程图如下：

具体整个spring http远端调用就结束了，其实开发中，如果要封装类似的远端调用，可以仿照springhttp模式进行开发，将其中的http换成其他的协议，即可实现