Spring HttpInvoke远程调用服务

Spring HttpInvoke实现和效率提升

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

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

/**
 * @author <a href="mailto:[e-mail]">梁栋</a>
 * @since 1.0
 */
public interface UserService {

    /**
     * 获得用户
     *
     * @param username
     *            用户名
     * @return
     */
    User getUser(String username);
}

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

/**
 * @author <a href="mailto:[e-mail]">梁栋</a>
 * @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实现： 

/**
 * @author <a href="mailto:[e-mail]">梁栋</a>
 * @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 

<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，定义具体的实现类！ 

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

熟悉serviceInterface指向需要暴露的接口，注意使用value标注接口名称！ 

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

最后再看service-servlet.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/ 
 
这就说明，服务器端配置已经成功了！如果在日志中频繁得到这种异常，那很可能服务器被恶意访问了！ 
再看客户端实现： 

/**
 * @author <a href="mailto:[e-mail]">梁栋</a>
 * @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： 

<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就行！ 

<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！ 

<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版本中，已不支持如下配置，相应的方法已经废弃！ 

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

如果仔细看看文档， 

引用

HttpClient that uses a default MultiThreadedHttpConnectionManager.

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

<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中配置  

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>