程序博客网 > mac文件打包

Spring HttpInvoker源码分析

来源：互联网 发布：mac文件打包 编辑：程序博客网 时间：2024/05/16 15:59

1.Spring中，HTTPInvoker(HTTP调用器)是通过基于HTTP协议的分布式远程调用解决方案，和java RMI一样，HTTP调用器也需要使用java的对象序列化机制完成客户端和服务器端的通信。HTTP调用器的远程调用工作原理如下：

(1).客户端：

a.向服务器发送远程调用请求：

远程调用信息——>封装为远程调用对象——>序列化写入到远程调用HTTP请求中——>向服务器端发送。

b.接收服务器端返回的远程调用结果：

服务器端返回的远程调用结果HTTP响应——>反序列化为远程调用结果对象。

(2).服务器端：

a.接收客户端发送的远程调用请求：

客户端发送的远程调用HTTP请求——>反序列化为远程调用对象——>调用服务器端目标对象的目标方法处理。

b.向客户端返回远程调用结果：

服务器端目标对象方法的处理结果——>序列化写入远程调用结果HTTP响应中——>返回给客户端。

接下来我们将从客户端和服务器端分别分析HTTP调用器远程调用的具体实现。

2.HTTP调用器客户端配置：

使用HTTP调用器之前，首先需要对客户端其进行如下的配置：

[xhtml] view plaincopy
  1. <!--客户端HTTP调用器代理-->  
  2. <bean id=”proxy” class=”org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean”>  
  3. <property name=”serviceUrl”>  
  4. <value>http://yourhost:8080/远程调用URL</value>  
  5. </property>  
  6. <property name=”serviceInterface”>  
  7. <value>远程调用服务接口全路径</value>  
  8. </property>  
  9. </bean>  
  10. <bean id=”客户端bean” class=”客户端Bean全路径”>  
  11.         <property name=”remoteService”>  
  12.                 <ref bean=”proxy”/>  
  13.         </property>  
  14. </bean>  

在HTTP调用器客户端代理HttpInvokerProxyFactoryBean中封装远程调用服务URL和服务接口，客户端程序通过HTTP调用代理可以调用实现了指定接口的目标服务端对象。

3.HttpInvokerProxyFactoryBean创建远程调用代理对象：

HTTP调用器客户端代理HttpInvokerProxyFactoryBean是一个实现了Spring FactoryBean接口的IoC容器，其作用是对远程服务客户端封装，源码如下：

[java] view plaincopy
  1. public class HttpInvokerProxyFactoryBean extends HttpInvokerClientInterceptor implements FactoryBean<Object> {  
  2.     //远程对象的代理  
  3.     private Object serviceProxy;  
  4.     //在IoC容器注入完成之后调用  
  5.     public void afterPropertiesSet() {  
  6.         //调用父类容器的回调方法  
  7.         super.afterPropertiesSet();  
  8. //getServiceInterface()方法用于获取配置的远程调用接口  
  9.         if (getServiceInterface() == null) {  
  10.             throw new IllegalArgumentException("Property 'serviceInterface' is required");  
  11.         }  
  12.         //使用ProxyFactory代理工厂生成远程代理对象，注意第二个参数this，因为  
  13.     //HttpInvokerProxyFactoryBean继承了HttpInvokerClientInterceptor,  
  14.         //所以代理对象的拦截器设置为HttpInvokerClientInterceptor  
  15.         this.serviceProxy = new ProxyFactory(getServiceInterface(), this).getProxy(getBeanClassLoader());  
  16.     }  
  17.     //向IoC容器索取被管理对象的方法，获取产生的远程调用代理对象  
  18.     public Object getObject() {  
  19.         return this.serviceProxy;  
  20.     }  
  21.     //获取对象类型，返回配置的远程调用接口  
  22.     public Class<?> getObjectType() {  
  23.         return getServiceInterface();  
  24.     }  
  25.     //是否是单态类型，默认Spring IoC容器产生的都是单态类型  
  26.     public boolean isSingleton() {  
  27.         return true;  
  28.     }  
  29. }  

通过上面对HttpInvokerProxyFactoryBean源码的分析我们看到，当通过getObject方法向Spring IoC容器索取远程调用对象时，触发afterPropertiesSet回调方法，创建远程调用的代理对象，最后将该远程调用代理对象返回。在创建远程调用代理对象时，使用其父类HttpInvokerClientInterceptor作为远程调用代理对象的拦截器，该拦截器将拦截对代理对象的方法调用。下面我们分析HttpInvokerClientInterceptor代理拦截器对代理对象的方法拦截处理。

4.HttpInvokerClientInterceptor拦截对远程调用代理的方法调用：

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

[java] view plaincopy
  1. public class HttpInvokerClientInterceptor extends RemoteInvocationBasedAccessor  
  2.         implements MethodInterceptor, HttpInvokerClientConfiguration {  
  3.     private String codebaseUrl;  
  4.     //HTTP调用请求执行器  
  5.     private HttpInvokerRequestExecutor httpInvokerRequestExecutor;  
  6.     public void setCodebaseUrl(String codebaseUrl) {  
  7.         this.codebaseUrl = codebaseUrl;  
  8.     }  
  9.     public String getCodebaseUrl() {  
  10.         return this.codebaseUrl;  
  11.     }  
  12.     public void setHttpInvokerRequestExecutor(HttpInvokerRequestExecutor httpInvokerRequestExecutor) {  
  13.         this.httpInvokerRequestExecutor = httpInvokerRequestExecutor;  
  14.     }  
  15.     //获取HTTP调用请求执行器，如果HTTP调用请求执行器没有设置，则使用  
  16.     //SimpleHttpInvokerRequestExecutor作为HTTP调用请求执行器  
  17.     public HttpInvokerRequestExecutor getHttpInvokerRequestExecutor() {  
  18.         if (this.httpInvokerRequestExecutor == null) {  
  19.             SimpleHttpInvokerRequestExecutor executor = new SimpleHttpInvokerRequestExecutor();  
  20.             executor.setBeanClassLoader(getBeanClassLoader());  
  21.             this.httpInvokerRequestExecutor = executor;  
  22.         }  
  23.         return this.httpInvokerRequestExecutor;  
  24.     }  
  25.     //IoC容器初始化完成回调方法  
  26.     public void afterPropertiesSet() {  
  27.         //调用父类的初始化回调方法  
  28.         super.afterPropertiesSet();  
  29.         //获取HTTP调用请求执行器  
  30.         getHttpInvokerRequestExecutor();  
  31.     }  
  32. //拦截器代理对象方法调用入口，拦截器将客户端对远程调用代理的调用封装为  
  33. //MethodInvocation对象。  
  34.     public Object invoke(MethodInvocation methodInvocation) throws Throwable {  
  35.         if (AopUtils.isToStringMethod(methodInvocation.getMethod())) {  
  36.             return "HTTP invoker proxy for service URL [" + getServiceUrl() + "]";  
  37.         }  
  38.         //创建远程调用对象，封装了远程调用  
  39.         RemoteInvocation invocation = createRemoteInvocation(methodInvocation);  
  40.         //远程调用结果  
  41.         RemoteInvocationResult result = null;  
  42.         try {  
  43.             //远程调用入口  
  44.             result = executeRequest(invocation, methodInvocation);  
  45.         }  
  46.         catch (Throwable ex) {  
  47.             throw convertHttpInvokerAccessException(ex);  
  48.         }  
  49.         try {  
  50.             //返回远程调用结果  
  51.             return recreateRemoteInvocationResult(result);  
  52.         }  
  53.         catch (Throwable ex) {  
  54.             if (result.hasInvocationTargetException()) {  
  55.                 throw ex;  
  56.             }  
  57.             else {  
  58.                 throw new RemoteInvocationFailureException("Invocation of method [" + methodInvocation.getMethod() +  
  59.                         "] failed in HTTP invoker remote service at [" + getServiceUrl() + "]", ex);  
  60.             }  
  61.         }  
  62.     }  
  63.     //执行远程调用入口  
  64.     protected RemoteInvocationResult executeRequest(  
  65.             RemoteInvocation invocation, MethodInvocation originalInvocation) throws Exception {  
  66.         return executeRequest(invocation);  
  67.     }  
  68.     //通过HTTP调用请求执行器执行远程调用  
  69.     protected RemoteInvocationResult executeRequest(RemoteInvocation invocation) throws Exception {  
  70.         return getHttpInvokerRequestExecutor().executeRequest(this, invocation);  
  71.     }  
  72.     //将远程调用异常转换成Spring异常  
  73.     protected RemoteAccessException convertHttpInvokerAccessException(Throwable ex) {  
  74.         if (ex instanceof ConnectException) {  
  75.             throw new RemoteConnectFailureException(  
  76.                     "Could not connect to HTTP invoker remote service at [" + getServiceUrl() + "]", ex);  
  77.         }  
  78.         else if (ex instanceof ClassNotFoundException || ex instanceof NoClassDefFoundError ||  
  79.                 ex instanceof InvalidClassException) {  
  80.             throw new RemoteAccessException(  
  81.                     "Could not deserialize result from HTTP invoker remote service [" + getServiceUrl() + "]", ex);  
  82.         }  
  83.         else {  
  84.             throw new RemoteAccessException(  
  85.                 "Could not access HTTP invoker remote service at [" + getServiceUrl() + "]", ex);  
  86.         }  
  87.     }  
  88. }  

通过上面对HttpInvokerClientInterceptor拦截器的源码分析，我们可以看出，拦截器将客户端对远程调用的HTTP请求封装成了MethodInvocation对象，拦截器的在调用远程调用的代理对象时，又将方法调用封装成了RemoteInvocation远程调用，RemoteInvocation数据对象中封装了调用的具体信息，如方法名、方法参数以及参数类型等。

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

5.SimpleHttpInvokerRequestExecutor远程调用：

SimpleHttpInvokerRequestExecutor封装了基于HTTP协议的远程调用过程，具体源码如下：

[java] view plaincopy
  1. public class SimpleHttpInvokerRequestExecutor extends AbstractHttpInvokerRequestExecutor {  
  2. //HTTP调用请求执行器真正进行远程调用的方法，该方法有其父类//AbstractHttpInvokerRequestExecutor的executeRequest方法调用  
  3.     protected RemoteInvocationResult doExecuteRequest(  
  4.             HttpInvokerClientConfiguration config, ByteArrayOutputStream baos)  
  5.             throws IOException, ClassNotFoundException {  
  6.         //打开一个标准的J2SE HttpURLConnection  
  7.         HttpURLConnection con = openConnection(config);  
  8.         //准备连接  
  9.         prepareConnection(con, baos.size());  
  10. //远程调用被封装成了RemoteInvocation对象，它通过序列化被写到对应的//HttpURLConnection中  
  11.         writeRequestBody(config, con, baos);  
  12.         //获取远程调用的结果，校验返回的结果  
  13.         validateResponse(config, con);  
  14.         InputStream responseBody = readResponseBody(config, con);  
  15.         //将远程调用结果转换成RemoteInvocationResult返回  
  16.         return readRemoteInvocationResult(responseBody, config.getCodebaseUrl());  
  17.     }  
  18. //打开一个HttpURLConnection  
  19.     protected HttpURLConnection openConnection(HttpInvokerClientConfiguration config) throws IOException {  
  20.         //getServiceUrl()方法获取配置的远程调用URL，打开一个URL连接  
  21.         URLConnection con = new URL(config.getServiceUrl()).openConnection();  
  22.         if (!(con instanceof HttpURLConnection)) {  
  23.             throw new IOException("Service URL [" + config.getServiceUrl() + "] is not an HTTP URL");  
  24.         }  
  25.         return (HttpURLConnection) con;  
  26.     }  
  27.     //准备HTTP请求连接  
  28.     protected void prepareConnection(HttpURLConnection con, int contentLength) throws IOException {  
  29.         con.setDoOutput(true);  
  30.         //HTTP调用器只支持POST请求方法  
  31.         con.setRequestMethod(HTTP_METHOD_POST);  
  32.     //设置HTTP请求头内容类型，设置为：application/x-java-serialized-object  
  33.         con.setRequestProperty(HTTP_HEADER_CONTENT_TYPE, getContentType());  
  34.         //设置HTTP请求头内容长度  
  35.         con.setRequestProperty(HTTP_HEADER_CONTENT_LENGTH, Integer.toString(contentLength));  
  36.         LocaleContext locale = LocaleContextHolder.getLocaleContext();  
  37.         //设置HTTP请求的Locale  
  38.         if (locale != null) {  
  39.             con.setRequestProperty(HTTP_HEADER_ACCEPT_LANGUAGE, StringUtils.toLanguageTag(locale.getLocale()));  
  40.         }  
  41.         //设置HTTP请求压缩方式  
  42.         if (isAcceptGzipEncoding()) {  
  43.             con.setRequestProperty(HTTP_HEADER_ACCEPT_ENCODING, ENCODING_GZIP);  
  44.         }  
  45.     }  
  46. //把序列化对象输出到HTTP请求体中  
  47.     protected void writeRequestBody(  
  48.             HttpInvokerClientConfiguration config, HttpURLConnection con, ByteArrayOutputStream baos)  
  49.             throws IOException {  
  50.         baos.writeTo(con.getOutputStream());  
  51.     }  
  52. //校验远程调用的HTTP响应  
  53.     protected void validateResponse(HttpInvokerClientConfiguration config, HttpURLConnection con)  
  54.             throws IOException {  
  55.         //如果HTTP响应状态码大于等于300，则证明调用发生错误  
  56.         if (con.getResponseCode() >= 300) {  
  57.             throw new IOException(  
  58.                     "Did not receive successful HTTP response: status code = " + con.getResponseCode() +  
  59.                     ", status message = [" + con.getResponseMessage() + "]");  
  60.         }  
  61.     }  
  62.     //提取远程调用结果的HTTP响应信息  
  63.     protected InputStream readResponseBody(HttpInvokerClientConfiguration config, HttpURLConnection con)  
  64.             throws IOException {  
  65.         //如果响应信息是Gzip压缩的，则需要先解压  
  66.         if (isGzipResponse(con)) {  
  67.             return new GZIPInputStream(con.getInputStream());  
  68.         }  
  69.         //正常的HTTP响应  
  70.         else {  
  71.             return con.getInputStream();  
  72.         }  
  73.     }  
  74.     //是否是Gzip格式压缩  
  75.     protected boolean isGzipResponse(HttpURLConnection con) {  
  76.         //获取HTTP响应头信息中的压缩方式  
  77.         String encodingHeader = con.getHeaderField(HTTP_HEADER_CONTENT_ENCODING);  
  78.         return (encodingHeader != null && encodingHeader.toLowerCase().indexOf(ENCODING_GZIP) != -1);  
  79.     }  
  80. }  

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

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

6.AbstractHttpInvokerRequestExecutor其将HTTP响应结果转换成RemoteInvocationResult：

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

[java] view plaincopy
  1. //从HTTP响应中读取远程调用结果入口方法  
  2. protected RemoteInvocationResult readRemoteInvocationResult(InputStream is, String codebaseUrl)  
  3.             throws IOException, ClassNotFoundException {  
  4.         //根据给定的输入流和类创建对象输入流  
  5.         ObjectInputStream ois = createObjectInputStream(decorateInputStream(is), codebaseUrl);  
  6.         try {  
  7.             //从对象输入流中读取远程调用结果  
  8.             return doReadRemoteInvocationResult(ois);  
  9.         }  
  10.         finally {  
  11.             ois.close();  
  12.         }  
  13.     }  
  14. //从对象输入流中读取远程调用结果  
  15. protected RemoteInvocationResult doReadRemoteInvocationResult(ObjectInputStream ois)  
  16.             throws IOException, ClassNotFoundException {  
  17.         //获取对象输入流中的对象  
  18.         Object obj = ois.readObject();  
  19.         if (!(obj instanceof RemoteInvocationResult)) {  
  20.             throw new RemoteException("Deserialized object needs to be assignable to type [" +  
  21.                     RemoteInvocationResult.class.getName() + "]: " + obj);  
  22.         }  
  23.         //将获取到的对象封装为RemoteInvocationResult  
  24.         return (RemoteInvocationResult) obj;  
  25.     }  

7.HTTP调用器的服务器端配置：

和HTTP调用器客户端类似，服务器端也需要进行如下的配置：

[xhtml] view plaincopy
  1. <bean name=”/客户端配置的远程调用URL” class=”org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter”>  
  2. <property name=”service”>  
  3. <ref bean=”服务器端实现bean”/>  
  4. </property>  
  5. <property name=”serviceInterface”>  
  6. <value>远程调用服务接口全路径</value>  
  7. </property>  
  8. </property>  

通过对服务器端配置的例子，我们可以看出，真正处理远程调用的服务器端实现是由service属性中指定的服务器端bean提供的，HttpInvokerServiceExporter将远程调用服务接口和服务实现类进行封装，主要提HTTP协议封装和java对象序列化功能。

Spring的HttpInvokerServiceExporter是与Spring的MVC结合在一起的，它本质上是Spring MVC的一个Controller，客户端发来的远程调用HTTP请求有Spring MVC的中央控制器DispatcherServlet转发到指定URL的HttpInvokerServiceExporter上。

8.HttpInvokerServiceExporter导出和执行远程调用服务：

HttpInvokerServiceExporter响应客户端发送的远程调用HTTP请求，它从HTTP请求中读取远程调用并将其反序列化为RemoteInvocation对象，然后调用目标服务对象的目标方法完成远程调用服务，当服务执行完成之后，通过HTTP响应把执行结果对象序列化输出到客户端。器源码如下：

[java] view plaincopy
  1. public class HttpInvokerServiceExporter extends RemoteInvocationSerializingExporter implements HttpRequestHandler {  
  2.     //处理客户端发来的远程调用HTTP请求  
  3.     public void handleRequest(HttpServletRequest request, HttpServletResponse response)  
  4.             throws ServletException, IOException {  
  5.         try {  
  6.             //从HTTP请求中反序列化出RemoteInvocation远程调用对象  
  7.             RemoteInvocation invocation = readRemoteInvocation(request);  
  8.             //调用目标服务对象，完成远程调用请求，并创建调用结果  
  9.             RemoteInvocationResult result = invokeAndCreateResult(invocation, getProxy());  
  10.             //将调用结果写到HTTP响应中  
  11.             writeRemoteInvocationResult(request, response, result);  
  12.         }  
  13.         catch (ClassNotFoundException ex) {  
  14.             throw new NestedServletException("Class not found during deserialization", ex);  
  15.         }  
  16.     }  
  17.     //从HTTP请求中读取RemoteInvocation远程调用对象入口方法  
  18.     protected RemoteInvocation readRemoteInvocation(HttpServletRequest request) throws IOException, ClassNotFoundException {  
  19.         //将从HTTP请求中读取远程调用对象  
  20.         return readRemoteInvocation(request, request.getInputStream());  
  21.     }  
  22. //从HTTP请求中读取远程调用对象  
  23.     protected RemoteInvocation readRemoteInvocation(HttpServletRequest request, InputStream is) throws IOException, ClassNotFoundException {  
  24.         //根据HTTP请求输入流创建对象输入流  
  25.         ObjectInputStream ois = createObjectInputStream(decorateInputStream(request, is));  
  26.         try {  
  27.             //从对象输入流中读取远程调用对象  
  28.             return doReadRemoteInvocation(ois);  
  29.         }  
  30.         finally {  
  31.             ois.close();  
  32.         }  
  33.     }  
  34.     //获取HTTP请求输入流  
  35.     protected InputStream decorateInputStream(HttpServletRequest request, InputStream is) throws IOException {  
  36.         return is;  
  37.     }  
  38.     //将远程调用执行结果写到HTTP响应中  
  39.     protected void writeRemoteInvocationResult(  
  40.             HttpServletRequest request, HttpServletResponse response, RemoteInvocationResult result) throws IOException {  
  41.         //设置HTTP响应的内容类型为：application/x-java-serialized-object  
  42.         response.setContentType(getContentType());  
  43.         //将远程调用结果写到HTTP响应中  
  44.         writeRemoteInvocationResult(request, response, result, response.getOutputStream());  
  45.     }  
  46. //将远程调用执行结果写入HTTP响应中  
  47.     protected void writeRemoteInvocationResult(  
  48.             HttpServletRequest request, HttpServletResponse response, RemoteInvocationResult result, OutputStream os)  
  49.             throws IOException {  
  50.         //获取HTTP响应对象输出流  
  51.         ObjectOutputStream oos = createObjectOutputStream(decorateOutputStream(request, response, os));  
  52.         try {  
  53.             //将远程调用执行结果写到HTTP响应对象输出流中  
  54.             doWriteRemoteInvocationResult(result, oos);  
  55.         }  
  56.         finally {  
  57.             oos.close();  
  58.         }  
  59.     }  
  60.     //获取HTTP响应对象输入流  
  61.     protected OutputStream decorateOutputStream(  
  62.             HttpServletRequest request, HttpServletResponse response, OutputStream os) throws IOException {  
  63.         return os;  
  64.     }  
  65. }  

通过对HttpInvokerServiceExporter的源码分析，我们可以看出，真正执行远程对象调用的是RemoteInvocationResultresult = invokeAndCreateResult(invocation, getProxy());它调用了RemoteInvocationBasedExporter的invokeAndCreateResult方法调用远程目标对象方法，并创建远程调用执行结果，下面我们继续分析执行服务器端远程调用目标对象方法的实现。

9.RemoteInvocationBasedExporter调用服务器目标对象：

RemoteInvocationBasedExporter的invokeAndCreateResult方法调用服务器目标对象方法，RemoteInvocationBasedExporter源码如下：

[java] view plaincopy
  1. public abstract class RemoteInvocationBasedExporter extends RemoteExporter {  
  2.     //远程调用执行器  
  3. private RemoteInvocationExecutor remoteInvocationExecutor = new DefaultRemoteInvocationExecutor();  
  4. public RemoteInvocationExecutor getRemoteInvocationExecutor() {  
  5.         return this.remoteInvocationExecutor;  
  6.     }  
  7. protected RemoteInvocationResult invokeAndCreateResult(RemoteInvocation invocation, Object targetObject) {  
  8.         try {  
  9.             //调用服务器端目标对象的方法  
  10.             Object value = invoke(invocation, targetObject);  
  11.             //根据执行结果创建RemoteInvocationResult  
  12.             return new RemoteInvocationResult(value);  
  13.         }  
  14.         catch (Throwable ex) {  
  15.             return new RemoteInvocationResult(ex);  
  16.         }  
  17.     }  
  18. //调用目标对象的方法  
  19. protected Object invoke(RemoteInvocation invocation, Object targetObject)  
  20. throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {  
  21.         if (logger.isTraceEnabled()) {  
  22.             logger.trace("Executing " + invocation);  
  23.         }  
  24.         try {  
  25.             //获取远程调用执行器，由远程调用执行器调用目标对象的方法，即通过  
  26.             //DefaultRemoteInvocationExecutor了调用目标对象的方法  
  27.             return getRemoteInvocationExecutor().invoke(invocation, targetObject);  
  28.         }  
  29.         catch (NoSuchMethodException ex) {  
  30.             if (logger.isDebugEnabled()) {  
  31.                 logger.warn("Could not find target method for " + invocation, ex);  
  32.             }  
  33.             throw ex;  
  34.         }  
  35.         catch (IllegalAccessException ex) {  
  36.             if (logger.isDebugEnabled()) {  
  37.                 logger.warn("Could not access target method for " + invocation, ex);  
  38.             }  
  39.             throw ex;  
  40.         }  
  41.         catch (InvocationTargetException ex) {  
  42.             if (logger.isDebugEnabled()) {  
  43.                 logger.debug("Target method failed for " + invocation, ex.getTargetException());  
  44.             }  
  45.             throw ex;  
  46.         }  
  47.     }   
  48. }  

通过上面对RemoteInvocationBasedExporter源码分析我们看到，真正调用目标对象的是DefaultRemoteInvocationExecutor的invoke方法，下面我们继续分析DefaultRemoteInvocationExecutor调用目标对象方法的实现。

10.DefaultRemoteInvocationExecutor调用目标对象的方法实现远程调用：

DefaultRemoteInvocationExecutor用于调用目标对象的指定方法实现远程对象调用服务，其源码如下：

[java] view plaincopy
  1. public class DefaultRemoteInvocationExecutor implements RemoteInvocationExecutor {  
  2.     //调用目标对象的方法  
  3.     public Object invoke(RemoteInvocation invocation, Object targetObject)  
  4.             throws NoSuchMethodException, IllegalAccessException, InvocationTargetException{  
  5.         Assert.notNull(invocation, "RemoteInvocation must not be null");  
  6.         Assert.notNull(targetObject, "Target object must not be null");  
  7.         //调用RemoteInvocation的invoke方法  
  8.         return invocation.invoke(targetObject);  
  9.     }  
  10. }  
  11. RemoteInvocation的invoke方法源码如下：  
  12.     public Object invoke(Object targetObject)  
  13.             throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {  
  14.         //获取远程调用对象的方法名称和参数类型  
  15.         Method method = targetObject.getClass().getMethod(this.methodName, this.parameterTypes);  
  16.         //利用JDK反射机制，调用目标对象指定参数的方法  
  17.         return method.invoke(targetObject, this.arguments);  
  18.     }  
0 0
mac文件打包 mac文件打包
原创粉丝点击
热门IT博客
网络人工投票公司网络人工投票公司
企业内部即时通讯软件企业内部即时通讯软件
雅思培训机构知乎
ldc1000数据手册
淘宝客户资料购买
php工作流开源
我的世界java最大内存
淘宝直通车关键词下载
淘宝女装销量排名
手机吹奏软件
异能事务所网络电影
2016年的淘宝怎么操作
windows程序开发教程
武汉seo建站
英语人机对话软件
阿里云和百度云
网络上如何日赚一万
python基础视频教程
php mysql库存管理
神仙珊瑚 知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 寿宁县志 安图县志 安国县志 呼兰县志 武宁县志 武宣县志 广水县志 金溪县志 蠡县志 宽甸县志 富县县志 县志是什么 县志大全 全国县志在线阅读 全国各地县志电子版 地方志县志电子版 浚县志远轮胎商行的轮胎价格 地方县志大全 县级行政区 县级市 县级医院 县级以上包括县级吗 县级 县级市排名 县级代理商 县级融媒体 县级以上 副县级 地级市和县级市区别 县级市和县有什么区别 县级市和地级市 县级市市长级别 县级医院属于几级医院 全国县级市排名 泸小二县级代理好多钱 菜鸟物流县级代理 县级以上医院 九多肉多县级店倒闭 巴拉巴拉县级拿货几折 县级市什么意思 县级事业单位工资一般多少

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里