Spring集成JMS（二）.

最新推荐文章于 2020-09-17 10:58:23 发布
最新推荐文章于 2020-09-17 10:58:23 发布
阅读量691 收藏
点赞数
分类专栏： jms

一.：要在spring下集成ActiveMQ，那么就需要将jar包导入项目，所需jar包如下：

这些jar包来自“apache-activemq-5.6.0\lib”中。

二：相关的实例

1.实例--1

1）：.配置Spring与ActiveMQ的配置文件：

[html] view plain copy print ?
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
  5.         http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
  6.         http://www.springframework.org/schema/context   
  7.         http://www.springframework.org/schema/context/spring-context-2.5.xsd"  
  8.     default-autowire="byName">  
  9.       
  10.     <!-- 配置connectionFactory -->  
  11.     <bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory"  
  12.         destroy-method="stop">  
  13.         <property name="connectionFactory">  
  14.             <bean class="org.apache.activemq.ActiveMQConnectionFactory">  
  15.                 <property name="brokerURL">  
  16.                     <value>tcp://127.0.0.1:61616</value>  
  17.                 </property>  
  18.             </bean>  
  19.         </property>  
  20.         <property name="maxConnections" value="100"></property>  
  21.     </bean>  
  22.   
  23.     <!-- Spring JMS Template -->  
  24.     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
  25.         <property name="connectionFactory">  
  26.             <ref local="jmsFactory" />  
  27.         </property>  
  28.         <property name="defaultDestinationName" value="subject" />  
  29.         <!-- 区别它采用的模式为false是p2p为true是订阅 -->  
  30.         <property name="pubSubDomain" value="true" />  
  31.     </bean>  
  32.   
  33.     <!-- 发送消息的目的地（一个Topic） -->  
  34.     <bean id="destination" class="org.apache.activemq.command.ActiveMQTopic">  
  35.         <!-- 设置消息队列的名字 -->  
  36.         <constructor-arg index="0" value="subject" />  
  37.     </bean>  
  38.     <bean id="messageReceiver" class="com.pwc.spring.jms.example.JMSReceiver">  
  39.         <property name="jmsTemplate" ref="jmsTemplate"></property>  
  40.     </bean>  
  41.       
  42. </beans>  
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-2.5.xsd"
    default-autowire="byName">
    
    <!-- 配置connectionFactory -->
    <bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory"
        destroy-method="stop">
        <property name="connectionFactory">
            <bean class="org.apache.activemq.ActiveMQConnectionFactory">
                <property name="brokerURL">
                    <value>tcp://127.0.0.1:61616</value>
                </property>
            </bean>
        </property>
        <property name="maxConnections" value="100"></property>
    </bean>

    <!-- Spring JMS Template -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory">
            <ref local="jmsFactory" />
        </property>
        <property name="defaultDestinationName" value="subject" />
        <!-- 区别它采用的模式为false是p2p为true是订阅 -->
        <property name="pubSubDomain" value="true" />
    </bean>

    <!-- 发送消息的目的地（一个Topic） -->
    <bean id="destination" class="org.apache.activemq.command.ActiveMQTopic">
        <!-- 设置消息队列的名字 -->
        <constructor-arg index="0" value="subject" />
    </bean>
    <bean id="messageReceiver" class="com.pwc.spring.jms.example.JMSReceiver">
        <property name="jmsTemplate" ref="jmsTemplate"></property>
    </bean>
    
</beans>
2）：.消息的发送者：

[java] view plain copy print ?
  1. package com.pwc.spring.jms.example;  
  2.   
  3. import javax.jms.Destination;  
  4. import javax.jms.JMSException;  
  5. import javax.jms.Message;  
  6. import javax.jms.Session;  
  7.   
  8. import org.springframework.context.ApplicationContext;  
  9. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  10. import org.springframework.jms.core.JmsTemplate;  
  11. import org.springframework.jms.core.MessageCreator;  
  12.   
  13. public class JMSSender {  
  14.   
  15.     /** 
  16.      * @param args 
  17.      */  
  18.     public static void main(String[] args) {  
  19.         // TODO Auto-generated method stub   
  20.         ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext-jms.xml");  
  21.         JmsTemplate template=(JmsTemplate)applicationContext.getBean("jmsTemplate");  
  22.         Destination destination=(Destination)applicationContext.getBean("destination");  
  23.         template.send(destination, new MessageCreator(){  
  24.   
  25.             @Override  
  26.             public Message createMessage(Session session) throws JMSException {  
  27.                 // TODO Auto-generated method stub   
  28.                 return session.createTextMessage("Send Message:Hello ActiveMQ Text Message!");  
  29.             }  
  30.               
  31.         });  
  32.         System.out.println("Send the JMS Message Successfully!");  
  33.     }  
  34.   
  35. }  
package com.pwc.spring.jms.example;

import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

public class JMSSender {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext-jms.xml");
		JmsTemplate template=(JmsTemplate)applicationContext.getBean("jmsTemplate");
		Destination destination=(Destination)applicationContext.getBean("destination");
		template.send(destination, new MessageCreator(){

			@Override
			public Message createMessage(Session session) throws JMSException {
				// TODO Auto-generated method stub
				return session.createTextMessage("Send Message:Hello ActiveMQ Text Message!");
			}
			
		});
		System.out.println("Send the JMS Message Successfully!");
	}

}
3）：.消息的接收者：

A：消息接收的入口：

[java] view plain copy print ?
  1. package com.pwc.spring.jms.example;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class JMSReceiverMain {  
  7.   
  8.     /** 
  9.      * @param args 
  10.      */  
  11.     public static void main(String[] args) {  
  12.         // TODO Auto-generated method stub   
  13.         ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext-jms.xml");  
  14.         JMSReceiver proxyJMSConsumer=(JMSReceiver)applicationContext.getBean("messageReceiver");  
  15.         proxyJMSConsumer.receive();  
  16.         System.out.println("Initial Consumer End! ");  
  17.     }  
  18.   
  19. }  
package com.pwc.spring.jms.example;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class JMSReceiverMain {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext-jms.xml");
		JMSReceiver proxyJMSConsumer=(JMSReceiver)applicationContext.getBean("messageReceiver");
		proxyJMSConsumer.receive();
		System.out.println("Initial Consumer End! ");
	}

}
B：消息接收的具体方法：

[java] view plain copy print ?
  1. package com.pwc.spring.jms.example;  
  2.   
  3. import javax.jms.Destination;  
  4. import javax.jms.JMSException;  
  5. import javax.jms.TextMessage;  
  6.   
  7. import org.springframework.context.ApplicationContext;  
  8. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  9. import org.springframework.jms.JmsException;  
  10. import org.springframework.jms.core.JmsTemplate;  
  11.   
  12. public class JMSReceiver {  
  13.   
  14.     public JMSReceiver(){  
  15.           
  16.     }  
  17.     private JmsTemplate jmsTemplate;  
  18.     public JmsTemplate getJmsTemplate() {  
  19.         return jmsTemplate;  
  20.     }  
  21.     public void setJmsTemplate(JmsTemplate jmsTemplate) {  
  22.         this.jmsTemplate = jmsTemplate;  
  23.     }  
  24.       
  25.     public void receive(){  
  26.         ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext-jms.xml");  
  27.         Destination destination=(Destination)applicationContext.getBean("destination");  
  28.         while(true){  
  29.             try {  
  30.                 TextMessage txtmsg=(TextMessage)jmsTemplate.receive(destination);  
  31.                 if(null!=txtmsg){  
  32.                     System.out.println("DB Proxy: "+txtmsg);  
  33.                     System.out.println("DB Proxy Message: "+txtmsg.getText());  
  34.                 }else{  
  35.                                    break;  
  36.                                 }  
  37.             } catch (JmsException e) {  
  38.                 e.printStackTrace();  
  39.             } catch (JMSException e) {  
  40.                 e.printStackTrace();  
  41.             }  
  42.         }  
  43.     }  
  44. }  
package com.pwc.spring.jms.example;

import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.TextMessage;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.JmsException;
import org.springframework.jms.core.JmsTemplate;

public class JMSReceiver {

	public JMSReceiver(){
		
	}
	private JmsTemplate jmsTemplate;
	public JmsTemplate getJmsTemplate() {
		return jmsTemplate;
	}
	public void setJmsTemplate(JmsTemplate jmsTemplate) {
		this.jmsTemplate = jmsTemplate;
	}
	
	public void receive(){
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext-jms.xml");
		Destination destination=(Destination)applicationContext.getBean("destination");
		while(true){
			try {
				TextMessage txtmsg=(TextMessage)jmsTemplate.receive(destination);
				if(null!=txtmsg){
					System.out.println("DB Proxy: "+txtmsg);
					System.out.println("DB Proxy Message: "+txtmsg.getText());
				}else{
                                   break;
                                }
			} catch (JmsException e) {
				e.printStackTrace();
			} catch (JMSException e) {
				e.printStackTrace();
			}
		}
	}
}
先运行消息的接收者，再运行消息的发送者；

运行结果：


2. 实例--2

1）Spring与ActiveMQ配置文件信息：

[html] view plain copy print ?
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans  
  3.     xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  6.       
  7.     http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">  
  8.     <!--创建连接工厂-->  
  9.     <bean id="connectionFactory"  
  10.         class="org.apache.activemq.ActiveMQConnectionFactory">  
  11.         <property name="brokerURL" value="tcp://localhost:61616"></property>  
  12.     </bean>  
  13.     <!-- 声明ActiveMQ消息目标,目标可以是一个队列，也可以是一个主题ActiveMQTopic-->  
  14.     <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">  
  15.         <constructor-arg index="0" value="springactivemq"></constructor-arg>  
  16.     </bean>  
  17.     <!---->  
  18.     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
  19.         <property name="connectionFactory" ref="connectionFactory"></property>  
  20.         <property name="defaultDestination" ref="destination"></property>  
  21.         <property name="receiveTimeout" value="600"></property>  
  22.   
  23.     </bean>  
  24.     <bean id="sender" class="com.pwc.spring.jms.further.Sender">  
  25.         <property name="jmsTemplate" ref="jmsTemplate"></property>  
  26.   
  27.     </bean>  
  28.     <bean id="receiver" class="com.pwc.spring.jms.further.Receiver">  
  29.         <property name="jmsTemplate" ref="jmsTemplate"></property>  
  30.     </bean>  
  31. </beans>  
<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    
    http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
    <!--创建连接工厂-->
    <bean id="connectionFactory"
        class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL" value="tcp://localhost:61616"></property>
    </bean>
    <!-- 声明ActiveMQ消息目标,目标可以是一个队列，也可以是一个主题ActiveMQTopic-->
    <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg index="0" value="springactivemq"></constructor-arg>
    </bean>
    <!---->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="connectionFactory"></property>
        <property name="defaultDestination" ref="destination"></property>
        <property name="receiveTimeout" value="600"></property>

    </bean>
    <bean id="sender" class="com.pwc.spring.jms.further.Sender">
        <property name="jmsTemplate" ref="jmsTemplate"></property>

    </bean>
    <bean id="receiver" class="com.pwc.spring.jms.further.Receiver">
        <property name="jmsTemplate" ref="jmsTemplate"></property>
    </bean>
</beans>
2. 发送者发送消息

A：发送消息的入口

[java] view plain copy print ?
  1. package com.pwc.spring.jms.further;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class SenderMain {  
  7.   
  8.     /** 
  9.      * @param args 
  10.      */  
  11.     public static void main(String[] args) {  
  12.         // TODO Auto-generated method stub   
  13.         ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");  
  14.         Sender sender=(Sender)context.getBean("sender");  
  15.         sender.sendInfo();  
  16.     }  
  17.   
  18. }  
package com.pwc.spring.jms.further;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SenderMain {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
		Sender sender=(Sender)context.getBean("sender");
		sender.sendInfo();
	}

}
B：发送消息的具体方法

[java] view plain copy print ?
  1. package com.pwc.spring.jms.further;  
  2.   
  3. import javax.jms.JMSException;  
  4. import javax.jms.MapMessage;  
  5. import javax.jms.Message;  
  6. import javax.jms.Session;  
  7.   
  8. import org.springframework.jms.core.JmsTemplate;  
  9. import org.springframework.jms.core.MessageCreator;  
  10.   
  11. public class Sender {  
  12.   
  13.     private JmsTemplate jmsTemplate;  
  14.   
  15.     public JmsTemplate getJmsTemplate() {  
  16.         return jmsTemplate;  
  17.     }  
  18.   
  19.     public void setJmsTemplate(JmsTemplate jmsTemplate) {  
  20.         this.jmsTemplate = jmsTemplate;  
  21.     }  
  22.       
  23.     public void sendInfo(){  
  24.         jmsTemplate.send(new MessageCreator(){  
  25.   
  26.             @Override  
  27.             public Message createMessage(Session session) throws JMSException {  
  28.                 MapMessage message=session.createMapMessage();  
  29.                 message.setString("lastName", "Leio");  
  30.                 return message;  
  31.             }  
  32.               
  33.         });  
  34.     }  
  35. }  
package com.pwc.spring.jms.further;

import javax.jms.JMSException;
import javax.jms.MapMessage;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

public class Sender {

	private JmsTemplate jmsTemplate;

	public JmsTemplate getJmsTemplate() {
		return jmsTemplate;
	}

	public void setJmsTemplate(JmsTemplate jmsTemplate) {
		this.jmsTemplate = jmsTemplate;
	}
	
	public void sendInfo(){
		jmsTemplate.send(new MessageCreator(){

			@Override
			public Message createMessage(Session session) throws JMSException {
				MapMessage message=session.createMapMessage();
				message.setString("lastName", "Leio");
				return message;
			}
			
		});
	}
}
3. 接收者接收消息

A：接收消息入口：

[java] view plain copy print ?
  1. package com.pwc.spring.jms.further;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class ReceiverMain {  
  7.   
  8.     /** 
  9.      * @param args 
  10.      */  
  11.     public static void main(String[] args) {  
  12.         // TODO Auto-generated method stub   
  13.         ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");  
  14.         Receiver receiver=(Receiver) context.getBean("receiver");  
  15.         System.out.println(receiver.receiveMessage());  
  16.     }  
  17.   
  18. }  
package com.pwc.spring.jms.further;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ReceiverMain {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
		Receiver receiver=(Receiver) context.getBean("receiver");
		System.out.println(receiver.receiveMessage());
	}

}
B：接收消息方法：

[java] view plain copy print ?
  1. package com.pwc.spring.jms.further;  
  2.   
  3. import javax.jms.JMSException;  
  4. import javax.jms.MapMessage;  
  5.   
  6. import org.springframework.jms.core.JmsTemplate;  
  7.   
  8. public class Receiver {  
  9.   
  10.     private JmsTemplate jmsTemplate;  
  11.   
  12.     public JmsTemplate getJmsTemplate() {  
  13.         return jmsTemplate;  
  14.     }  
  15.   
  16.     public void setJmsTemplate(JmsTemplate jmsTemplate) {  
  17.         this.jmsTemplate = jmsTemplate;  
  18.     }  
  19.     public Receiver(){  
  20.           
  21.     }  
  22.     public String receiveMessage(){  
  23.         String receiveMessage="";  
  24.         MapMessage message=(MapMessage)jmsTemplate.receive();  
  25.         try {  
  26.             receiveMessage=message.getString("lastName");  
  27.         } catch (JMSException e) {  
  28.             e.printStackTrace();  
  29.         }  
  30.         return receiveMessage;  
  31.     }  
  32. }  
package com.pwc.spring.jms.further;

import javax.jms.JMSException;
import javax.jms.MapMessage;

import org.springframework.jms.core.JmsTemplate;

public class Receiver {

	private JmsTemplate jmsTemplate;

	public JmsTemplate getJmsTemplate() {
		return jmsTemplate;
	}

	public void setJmsTemplate(JmsTemplate jmsTemplate) {
		this.jmsTemplate = jmsTemplate;
	}
	public Receiver(){
		
	}
	public String receiveMessage(){
		String receiveMessage="";
		MapMessage message=(MapMessage)jmsTemplate.receive();
		try {
			receiveMessage=message.getString("lastName");
		} catch (JMSException e) {
			e.printStackTrace();
		}
		return receiveMessage;
	}
}
先运行发送者，再运行接收者，结果如下：


zhengbo0
关注
专栏目录
Spring集成ActiveMQ配置.docx
09-13
<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"> 在上面的配置文件中，我们首先配置了 connectionFactory，然后配置了 Spring JMS Template。connectionFactory 是用于连接 ...
JMS学习十（Spring+ActiveMQ同步、异步）
qq1620851849的博客
04-19 385
通过前面的九篇我们了解了JMS(ActiveMQ)，接下来这篇文章我们来看看spring中使用ActiveMQ,但通过资料，demo的查找以及整合实例的使用个人感觉spring和activemq整合使用确实不是很好，很方便！spring中使用activemq我们从如下几个步骤来学习：1、spring+activemq的同步消息接收（queue+topic）2、spring+activemq的异步消...
JMS消息传输机制
lipc_的博客
10-04 2721
JMS消息传送模型: 　　消息传送机制, 是基于拉取(pull)或者轮询(polling)的方式.    JMS具备两种"消息传送模型": P2P和Pub/sub.  (1) P2P：点对点消息传送模型, 允许JMS客户端通过队列(queue)这个虚拟通道来同步或异步发送消息; 消息的生产者为Sender, 消费者为receiver. 　　　　   receiver主
ActiveMQ之三--JMS-Spring和ActiveMQ整合的完整实例
weixin_34220834的博客
09-05 782
前言 这篇博文,我们基于Spring+JMS+ActiveMQ+Tomcat，做一个Spring4.1.0和ActiveMQ5.11.1整合实例，实现了Point-To-Point的异步队列消息和PUB/SUB（发布/订阅）模型，简单实例，不包含任何业务。 环境准备 工具 JDK1.6或1.7 Spring4.1.0 ActiveMQ5.11.1 ...
Spring集成ActiveMQ
weixin_33701294的博客
01-16 226
准备工作从下面官网下载ActiveMQ，本文使用5.7版本，写博时Maven库能找到的最高版本为5.7http://activemq.apache.org/download-archives.html解压缩下载的文件到你希望安装的目录进入bin目录运行activemq.bat以启动ActiveMQ服务，启动后默认broker URL : tcp://localhost:616...
Spring整合JMS——三种connectionFactory
s296850101的专栏
08-30 1万+
1、SingleConnectionFactory：对于建立JMS服务器链接的请求会一直返回同一个链接，并且会忽略Connection的close方法调用。(org.springframework.jms.connection.SingleConnectionFactory) 2、CachingConnectionFactory：继承了SingleConnectionFactory，所以它拥有S
spring集成JMS
05-10
Spring集成JMS提供了丰富的功能和便利的API，降低了开发复杂性，使得开发者能够专注于业务逻辑，而不是底层的消息传递细节。通过使用Spring JMS，你可以构建高度可扩展和可靠的分布式系统，实现高效的消息通信。
jms.rar_weblogic8 spring jms
09-14
总的来说，"jms.rar_weblogic8_spring_jms"这个主题涉及的是在Spring框架下使用JMS与WebLogic 8.1集成的技术。它涵盖了从JMS服务的配置、消息模板的定义，到消息的生产和消费，以及可能的数据持久化配合。这种集成...
spring-jms-4.3.4.RELEASE.zip
10-10
综上所述，Spring JMS 4.3.4.RELEASE为开发者提供了一套完整的JMS集成方案，通过抽象和封装JMS API，使得消息处理更加简单且易于维护。配合Spring Framework的其他模块，如Spring JDBC、Spring AOP等，可以构建出...
Spring集成JMS
02-10
Spring集成JMS是Java消息服务（Java Message Service）与Spring框架的结合，它提供了一种在分布式系统中高效处理异步消息传递的方式。Spring通过其强大的IoC（Inversion of Control，控制反转）和AOP（Aspect ...
activemq-jms-pool-5.9.0.jar
07-18
标签:activemq-jms-pool-5.9.0.jar,activemq,jms,pool,5.9.0,jar包下载,依赖包
JMS学习(4):--Spring和ActiveMQ整合的完整实例
jianfpeng241241的专栏
06-15 3598
前言 这篇博文,我们基于spring+JMS+ActiveMQ+Tomcat，做一个Spring4.1.0和ActiveMQ5.11.1整合实例，实现了Point-To-Point的异步队列消息和PUB/SUB（发布/订阅）模型，简单实例，不包含任何业务。 环境准备 工具 JDK1.6或1.7 Spring4.1.0 ActiveMQ5.
Tomcat配置JNDI资源(数据源，JMSFactory)
日蚀
08-02 2747
tomcat中通过JNDI数据源配置使用 一、数据源简介： 在Java语言中，DataSource对象就是一个代表数据源实体的对象。一个数据源就是一个用来存储数据的工具，它可以是复杂的大型企业级数据库，也可以是简单得只有行和列的文件。数据源
同时消费队列和发布订阅两类型消息
海锋博客
01-07 4801
在《实现生产者P2P&subpub兼容模式》中实现了生产者两种消息类型的兼容模式，在消费者中对于单应用同样有这样的需求，我们需要能够在一个应用内同时消费队列和发布订阅两个类型的消息。 本章概要 1、回顾； 2、编码； 3、验证； 回顾 在springboot下，目前我们切换队列和发布订阅模式均通过spring.jms.pub-sub-domain属性配置。《实现
activemq集合JMS处理异步消息
newersky的专栏
07-19 4344
Jms 发送 代码： publicstaticvoidmain(String[]args)throwsException{ ConnectionFactoryconnectionFactory=newActiveMQConnectionFactory(); Connectionconnection=connectionFactory...
JMS两种消息方式
mao1059568684的专栏
11-08 1388
JMS的消息模式有1.点对点的消息模式(Point to Point Messaging) 2.发布订阅模式(publish – subscribe Mode) 这里基于点对点的消息模式进行ActiveMQ发消息和收消息过程的分析，请看模型图： 点对点的消息发送方式主要建立在 Message Queue,Sender,reciever上，Message Queue 存贮消
使用JMS进行消息传递
我弟是个程序员
06-12 6811
你需要什么 大约 15 分钟 IntelliJ IDEA或其他编辑器 JDK 1.8或更高版本 Maven 3.2+ 你会建立什么 本指南将指导您完成使用 JMS 代理发布和订阅消息的过程。您将构建一个应用程序，该应用程序使用Spring的 JmsTemplate 发布单个消息并使用托管 bean 的 @JmsListener 注释方法订阅该消息。 构建步骤 1、添加maven依...
spring整合JMS一同步收发消息(基于ActiveMQ的实现)
热门推荐
牛奋lch
07-28 1万+
1. 安装ActiveMQ 到Apache官方网站下载最新的ActiveMQ的安装包，并解压到本地目录下，下载链接如下：http://activemq.apache.org/download.html，解压后的目录结构如下： bin目录结构如下： 如果我们是32位的机器，就双击win32目录下的activemq.bat,如果是64位机器，则双击
ActiveMQ 基础到进阶 && 高级面试
村里的原振侠的博客
09-17 598
activemq查漏补缺 基础 带日志自定义启动 ./activemq start > /myactiveMQ/run_time.log 注意如果启动不了amq，有一种原因是：linux机器名带有下滑线_，腾讯云服务器也会带下划线，会在日志中报错。 activemq图解 通过ConnectionFactory获取connection，connection生成Session，然后session可以生成Message，MessageProducer和MessageConsumer。 消费者 一个生产者
SpringJMS客户端示例：使用Spring集成ActiveMQ
本资源是一份关于使用Spring框架与Apache ActiveMQ集成的详细教程，主要关注于运行SpringJMS客户端示例程序。标题"运行SpringJMS客户端示例程序-iec 61131-8"表明该内容涉及到Spring框架在Java消息服务（JMS）中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值