欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

Spring HttpInvoke实现和效率提升 httptimeouthttp invokerjavaweb 

程序员文章站 2022-07-13 10:58:42
...
Spring HttpInvoke，一种较为常用的、基于Spring架构的服务器之间的远程调用实现，可以说是轻量级的RMI。
最初，我们使用Spring HttpInvoke同步配置数据，刷新多个服务器上的缓存，当然如果用分布式缓存是不是更好 ！
使用Spring HttpInvoke，你可以调用远程接口，进行数据交互、业务逻辑操作等等。
废话不说了，上代码！
用户操作接口：
Java代码 

    
/** 
     * @since 1.0 
     */  
    public interface UserService {  
      
        /** 
         * 获得用户 
         *  
        * @param username 
        *            用户名 
        * @return 
        */  
       User getUser(String username);  
   }



用户类，注意实现Serializable接口，这是执行远程调用传递数据对象的第一要求——数据对象必须实现Serializable接口，因为，要执行序列化/反序列化操作！
Java代码 

    
/** 
     * @since 1.0 
     */  
    public class User implements Serializable {  
      
        private static final long serialVersionUID = 5590768569302443813L;  
        private String username;  
        private Date birthday;  
     
       /** 
        * @param username 
        * @param birthday 
        */  
       public User(String username, Date birthday) {  
           this.username = username;  
           this.birthday = birthday;  
       }  
          // 省略  
       /* 
        * (non-Javadoc) 
        *  
        * @see java.lang.Object#toString() 
        */  
       @Override  
       public String toString() {  
           return String.format("%s\t%s\t", username, birthday);  
       }  
   }
 

覆盖toString()方法，输出用户信息！
再看UserServiceImpl实现：
Java代码 

    
/** 
     * @since 1.0 
     */  
    public class UserServiceImpl implements UserService {  
        private Logger logger = Logger.getLogger(UserServiceImpl.class);  
      
        /* 
         * (non-Javadoc) 
        *  
        * @see 
        * org.zlex.spring.httpinvoke.service.UserService#getUser(java.lang.String) 
        */  
       @Override  
       public User getUser(String username) {  
           if (logger.isDebugEnabled()) {  
               logger.debug("username:[" + username + "]");  
           }  
           User user = new User(username, new Date());  
           if (logger.isDebugEnabled()) {  
               logger.debug("user:[" + user + "]");  
           }  
           return user;  
       }  
     
   }



只把用户信息打出来即可说明调用效果！
看applicationContext.xml
Xml代码 

    
<bean  
        id="userService"  
    class="org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter">  
        <property  
            name="service">  
            <bean  
    class="org.zlex.spring.httpinvoke.service.impl.UserServiceImpl" />  
        </property>  
        <property  
           name="serviceInterface"  
           value="org.zlex.spring.httpinvoke.service.UserService" />  
   </bean>



我们要把userService暴露出去，这样外部就可以通过http接口调用这个接口的实现了。
说说HttpInvokerServiceExporter，这个类用来在服务器端包装需要暴露的接口。
属性service，定义具体的实现类！
Xml代码 

    
<property  
        name="service">  
        <bean  
    lass="org.zlex.spring.httpinvoke.service.impl.UserServiceImpl" />  
    </property>



属性serviceInterface指向需要暴露的接口，注意使用value标注接口名称！
Xml代码

    
<property  
        name="serviceInterface"  
        value="org.zlex.spring.httpinvoke.service.UserService" />



最后再看service-servlet.xml配置
Xml代码 

    
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">  
        <property  
            name="urlMap">  
            <map>  
                <entry  
                    key="userTest"  
                    value-ref="userService" />  
            </map>  
        </property>  
   </bean>



直接将请求指向刚才配置的userService
现在我们之间访问一下http://localhost:8080/spring/service/
[点击查看原始大小图片] 
这就说明，服务器端配置已经成功了！如果在日志中频繁得到这种异常，那很可能服务器被恶意访问了！
再看客户端实现：
Java代码 

    
/** 
     * @since 1.0 
     */  
    public class UserServiceTest {  
        private Logger logger = Logger.getLogger(UserServiceTest.class);  
        private ApplicationContext context;  
      
        private UserService userService;  
     
       @Before  
       public void initialize() {  
           context = new ClassPathXmlApplicationContext("applicationContext.xml");  
           userService = (UserService) context.getBean("userService");  
       }  
     
       @Test  
       public void getUser() {  
           User user = userService.getUser("zlex");  
           if (logger.isDebugEnabled()) {  
               logger.debug("user[" + user + "]");  
           }  
       }  
   }
 


我们做了什么？Nothing！就跟调用一般Spring容器中的实现一样！
再看applicationContext.xml：
Xml代码 

   
<bean  
        id="userService"  
    class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">  
        <property  
            name="serviceUrl"  
            value="http://localhost:8080/spring/service/userTest" />  
        <property  
            name="serviceInterface"  
            value="org.zlex.spring.httpinvoke.service.UserService" />  
   </bean>



这里我们可以通过Spring容器调用userService，而实际上，他是一个HttpInvokerProxyFactoryBean，在这个配置里，定义了访问地址serviceUrl，和访问接口serviceInterface。
执行测试！
[点击查看原始大小图片] 
如果我们这样写，其实默认调用了SimpleHttpInvokerRequestExecutor做实现，这个实现恐怕只能作为演示来用！
这也是效率问题所在！！！
为提高效率，应该通过Commons-HttpClient！
我们需要做什么？导入这个jar，改改xml就行！
Xml代码

    
<bean  
        id="userService"  
        class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">  
        <property  
            name="serviceUrl"  
            value="http://localhost:8080/spring/service" />  
        <property  
            name="serviceInterface"  
            value="org.zlex.spring.httpinvoke.service.UserService" />  
       <property  
           name="httpInvokerRequestExecutor">  
           <ref  
               bean="httpInvokerRequestExecutor" />  
       </property>  
   </bean>  
   <bean  
       id="httpInvokerRequestExecutor" class="org.springframework.remoting.httpinvoker.CommonsHttpInvokerRequestExecutor">  
       <property  
           name="httpClient">  
           <bean  
               class="org.apache.commons.httpclient.HttpClient">  
               <property  
                   name="connectionTimeout"  
                   value="2000" />  
               <property  
                   name="timeout"  
                   value="5000" />  
           </bean>  
       </property>  
   </bean>



通过HttpClient，我们可以配置超时时间timeout和连接超时connectionTimeout两个属性，这样，服务器执行操作时，如果超时就可以强行释放连接，这样可怜的tomcat不会因为HttpInvoke连接不释放而被累死！
回头看了一眼我N多年前的代码，万岁，我当时确实是这么实现的！好在没有犯低级错误！！！
执行操作！
[点击查看原始大小图片] 
这时，转为org.springframework.remoting.httpinvoker.CommonsHttpInvokerRequestExecutor实现了！
不过同事认为，这个效率还是不够高！！！
再改，改什么？还是xml！
Xml代码 

    
<bean  
            id="httpInvokerRequestExecutor"  
            class="org.springframework.remoting.httpinvoker.CommonsHttpInvokerRequestExecutor">  
            <property  
                name="httpClient">  
                <bean  
                    class="org.apache.commons.httpclient.HttpClient">  
                    <property  
                        name="connectionTimeout"  
                       value="2000" />  
                   <property  
                       name="timeout"  
                       value="5000" />  
                   <property  
                       name="httpConnectionManager">  
                       <ref  
                           bean="multiThreadedHttpConnectionManager" />  
                   </property>  
               </bean>  
           </property>  
       </bean>  
       <bean  
           id="multiThreadedHttpConnectionManager"  
           class="org.apache.commons.httpclient.MultiThreadedHttpConnectionManager">  
           <property  
               name="params">  
               <bean  
                   class="org.apache.commons.httpclient.params.HttpConnectionManagerParams">  
                   <property  
                       name="maxTotalConnections"  
                       value="600" />  
                   <property  
                       name="defaultMaxConnectionsPerHost"  
                       value="512" />  
               </bean>  
           </property>  
       </bean>
 

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

注意：在HttpClient的3.1版本中，已不支持如下配置，相应的方法已经废弃！
Xml代码 

    
<property    
        name="connectionTimeout"    
        value="2000" />    
    <property    
        name="timeout"    
        value="5000" />
  



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

commons 系列的实现怎么会不考虑多线程呢？人家默认实现就是多线程的！同事多虑了！
当然，同事还补充了一句，需要控制连接数！
难怪，这里要设置
Xml代码 

    
<bean  
      class="org.apache.commons.httpclient.params.HttpConnectionManagerParams">  
        <property  
            name="maxTotalConnections"  
            value="600" />  
        <property  
            name="defaultMaxConnectionsPerHost"  
            value="512" />  
    </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中配置  
<servlet>
	    <servlet-name>service</servlet-name>
	    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	    <load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
	    <servlet-name>service</servlet-name>
	    <url-pattern>/service/*</url-pattern>
	</servlet-mapping>
相关标签： http timeout http invoker java web

上一篇： 分布式锁、会话、事务等学习记要

下一篇： java中的线程停止

推荐阅读