Spring HTTP invoker

具体使用请参考，这里主要看一下源码如何实现，以及和其他rpc框架的区别。

源码：

服务端配置：在spring-web包的org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter，该类继承了RemoteExporter，它内部两个属性service和serviceInterface，分别是远程服务接口和该服务的实现类，它主要提供HTTP协议封装和java对象序列化功能。

Spring的HttpInvokerServiceExporter(继承了HttpRequestHandler接口，可被适配器适配为HTTP请求处理器)是与Spring的MVC结合在一起的，它本质上是Spring MVC的一个Controller（所以要另外定义一个SimpleUrlHandlerMapping进行url映射），客户端发来的远程调用HTTP请求有Spring MVC的中央控制器DispatcherServlet转发到指定URL的HttpInvokerServiceExporter上。

<beans>
	<bean id="userService" class="com.service.impl.UserServiceImpl" />
	<!-- 基于Url映射方式,这个配置，就是把userService接口，提供给远程调用 -->
	<bean id="httpService"  class="org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter">
            <property name="service" ref="userService"/>
            <property name="serviceInterface" value="com.service.UserService"/>
        </bean>
    <bean
        class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
         <property name="mappings">
            <props>
                  <prop key="/test">httpService</prop>
            </props>
        </property>
    </bean>

客户端配置：在通过从工厂的getbean("httpTestService")方式，通过接口调用。

	<bean id="httpTestService"
	class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
		<property name="serviceUrl">
			<value>http://localhost:8080/SpringHttp_Server/test</value>
		</property>
		<!-- 在客户端定义，或者抽出来当做公用定义接口 -->
		<property name="serviceInterface">
			<value>com.service.UserService</value>
		</property>
	</bean>

  

 

 

1、在调用时，会通过HttpInvokerProxyFactoryBean作为一个ioc容器，对远程客户端封装。当通过getObject方法向Spring IoC容器索取远程调用对象时，触发afterPropertiesSet回调方法，创建远程调用的代理对象，最后将该远程调用代理对象返回。在创建远程调用代理对象时，使用其父类HttpInvokerClientInterceptor作为远程调用代理对象的拦截器，该拦截器将拦截对代理对象的方法调用。下面我们分析HttpInvokerClientInterceptor代理拦截器对代理对象的方法拦截处理。

2、当客户端通过HTTP请求调用远程调用代理的方法时，将会触发HttpInvokerClientInterceptor拦截器的invoke方法对当前的请求进行封装处理，将客户端的java对象序列化传输到服务器端，在远程服务器端执行完请求之后，又将处理结果java对象序列化返回给客户端。

3、拦截器将客户端对远程调用的HTTP请求封装成了MethodInvocation对象，拦截器的在调用远程调用的代理对象时，又将方法调用封装成了RemoteInvocation远程调用，RemoteInvocation数据对象中封装了调用的具体信息，如方法名、方法参数以及参数类型等。

真正执行远程调用的是HTTP调用请求执行器SimpleHttpInvokerRequestExecutor，下面我们继续分析SimpleHttpInvokerRequestExecutor远程调用的具体过程。

4、SimpleHttpInvokerRequestExecutor封装了基于HTTP协议的远程调用过程，HTTP调用请求执行器的处理逻辑是：首先，打开指定URL的HTTP连接，设置连接属性。其次，将封装请求的RemoteInvocation对象序列化到请求体中，请HTTP请求发送到服务器端。最后，从服务器端的HTTP响应中读取输入流，并将响应结果转换成RemoteInvocationResult。

将远程调用的HTTP响应转换为RemoteInvocationResult是由AbstractHttpInvokerRequestExecutor的readRemoteInvocationResult方法实现，下面我们将分析其将HTTP响应结果转换成RemoteInvocationResult的实现。

public class SimpleHttpInvokerRequestExecutor extends AbstractHttpInvokerRequestExecutor {
//HTTP调用请求执行器真正进行远程调用的方法，该方法有其父类//AbstractHttpInvokerRequestExecutor的executeRequest方法调用
	protected RemoteInvocationResult doExecuteRequest(
			HttpInvokerClientConfiguration config, ByteArrayOutputStream baos)
			throws IOException, ClassNotFoundException {
		//打开一个标准的J2SE HttpURLConnection
		HttpURLConnection con = openConnection(config);
		//准备连接
		prepareConnection(con, baos.size());
//远程调用被封装成了RemoteInvocation对象，它通过序列化被写到对应的//HttpURLConnection中
		writeRequestBody(config, con, baos);
		//获取远程调用的结果，校验返回的结果
		validateResponse(config, con);
		InputStream responseBody = readResponseBody(config, con);
		//将远程调用结果转换成RemoteInvocationResult返回
		return readRemoteInvocationResult(responseBody, config.getCodebaseUrl());
	}
//打开一个HttpURLConnection
	protected HttpURLConnection openConnection(HttpInvokerClientConfiguration config) throws IOException {
		//getServiceUrl()方法获取配置的远程调用URL，打开一个URL连接
		URLConnection con = new URL(config.getServiceUrl()).openConnection();
		if (!(con instanceof HttpURLConnection)) {
			throw new IOException("Service URL [" + config.getServiceUrl() + "] is not an HTTP URL");
		}
		return (HttpURLConnection) con;
	}
	//准备HTTP请求连接
	protected void prepareConnection(HttpURLConnection con, int contentLength) throws IOException {
		con.setDoOutput(true);
		//HTTP调用器只支持POST请求方法
		con.setRequestMethod(HTTP_METHOD_POST);
	//设置HTTP请求头内容类型，设置为：application/x-java-serialized-object
		con.setRequestProperty(HTTP_HEADER_CONTENT_TYPE, getContentType());
		//设置HTTP请求头内容长度
		con.setRequestProperty(HTTP_HEADER_CONTENT_LENGTH, Integer.toString(contentLength));
		LocaleContext locale = LocaleContextHolder.getLocaleContext();
		//设置HTTP请求的Locale
		if (locale != null) {
			con.setRequestProperty(HTTP_HEADER_ACCEPT_LANGUAGE, StringUtils.toLanguageTag(locale.getLocale()));
		}
		//设置HTTP请求压缩方式
		if (isAcceptGzipEncoding()) {
			con.setRequestProperty(HTTP_HEADER_ACCEPT_ENCODING, ENCODING_GZIP);
		}
	}
//把序列化对象输出到HTTP请求体中
	protected void writeRequestBody(
			HttpInvokerClientConfiguration config, HttpURLConnection con, ByteArrayOutputStream baos)
			throws IOException {
		baos.writeTo(con.getOutputStream());
	}
//校验远程调用的HTTP响应
	protected void validateResponse(HttpInvokerClientConfiguration config, HttpURLConnection con)
			throws IOException {
		//如果HTTP响应状态码大于等于300，则证明调用发生错误
		if (con.getResponseCode() >= 300) {
			throw new IOException(
					"Did not receive successful HTTP response: status code = " + con.getResponseCode() +
					", status message = [" + con.getResponseMessage() + "]");
		}
	}
	//提取远程调用结果的HTTP响应信息
	protected InputStream readResponseBody(HttpInvokerClientConfiguration config, HttpURLConnection con)
			throws IOException {
		//如果响应信息是Gzip压缩的，则需要先解压
		if (isGzipResponse(con)) {
			return new GZIPInputStream(con.getInputStream());
		}
		//正常的HTTP响应
		else {
			return con.getInputStream();
		}
	}
	//是否是Gzip格式压缩
	protected boolean isGzipResponse(HttpURLConnection con) {
		//获取HTTP响应头信息中的压缩方式
		String encodingHeader = con.getHeaderField(HTTP_HEADER_CONTENT_ENCODING);
		return (encodingHeader != null && encodingHeader.toLowerCase().indexOf(ENCODING_GZIP) != -1);
	}
}

 5、AbstractHttpInvokerRequestExecutor中处理远程调用结果，并HTTP响应转换成RemoteInvocationResult的主要方法如下：

//从HTTP响应中读取远程调用结果入口方法
protected RemoteInvocationResult readRemoteInvocationResult(InputStream is, String codebaseUrl)
			throws IOException, ClassNotFoundException {
		//根据给定的输入流和类创建对象输入流
		ObjectInputStream ois = createObjectInputStream(decorateInputStream(is), codebaseUrl);
		try {
			//从对象输入流中读取远程调用结果
			return doReadRemoteInvocationResult(ois);
		}
		finally {
			ois.close();
		}
	}
//从对象输入流中读取远程调用结果
protected RemoteInvocationResult doReadRemoteInvocationResult(ObjectInputStream ois)
			throws IOException, ClassNotFoundException {
		//获取对象输入流中的对象
		Object obj = ois.readObject();
		if (!(obj instanceof RemoteInvocationResult)) {
			throw new RemoteException("Deserialized object needs to be assignable to type [" +
					RemoteInvocationResult.class.getName() + "]: " + obj);
		}
		//将获取到的对象封装为RemoteInvocationResult
		return (RemoteInvocationResult) obj;
	}