Spring Httpinvoke实现对外接口及效率提升

2024-06-22 05:32
文章标签 java 实现 接口 spring 提升 效率 对外 httpinvoke

本文主要是介绍Spring Httpinvoke实现对外接口及效率提升，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

本文转自：ITtye-snowolf博主

        最近接手服务器总被人质疑效率问题，说到底是质疑Spring HttpInvoke的效率问题。好在经过同事们的努力，找到了问题的根源，最终解决了这个问题。

我也顺道整理一下Spring HttpInvoke——那曾经最为熟悉的东西。
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" />  

最后再看servlet.xml配置
Xml代码   收藏代码
  1. <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">  
  2.     <property  
  3.         name="urlMap">  
  4.         <map>  
  5.             <entry  
  6.                 key="*"  
  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" />  
  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;



这篇关于Spring Httpinvoke实现对外接口及效率提升的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1083421。

相关文章

Java中流式并行操作parallelStream的原理和使用方法

Java中流式并行操作parallelStream的原理和使用方法

《Java中流式并行操作parallelStream的原理和使用方法》本文详细介绍了Java中的并行流（parallelStream）的原理、正确使用方法以及在实际业务中的应用案例,并指出在使用并行流... 目录Java中流式并行操作parallelStream0. 问题的产生1. 什么是parallelS
阅读更多...
C++中unordered_set哈希集合的实现

C++中unordered_set哈希集合的实现

《C++中unordered_set哈希集合的实现》std::unordered_set是C++标准库中的无序关联容器,基于哈希表实现,具有元素唯一性和无序性特点,本文就来详细的介绍一下unorder... 目录一、概述二、头文件与命名空间三、常用方法与示例1. 构造与析构2. 迭代器与遍历3. 容量相关4
阅读更多...
Java中Redisson 的原理深度解析

Java中Redisson 的原理深度解析

《Java中Redisson的原理深度解析》Redisson是一个高性能的Redis客户端,它通过将Redis数据结构映射为Java对象和分布式对象,实现了在Java应用中方便地使用Redis,本文... 目录前言一、核心设计理念二、核心架构与通信层1. 基于 Netty 的异步非阻塞通信2. 编解码器三、
阅读更多...
C++中悬垂引用(Dangling Reference) 的实现

C++中悬垂引用(Dangling Reference) 的实现

《C++中悬垂引用(DanglingReference)的实现》C++中的悬垂引用指引用绑定的对象被销毁后引用仍存在的情况,会导致访问无效内存,下面就来详细的介绍一下产生的原因以及如何避免,感兴趣... 目录悬垂引用的产生原因1. 引用绑定到局部变量，变量超出作用域后销毁2. 引用绑定到动态分配的对象，对象
阅读更多...
SpringBoot基于注解实现数据库字段回填的完整方案

SpringBoot基于注解实现数据库字段回填的完整方案

《SpringBoot基于注解实现数据库字段回填的完整方案》这篇文章主要为大家详细介绍了SpringBoot如何基于注解实现数据库字段回填的相关方法,文中的示例代码讲解详细,感兴趣的小伙伴可以了解... 目录数据库表pom.XMLRelationFieldRelationFieldMapping基础的一些代
阅读更多...
一篇文章彻底搞懂macOS如何决定java环境

一篇文章彻底搞懂macOS如何决定java环境

《一篇文章彻底搞懂macOS如何决定java环境》MacOS作为一个功能强大的操作系统,为开发者提供了丰富的开发工具和框架,下面：本文主要介绍macOS如何决定java环境的相关资料,文中通过代码... 目录方法一：使用 which命令方法二：使用 Java_home工具（Apple 官方推荐）那问题来了，
阅读更多...
Java HashMap的底层实现原理深度解析

Java HashMap的底层实现原理深度解析

《JavaHashMap的底层实现原理深度解析》HashMap基于数组+链表+红黑树结构,通过哈希算法和扩容机制优化性能,负载因子与树化阈值平衡效率,是Java开发必备的高效数据结构,本文给大家介绍... 目录一、概述：HashMap的宏观结构二、核心数据结构解析1. 数组（桶数组）2. 链表节点（Node
阅读更多...
Java AOP面向切面编程的概念和实现方式

Java AOP面向切面编程的概念和实现方式

《JavaAOP面向切面编程的概念和实现方式》AOP是面向切面编程,通过动态代理将横切关注点（如日志、事务）与核心业务逻辑分离,提升代码复用性和可维护性,本文给大家介绍JavaAOP面向切面编程的概... 目录一、AOP 是什么？二、AOP 的核心概念与实现方式核心概念实现方式三、Spring AOP 的关
阅读更多...
详解SpringBoot+Ehcache使用示例

详解SpringBoot+Ehcache使用示例

《详解SpringBoot+Ehcache使用示例》本文介绍了SpringBoot中配置Ehcache、自定义get/set方式,并实际使用缓存的过程,文中通过示例代码介绍的非常详细,对大家的学习或者... 目录摘要概念内存与磁盘持久化存储：配置灵活性：编码示例引入依赖：配置ehcache.XML文件：配置
阅读更多...
Java 虚拟线程的创建与使用深度解析

Java 虚拟线程的创建与使用深度解析

《Java虚拟线程的创建与使用深度解析》虚拟线程是Java19中以预览特性形式引入,Java21起正式发布的轻量级线程,本文给大家介绍Java虚拟线程的创建与使用,感兴趣的朋友一起看看吧... 目录一、虚拟线程简介1.1 什么是虚拟线程？1.2 为什么需要虚拟线程？二、虚拟线程与平台线程对比代码对比示例：三
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2