<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>

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;
    }
}

//具体调用执行的方法
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);
            }
        }
}

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

   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);
    }

<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>

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);
    }