WebService学习(八)——利用websevice接口封装activemq的生产者，并监听到消息

转载 于 2019-01-23 14:54:31 发布 · 536 阅读 · 1
文章标签：

#Java

本文详细介绍了如何使用MyEclipse生成基于JAX-WS的接口，并实现通过WebService访问WSDL。进一步，文章深入探讨了如何在接口操作中集成消息队列，包括查询、增删改等操作，通过UserService类与消息队列的交互，实现了数据的异步处理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

本系列第五篇，利用myeclipse生成基于jax-ws的接口，并能成功访问wsdl后，接下其他操作

1.service接口：

  1. /**
  2.  * 用于外部系统调用接口
  3.  * 
  4.  * @author Administrator
  5.  * 
  6.  */
  7. public interface IUserService {
  8.  
  9. 	public Users getUsersByUserCode(String userCode);
  10.  
  11. 	public Users selectByPrimaryKey(Integer id);
  12.  
  13. 	public int deleteByPrimaryKey(Integer id);
  14.  
  15. 	public int insert(Users record);
  16.  
  17. 	public int insertSelective(Users record);
  18.  
  19. 	public int updateByPrimaryKeySelective(Users record);
  20.  
  21. 	public int updateByPrimaryKey(Users record);
  22.  
  23. }

2.UserService类代码

  1. /**
  2.  * 用户信息操作服务
  3.  */
  4. @Service
  5. public class UserService implements IUserService {
  6. 	private UsersDao usersDao;
  7. 	
  8. 	@Resource
  9. 	private ProducerServiceUser producerServiceUser;
  10. 	
  11. 	@Resource(name = "userQueueDestination")
  12. 	private Destination destination;
  13.  
  14. 	//查询方法
  15. 	public Users getUsersByUserCode(String userCode) {
  16. 		return usersDao.getUsersByUserCode(userCode);
  17. 	}
  18.  
  19. 	public Users selectByPrimaryKey(Integer id) {
  20. 		return usersDao.selectByPrimaryKey(id);
  21. 	}
  22.  
  23. 	// 增删改的方法，都需要向消息队列中发送数据
  24. 	/**
  25. 	 * 删除方法，对外暴露接口
  26. 	 * 
  27. 	 * @param id
  28. 	 */	
  29. 	public void deleteByPrimaryKeyPort(Integer id) {
  30. 		// 将传入的参数放入队列中
  31. 		StringBuffer buf = new StringBuffer();
  32. 		buf.append(Constant.DATA_DELETE);
  33. 		buf.append(":");
  34. 		buf.append(String.valueOf(id));
  35. 		// 调用对应的生产者的sendMessage方法，向队列发送消息
  36. 		producerServiceUser.sendMessage(destination, buf.toString());
  37. 	}
  38.  
  39. 	public int deleteByPrimaryKey(Integer id) {
  40. 		return usersDao.deleteByPrimaryKey(id);
  41. 	}
  42.  
  43. 	/**
  44. 	 * 添加方法，对外暴露接口
  45. 	 * 
  46. 	 * @param id
  47. 	 */
  48.  
  49. 	public void insertPort(Users record) {
  50. 		// 将传入的参数放入队列中
  51. 		StringBuffer buf = new StringBuffer();
  52. 		buf.append(Constant.DATA_INSERT);
  53. 		buf.append(":");
  54. 		buf.append(String.valueOf(record.toString()));
  55. 		// 调用对应的生产者的sendMessage方法，向队列发送消息
  56. 		producerServiceUser.sendMessage(destination, buf.toString());
  57. 	}
  58.  
  59. 	public int insert(Users record) {
  60. 		return usersDao.insert(record);
  61. 	}
  62.  
  63. 	/**
  64. 	 * 添加方法，对外暴露接口
  65. 	 * 
  66. 	 * @param id
  67. 	 */
  68. 	public void insertSelectivePort(Users record) {
  69. 		// 将传入的参数放入队列中
  70. 		StringBuffer buf = new StringBuffer();
  71. 		buf.append(Constant.DATA_INSERT);
  72. 		buf.append(":");
  73. 		buf.append(String.valueOf(record.toString()));
  74. 		// 调用对应的生产者的sendMessage方法，向队列发送消息
  75. 		producerServiceUser.sendMessage(destination, buf.toString());
  76. 	}
  77.  
  78. 	public int insertSelective(Users record) {
  79. 		return usersDao.insertSelective(record);
  80. 	}
  81.  
  82. 	/**
  83. 	 * 更新方法，对外暴露接口
  84. 	 * 
  85. 	 * @param id
  86. 	 */
  87.  
  88. 	public void updateByPrimaryKeySelectivePort(Users record) {
  89. 		// 将传入的参数放入队列中
  90. 		StringBuffer buf = new StringBuffer();
  91. 		buf.append(Constant.DATA_UPDATE);
  92. 		buf.append(":");
  93. 		buf.append(String.valueOf(record.toString()));
  94. 		// 调用对应的生产者的sendMessage方法，向队列发送消息
  95. 		producerServiceUser.sendMessage(destination, buf.toString());
  96. 	}
  97.  
  98. 	public int updateByPrimaryKeySelective(Users record) {
  99. 		return usersDao.updateByPrimaryKeySelective(record);
  100. 	}
  101.  
  102. 	/**
  103. 	 * 更新方法，对外暴露接口
  104. 	 * 
  105. 	 * @param id
  106. 	 */
  107.  
  108. 	public void updateByPrimaryKeyPort(Users record) {
  109. 		// 将传入的参数放入队列中
  110. 		StringBuffer buf = new StringBuffer();
  111. 		buf.append(Constant.DATA_UPDATE);
  112. 		buf.append(":");
  113. 		buf.append(String.valueOf(record.toString()));
  114. 		// 调用对应的生产者的sendMessage方法，向队列发送消息
  115. 		producerServiceUser.sendMessage(destination, buf.toString());
  116. 	}
  117.  
  118. 	public int updateByPrimaryKey(Users record) {
  119. 		return usersDao.updateByPrimaryKey(record);
  120. 	}
  121.  
  122. }

3.UserServiceDelegate类代码

  1. @javax.jws.WebService(targetNamespace = "http://impl.service.store.yundao.com/", serviceName = "UserServiceService", portName = "UserServicePort")
  2. public class UserServiceDelegate {
  3.  
  4. 	com.yundao.store.service.impl.UserService userService = new com.yundao.store.service.impl.UserService();
  5.  
  6. 	/**
  7. 	 * 对外暴露的接口
  8. 	 */
  9. 	public Users getUsersByUserCode(String userCode) {
  10. 		return userService.getUsersByUserCode(userCode);
  11. 	}
  12.  
  13. 	public Users selectByPrimaryKey(Integer id) {
  14. 		return userService.selectByPrimaryKey(id);
  15. 	}
  16.  
  17. 	/**
  18. 	 * 对外暴露的接口
  19. 	 */
  20. 	public void deleteByPrimaryKeyPort(Integer id) {
  21. 		userService.deleteByPrimaryKeyPort(id);
  22. 	}
  23.  
  24. 	@WebMethod(exclude = true)
  25. 	public int deleteByPrimaryKey(Integer id) {
  26. 		return userService.deleteByPrimaryKey(id);
  27. 	}
  28.  
  29. 	/**
  30. 	 * 对外暴露的接口
  31. 	 */
  32. 	public void insertPort(Users record) {
  33. 		userService.insertPort(record);
  34. 	}
  35.  
  36. 	@WebMethod(exclude = true)
  37. 	public int insert(Users record) {
  38. 		return userService.insert(record);
  39. 	}
  40.  
  41. 	/**
  42. 	 * 对外暴露的接口
  43. 	 */
  44. 	public void insertSelectivePort(Users record) {
  45. 		userService.insertSelectivePort(record);
  46. 	}
  47.  
  48. 	@WebMethod(exclude = true)
  49. 	public int insertSelective(Users record) {
  50. 		return userService.insertSelective(record);
  51. 	}
  52.  
  53. 	/**
  54. 	 * 对外暴露的接口
  55. 	 */
  56. 	public void updateByPrimaryKeySelectivePort(Users record) {
  57. 		userService.updateByPrimaryKeySelectivePort(record);
  58. 	}
  59.  
  60. 	@WebMethod(exclude = true)
  61. 	public int updateByPrimaryKeySelective(Users record) {
  62. 		return userService.updateByPrimaryKeySelective(record);
  63. 	}
  64.  
  65. 	/**
  66. 	 * 对外暴露的接口
  67. 	 */
  68. 	public void updateByPrimaryKeyPort(Users record) {
  69. 		userService.updateByPrimaryKeyPort(record);
  70. 	}
  71.  
  72. 	@WebMethod(exclude = true)
  73. 	public int updateByPrimaryKey(Users record) {
  74. 		return userService.updateByPrimaryKey(record);
  75. 	}
  76.  
  77. }

4.ProducerServiceUser类

  1. **
  2.  * 生产者服务类
  3.  * 
  4.  * @author  2018-3-26下午4:38:22
  5.  *         将消息生产者做成一个服务，当我们需要发送消息的时候，只需要调用ProducerService实例中的sendMessage
  6.  *         方法就可以向默认目的发送一个消息。
  7.  */
  8. @Service
  9. public class ProducerServiceUser {
  10. 	@Autowired
  11. 	private JmsTemplate jmsTemplate;
  12.  
  13. 	/**
  14. 	 * 向指定队列发送消息
  15. 	 */
  16. 	public void sendMessage(Destination destination, final String msg) {
  17. 		System.out.println(Thread.currentThread().getName() + " 向队列"
  18. 				+ destination.toString() + "发送消息---------------------->" + msg);
  19. 		jmsTemplate.send(destination, new MessageCreator() {
  20. 			public Message createMessage(Session session) throws JMSException {
  21. 				return session.createTextMessage(msg);
  22. 			}
  23. 		});
  24. 	}
  25.  
  26. 	/**
  27. 	 * 向默认队列发送消息
  28. 	 */
  29. 	public void sendMessage(final String msg) {
  30. 		String destination = jmsTemplate.getDefaultDestinationName();
  31. 		System.out.println(Thread.currentThread().getName() + " 向队列"
  32. 				+ destination + "发送消息---------------------->" + msg);
  33. 		jmsTemplate.send(new MessageCreator() {
  34. 			public Message createMessage(Session session) throws JMSException {
  35. 				return session.createTextMessage(msg);
  36. 			}
  37. 		});
  38. 	}
  39.  
  40. }

5.对应的生产者配置文件spring-activemq-producer.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2.  
  3. <beans xmlns="http://www.springframework.org/schema/beans"
  4. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
  5. 	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
  6. 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  7.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
  8.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
  9.     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
  10.  
  11. 	<!-- 生产者 -->
  12. 	<!-- 扫描activemq包 -->
  13. 	<context:component-scan base-package="com.yundao.store.activemq.*" />
  14.  
  15.  
  16. 	<!-- 1.ActiveMQ的连接工厂 -->
  17. 	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
  18. 		<property name="brokerURL" value="tcp://localhost:61616" />
  19. 	</bean>
  20.  
  21. 	<!-- 2.Spring Caching连接工厂 -->
  22. 	<bean id="connectionFactory"
  23. 		class="org.springframework.jms.connection.CachingConnectionFactory">
  24. 		<property name="targetConnectionFactory" ref="targetConnectionFactory"></property>
  25. 		<!-- Session缓存数量 -->
  26. 		<property name="sessionCacheSize" value="100" />
  27. 	</bean>
  28.  
  29. 	<!-- 3.1.定义用户消息队列（Queue） -->
  30. 	<bean id="userQueueDestination" class="org.apache.activemq.command.ActiveMQQueue">
  31. 		<!-- 设置消息队列的名字 -->
  32. 		<constructor-arg index="0" value="queue-user" />
  33. 	</bean>
  34. 	<!-- 3.2.定义日志消息队列（Queue） -->
  35. 	<bean id="logQueueDestination" class="org.apache.activemq.command.ActiveMQQueue">
  36.        <!-- 设置消息队列的名字 -->
  37. 		<constructor-arg index="0" value="queue-log" />
  38.     </bean>
  39.  
  40. 	<!-- 4.配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 -->
  41. 	<!-- 4.1.队列模板 -->
  42. 	<bean id="jmsQueueTemplate" class="org.springframework.jms.core.JmsTemplate">
  43. 		<property name="connectionFactory" ref="connectionFactory" />
  44. 		<property name="receiveTimeout" value="10000" />
  45. 	</bean>
  46.  
  47.  
  48. </beans>

6.对应的消费者配置文件spring-activemq-consumer.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2.  
  3. <beans xmlns="http://www.springframework.org/schema/beans"
  4. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
  5. 	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
  6. 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  7.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
  8.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
  9.     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
  10.  
  11. 	<!-- 消费者 -->
  12. 	<!-- 扫描activemq包 -->
  13. 	<context:component-scan base-package="com.yundao.store.activemq.*" />
  14.  
  15. 	<!-- 1.ActiveMQ的连接工厂 -->
  16. 	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
  17. 		<property name="brokerURL" value="tcp://localhost:61616" />
  18. 	</bean>
  19.  
  20. 	<!-- 2.Spring Caching连接工厂 -->
  21. 	<bean id="connectionFactory"
  22. 		class="org.springframework.jms.connection.CachingConnectionFactory">
  23. 		<property name="targetConnectionFactory" ref="targetConnectionFactory"></property>
  24. 		<!-- Session缓存数量 -->
  25. 		<property name="sessionCacheSize" value="100" />
  26. 	</bean>
  27.  
  28.  
  29.  
  30. 	<!-- 5.第一个消息监听器（Queue) -->
  31. 	<bean id="userQueueMessageListener"
  32. 		class="com.yundao.store.activemq.listener.userQueueMessageListener"></bean>
  33. 	<!-- 第二个消息监听器（Queue) -->
  34. 	<bean id="logQueueMessageListener"
  35. 		class="com.yundao.store.activemq.listener.logQueueMessageListener">
  36. 	</bean>
  37.  
  38. 	<!-- 6.第一个消息监听容器（Queue），配置连接工厂，监听的目标是demoQueueDestination，监听器是上面定义的监听器 --><!-- 自动获取 -->
  39. 	<bean id="sessionAwareListenerContainer01"
  40. 		class="org.springframework.jms.listener.DefaultMessageListenerContainer">
  41. 		<property name="connectionFactory" ref="connectionFactory" />
  42. 		<property name="destination" ref="userQueueDestination" />
  43. 		<property name="messageListener" ref="userQueueMessageListener" />
  44. 	</bean>
  45.  
  46. 	<!-- 6.第二个消息监听容器（Queue），配置连接工厂，监听的目标是demoQueueDestination，监听器是上面定义的监听器 --><!-- 自动获取 -->
  47. 	<bean id="sessionAwareListenerContainer02"
  48. 		class="org.springframework.jms.listener.DefaultMessageListenerContainer">
  49. 		<property name="connectionFactory" ref="connectionFactory" />
  50. 		<property name="destination" ref="logQueueDestination" />
  51. 		<property name="messageListener" ref="logQueueMessageListener" />
  52. 	</bean>
  53.  
  54.  
  55. </beans>

7.监听器的类

  1. **
  2.  * 配置消息队列监听者(实际项目中采用的是这种方式)
  3.  * 
  4.  * @author  2018-3-26下午4:46:44
  5.  */
  6. public class userQueueMessageListener implements MessageListener {
  7. 	private UserService userService;	
  8. 	// 当收到消息后，自动调用该方法
  9. 	@Override
  10. 	public void onMessage(Message message) {
  11. 		TextMessage tm = (TextMessage) message;
  12. 		try {
  13. 			System.out.println("userQueueMessageListener监听到了文本消息：\t" + tm.getText());
  14. 			//处理业务逻辑
  15. 		} catch (JMSException e) {
  16. 			e.printStackTrace();
  17. 		}
  18.  
  19. 	}
  20.  
  21. }

8.测试方法

  1. /**
  2. 	 * 用户登录
  3. 	 */
  4. 	public String login() {
  5. 		setUtfEncoding();
  6. 		String userCode = getRequest().getParameter("userCode");
  7. 		String password = getRequest().getParameter("password");
  8.  
  9. //		String param = "登录成功";
  10. //		producerServiceUser.sendMessage(destination, param);
  11. //
  12. //		String param1 = "日志成功";
  13. //		producerServiceLog.sendMessage(destination1, param1);
  14. 		int id=1;
  15. 		userService.deleteByPrimaryKeyPort(id);
  16. 		return SUCCESS;
  17. 	}

最后能成功监听到调用接口封装的方法传输过来的数据，真实的的接口调用，可以参考我soap调接口那篇

简单的记录下来，毕竟是自己做项目遇到的难点......

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值