Spring HttpInvoke实现，以及效率提升！

最新推荐文章于 2023-05-11 23:05:12 发布

choulv4873

最新推荐文章于 2023-05-11 23:05:12 发布

阅读量485

点赞数

文章标签： java

原文链接：https://my.oschina.net/mohaiyong/blog/221248

版权

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

/**
 * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
 * @since 1.0
 */
public interface UserService {

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

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

/**
 * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</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:zlex.dongliang@gmail.com">梁栋</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
 class="org.zlex.spring.httpinvoke.service.impl.UserServiceImpl" />
		</property>

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

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

最后再看servlet.xml配置

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

直接将请求指向刚才配置的userService
现在我们之间访问一下http://localhost:8080/spring/service/

这就说明，服务器端配置已经成功了！如果在日志中频繁得到这种异常，那很可能服务器被恶意访问了！
再看客户端实现：

/**
 * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</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" />
		<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;

技高一筹！
赶紧记下来，供大家参考！
详情见附件！
许久没写博客了，今天终于舒展了一把！

转载于:https://my.oschina.net/mohaiyong/blog/221248

choulv4873

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring HttpInvoke实现，以及效率提升！

我也顺道整理一下Spring HttpInvoke——那曾经最为熟悉的东西。 Spring HttpInvoke，一种较为常用的、基于Spring架构的服务器之间的远程调用实现，可以说是轻量级的RMI。最初，我们使用Spring HttpInvoke同步配置数据，刷新多个服务器上的缓存，...
复制链接

扫一扫