`

Spring HttpInvoke远程调用服务

阅读更多

Spring HttpInvoke实现和效率提升

2人收藏此文章, 收藏此文章 发表于3个月前 , 已有143次阅读 共0个评论 2人收藏此文章

Spring HttpInvoke,一种较为常用的、基于Spring架构的服务器之间的远程调用实现,可以说是轻量级的RMI。 
最初,我们使用Spring HttpInvoke同步配置数据,刷新多个服务器上的缓存,当然如果用分布式缓存是不是更好 ! 
使用Spring HttpInvoke,你可以调用远程接口,进行数据交互、业务逻辑操作等等。 
废话不说了,上代码! 
用户操作接口: 
Java代码  
  1. /** 
  2.  * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a> 
  3.  * @since 1.0 
  4.  */  
  5. public interface UserService {  
  6.   
  7.     /** 
  8.      * 获得用户 
  9.      *  
  10.      * @param username 
  11.      *            用户名 
  12.      * @return 
  13.      */  
  14.     User getUser(String username);  
  15. }  

用户类,注意实现Serializable接口,这是执行远程调用传递数据对象的第一要求——数据对象必须实现Serializable接口,因为,要执行序列化/反序列化操作! 
Java代码  
  1. /** 
  2.  * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a> 
  3.  * @since 1.0 
  4.  */  
  5. public class User implements Serializable {  
  6.   
  7.     private static final long serialVersionUID = 5590768569302443813L;  
  8.     private String username;  
  9.     private Date birthday;  
  10.   
  11.     /** 
  12.      * @param username 
  13.      * @param birthday 
  14.      */  
  15.     public User(String username, Date birthday) {  
  16.         this.username = username;  
  17.         this.birthday = birthday;  
  18.     }  
  19.        // 省略  
  20.     /* 
  21.      * (non-Javadoc) 
  22.      *  
  23.      * @see java.lang.Object#toString() 
  24.      */  
  25.     @Override  
  26.     public String toString() {  
  27.         return String.format("%s\t%s\t", username, birthday);  
  28.     }  
  29. }  

覆盖toString()方法,输出用户信息! 
再看UserServiceImpl实现: 
Java代码  
  1. /** 
  2.  * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a> 
  3.  * @since 1.0 
  4.  */  
  5. public class UserServiceImpl implements UserService {  
  6.     private Logger logger = Logger.getLogger(UserServiceImpl.class);  
  7.   
  8.     /* 
  9.      * (non-Javadoc) 
  10.      *  
  11.      * @see 
  12.      * org.zlex.spring.httpinvoke.service.UserService#getUser(java.lang.String) 
  13.      */  
  14.     @Override  
  15.     public User getUser(String username) {  
  16.         if (logger.isDebugEnabled()) {  
  17.             logger.debug("username:[" + username + "]");  
  18.         }  
  19.         User user = new User(username, new Date());  
  20.         if (logger.isDebugEnabled()) {  
  21.             logger.debug("user:[" + user + "]");  
  22.         }  
  23.         return user;  
  24.     }  
  25.   
  26. }  

只把用户信息打出来即可说明调用效果! 
看applicationContext.xml 
Xml代码  
  1. <bean  
  2.     id="userService"  
  3. class="org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter">  
  4.     <property  
  5.         name="service">  
  6.         <bean  
  7. class="org.zlex.spring.httpinvoke.service.impl.UserServiceImpl" />  
  8.     </property>  
  9.     <property  
  10.         name="serviceInterface"  
  11.         value="org.zlex.spring.httpinvoke.service.UserService" />  
  12. </bean>  

我们要把userService暴露出去,这样外部就可以通过http接口调用这个接口的实现了。 
说说HttpInvokerServiceExporter,这个类用来在服务器端包装需要暴露的接口。 
熟悉service,定义具体的实现类! 
Xml代码  
  1. <property  
  2.     name="service">  
  3.     <bean  
  4. lass="org.zlex.spring.httpinvoke.service.impl.UserServiceImpl" />  
  5. </property>  

熟悉serviceInterface指向需要暴露的接口,注意使用value标注接口名称! 
Xml代码 
  1. <property  
  2.     name="serviceInterface"  
  3.     value="org.zlex.spring.httpinvoke.service.UserService" />  

最后再看service-servlet.xml配置 
Xml代码  
  1. <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">  
  2.     <property  
  3.         name="urlMap">  
  4.         <map>  
  5.             <entry  
  6.                 key="userTest"  
  7.                 value-ref="userService" />  
  8.         </map>  
  9.     </property>  
  10. </bean>  

直接将请求指向刚才配置的userService 
现在我们之间访问一下http://localhost:8080/spring/service/ 
 
这就说明,服务器端配置已经成功了!如果在日志中频繁得到这种异常,那很可能服务器被恶意访问了! 
再看客户端实现: 
Java代码  
  1. /** 
  2.  * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a> 
  3.  * @since 1.0 
  4.  */  
  5. public class UserServiceTest {  
  6.     private Logger logger = Logger.getLogger(UserServiceTest.class);  
  7.     private ApplicationContext context;  
  8.   
  9.     private UserService userService;  
  10.   
  11.     @Before  
  12.     public void initialize() {  
  13.         context = new ClassPathXmlApplicationContext("applicationContext.xml");  
  14.         userService = (UserService) context.getBean("userService");  
  15.     }  
  16.   
  17.     @Test  
  18.     public void getUser() {  
  19.         User user = userService.getUser("zlex");  
  20.         if (logger.isDebugEnabled()) {  
  21.             logger.debug("user[" + user + "]");  
  22.         }  
  23.     }  
  24. }  

我们做了什么?Nothing!就跟调用一般Spring容器中的实现一样! 
再看applicationContext.xml: 
Xml代码  
  1. <bean  
  2.     id="userService"  
  3. class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">  
  4.     <property  
  5.         name="serviceUrl"  
  6.         value="http://localhost:8080/spring/service/userTest" />  
  7.     <property  
  8.         name="serviceInterface"  
  9.         value="org.zlex.spring.httpinvoke.service.UserService" />  
  10. </bean>  

这里我们可以通过Spring容器调用userService,而实际上,他是一个HttpInvokerProxyFactoryBean,在这个配置里,定义了访问地址serviceUrl,和访问接口serviceInterface。 
执行测试! 
 
如果我们这样写,其实默认调用了SimpleHttpInvokerRequestExecutor做实现,这个实现恐怕只能作为演示来用! 
这也是效率问题所在!!! 
为提高效率,应该通过Commons-HttpClient! 
我们需要做什么?导入这个jar,改改xml就行! 
Xml代码 
  1. <bean  
  2.     id="userService"  
  3.     class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">  
  4.     <property  
  5.         name="serviceUrl"  
  6.         value="http://localhost:8080/spring/service" />  
  7.     <property  
  8.         name="serviceInterface"  
  9.         value="org.zlex.spring.httpinvoke.service.UserService" />  
  10.     <property  
  11.         name="httpInvokerRequestExecutor">  
  12.         <ref  
  13.             bean="httpInvokerRequestExecutor" />  
  14.     </property>  
  15. </bean>  
  16. <bean  
  17.     id="httpInvokerRequestExecutor" class="org.springframework.remoting.httpinvoker.CommonsHttpInvokerRequestExecutor">  
  18.     <property  
  19.         name="httpClient">  
  20.         <bean  
  21.             class="org.apache.commons.httpclient.HttpClient">  
  22.             <property  
  23.                 name="connectionTimeout"  
  24.                 value="2000" />  
  25.             <property  
  26.                 name="timeout"  
  27.                 value="5000" />  
  28.         </bean>  
  29.     </property>  
  30. </bean>  

通过HttpClient,我们可以配置超时时间timeout和连接超时connectionTimeout两个属性,这样,服务器执行操作时,如果超时就可以强行释放连接,这样可怜的tomcat不会因为HttpInvoke连接不释放而被累死! 
回头看了一眼我N多年前的代码,万岁,我当时确实是这么实现的!好在没有犯低级错误!!! 
执行操作! 
 
这时,转为org.springframework.remoting.httpinvoker.CommonsHttpInvokerRequestExecutor实现了! 
不过同事认为,这个效率还是不够高!!! 
再改,改什么?还是xml! 
Xml代码  
  1. <bean  
  2.         id="httpInvokerRequestExecutor"  
  3.         class="org.springframework.remoting.httpinvoker.CommonsHttpInvokerRequestExecutor">  
  4.         <property  
  5.             name="httpClient">  
  6.             <bean  
  7.                 class="org.apache.commons.httpclient.HttpClient">  
  8.                 <property  
  9.                     name="connectionTimeout"  
  10.                     value="2000" />  
  11.                 <property  
  12.                     name="timeout"  
  13.                     value="5000" />  
  14.                 <property  
  15.                     name="httpConnectionManager">  
  16.                     <ref  
  17.                         bean="multiThreadedHttpConnectionManager" />  
  18.                 </property>  
  19.             </bean>  
  20.         </property>  
  21.     </bean>  
  22.     <bean  
  23.         id="multiThreadedHttpConnectionManager"  
  24.         class="org.apache.commons.httpclient.MultiThreadedHttpConnectionManager">  
  25.         <property  
  26.             name="params">  
  27.             <bean  
  28.                 class="org.apache.commons.httpclient.params.HttpConnectionManagerParams">  
  29.                 <property  
  30.                     name="maxTotalConnections"  
  31.                     value="600" />  
  32.                 <property  
  33.                     name="defaultMaxConnectionsPerHost"  
  34.                     value="512" />  
  35.             </bean>  
  36.         </property>  
  37.     </bean>  

改用MultiThreadedHttpConnectionManager,多线程!!! 
测试就不说了,实践证明: 
默认实现,服务器平均10s左右才能响应一个请求。 
多线程实现,服务器平均20ms左右响应一个请求。 
这简直不是一个数量级!!! 

注意:在HttpClient的3.1版本中,已不支持如下配置,相应的方法已经废弃! 
Xml代码  
  1. <property    
  2.     name="connectionTimeout"    
  3.     value="2000" />    
  4. <property    
  5.     name="timeout"    
  6.     value="5000" />   


如果仔细看看文档, 
引用
HttpClient that uses a default MultiThreadedHttpConnectionManager.

commons 系列的实现怎么会不考虑多线程呢?人家默认实现就是多线程的!同事多虑了! 
当然,同事还补充了一句,需要控制连接数! 
难怪,这里要设置 
Xml代码  
  1. <bean  
  2.     class="org.apache.commons.httpclient.params.HttpConnectionManagerParams">  
  3.     <property  
  4.         name="maxTotalConnections"  
  5.         value="600" />  
  6.     <property  
  7.         name="defaultMaxConnectionsPerHost"  
  8.         value="512" />  
  9. </bean>  


默认啥情况?
引用
maxConnectionsPerHost 每个主机的最大并行链接数,默认为2 
public static final int DEFAULT_MAX_HOST_CONNECTIONS = 2; 
maxTotalConnections 客户端总并行链接最大数,默认为20  
public static final int DEFAULT_MAX_TOTAL_CONNECTIONS = 20;

 

--以下是艺术家补充

增加一个service-servlet.xm(对应urlMap)l,放在web-inf目录下 

web.xml中配置  

1 <servlet>
2     <servlet-name>service</servlet-name>
3     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
4     <load-on-startup>1</load-on-startup>
5 </servlet>
6 <servlet-mapping>
7     <servlet-name>service</servlet-name>
8     <url-pattern>/service/*</url-pattern>
9 </servlet-mapping>
分享到:
评论
发表评论

文章已被作者锁定,不允许评论。

相关推荐

    springmvc+httpInvoke远程调用例子(1)

    采用了httpInvoke远程调用技术,为了简单只用了jsp-&gt;controller-&gt;dao分层。。其中的jsp controller 放在_web工程中,业务逻辑放在_svc中,分开下载,如果觉得没有,就可以不用下载另外一个工程了,持久层用mybatis,...

    Spring HttpInvoke实现,以及效率提升!

    Spring HttpInvoke 是一个基于 Spring 框架的远程方法调用(RPC)解决方案,它允许你在分布式系统中透明地调用服务。这篇博客主要探讨了如何实现 Spring HttpInvoke 并提出了提高其效率的方法。 首先,我们需要理解...

    Spring 实现远程访问详解——httpinvoker

    上文我们利用Spring rmi实现了Spring的远程访问(Spring 实现远程访问详解——rmi),本文主要讲解利用HttpInvoke实现远程访问。 Spring httpInvoker使用标准java序列化机制,通过Http暴露业务服务。如果你的参数和...

    Dubbo服务框架面试题及答案.pdf

    - 使用Spring的HttpInvoke实现,适合提供者数量多于消费者的场景,尤其是需要为应用程序和浏览器JS调用的情况。基于HTTP的短连接传输。 5. **Hessian协议**: - 基于HTTP通讯,使用Servlet暴露服务,Dubbo内嵌...

    Dubbo面试及答案(上).pdf

    2. **Cluster**:服务框架,实现了基于接口方法的透明远程调用,支持多协议,包含负载均衡、失败容错和地址路由等功能。 3. **Registry**:服务注册,通过注册中心实现实时服务信息更新和订阅,保证服务间的通信可靠...

    httpinvoker的使用实例

    HTTPInvoker是Spring框架中的一种远程调用机制,它允许客户端通过HTTP协议来调用服务器端的方法,实现远程服务的透明化访问。这个技术基于HTTP,所以具有较好的穿透性,适用于内网或者对安全性要求不高的环境。在这...

    Java Dubbo面试及答案

    4. HTTP 协议:基于 Http 表单提交的远程调用协议,使用 Spring 的 HttpInvoke 实现。多个短连接,传输协议 HTTP,传入参数大小混合,提供者个数多于消费者,需要给应用程序和浏览器 JS 调用。 5. Hessian 协议:...

    Dubbo面试.pdf

    4. http协议:使用基于Http表单提交的远程调用协议,通过Spring的HttpInvoke实现。它支持HTTP协议,适用于提供者数量多于消费者,需要支持应用程序和浏览器JS调用的场景。 5. hessian协议:基于Hessian服务,采用...

    Dubbo 19道面试题及答案.docx

    - **RMI协议**:基于JDK的RMI标准,适合常规的远程服务调用,但可能存在安全漏洞。 - **WebService协议**:基于CXF,适合系统集成和跨语言调用,基于HTTP协议。 - **HTTP协议**:使用Spring的Httpinvoke实现,适合JS...

    Dubbo面试题集合.pdf

    - **特点**:基于HTTP表单提交的远程调用协议,使用Spring的HttpInvoke实现。 - **应用场景**:适用于需要给应用程序和浏览器JS调用的场景。 - **优点**:简单易用,易于调试。 - **缺点**:性能不是最优,安全性...

    2021Java字节跳动面试题——面向字节_Dubbo(上).pdf

    - **特点**:基于Http表单提交的远程调用协议,使用Spring的HttpInvoke实现。 - **传输协议**:HTTP - **应用场景**:适用于需要给应用程序和浏览器JS调用的场景。 - **优点**:易于理解和使用。 - **缺点**:性能...

    JAVA面试_Dubbo常问面试题30个.pdf

    - 基于WebService的远程调用,集成CXF实现,支持与原生WebService的互操作。 - 使用HTTP协议,同步传输,适合跨语言调用和系统集成。 4. **http协议**: - 基于Http表单提交,使用Spring的HttpInvoke实现。 - ...

Global site tag (gtag.js) - Google Analytics