ActiveMQ

最新推荐文章于 2024-04-12 22:51:51 发布
最新推荐文章于 2024-04-12 22:51:51 发布
阅读量826 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40405398/article/details/124543881
版权

ActiveMQ

官网地址：ActiveMQ (apache.org)

基础概念

JMS和AMQP

**JMS:**Java平台消息中间件 【消息生产者、queue队列、消息消费者】

AMQP:跨平台，【消息生产者、exchange交换机、queue队列、消息消费者】

JMS模型

  1. 点对点模型
  2. 发布、订阅模型

安装activemq

基本命令

#解压
tar -zxf apache-activemq-5.9.0-bin.tar.gz
#检查权限，如果权限不足，需要修改文件权限
ls -al apache-activemq-5.9.0/bin
chmod 755 activemq
#复制应用到本地目录
cp -r apache-activemq-5.9.0 /usr/local/activemq
#启动命令
/usr/local/activemq/bin/activemq start
#检查进程
ps aux | grep activemq
#访问
http://ip:8161/admin	username:admin	pwd:admin
#修改端口
cd /usr/local/activemq/conf/jetty.xml
关键字：jettyPort
#修改密码
vi /usr/local/activemq/conf/users.properties
内容 username:pwd
#重启
/usr/local/activemq/bin/activemq restart
#关闭
/usr/local/activemq/bin/activemq stop

#修改提供服务端口
activemq.xml 默认61616

术语

  1. destination目的地
  2. producer消息生成者
  3. consumer|receiver消息消费者
  4. message消息

Java中使用

基本使用

导入包：

		<!-- https://mvnrepository.com/artifact/org.apache.activemq/activemq-all -->
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-all</artifactId>
			<version>5.9.0</version>
		</dependency>
点对点模型

producer

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Session;
public class HelloWorldProducer {
	/**
	 * 生产消息
	 */
	public void sendHelloWorldActiveMQ(/*String msgTest*/ Users msgTest){
		//定义链接工厂
		ConnectionFactory connectionFactory = null;
		//定义链接对象
		Connection connection = null;
		//定义会话
		Session session = null;
		//目的地
		Destination destination = null;
		//定义消息的发送者
		MessageProducer producer = null;
		//定义消息
		Message message = null;
		try{
			/**
			 * userName:访问ActiveMQ服务的用户名。用户密码。默认的为admin。用户名可以通过jetty-ream.properties文件进行修改
			 * password:访问ActiveMQ服务的用户名。用户密码。默认的为admin。用户名可以通过jetty-ream.properties文件进行修改
			 * brokerURL:访问ActiveMQ服务的路径地址。路径结构为:协议名://主机地址:端口号
			 */
			connectionFactory = new ActiveMQConnectionFactory("admin", "admin", "tcp://192.168.3.128:61616");
			//创建连接对象
			connection = connectionFactory.createConnection();
			//启动连接
			connection.start();
			/**
			 * transacted:是否使用事务 可选值为：true|false
			 *            true:使用事务 当设置次变量值。Session.SESSION_TRANSACTED
			 *            false:不适用事务,设置次变量 则acknowledgeMode参数必须设置
			 * acknowledgeMode:
			 * Session.AUTO_ACKNOWLEDGE:自动消息确认机制
			 * Session.CLIENT_ACKNOWLEDGE:客户端确认机制
			 * Session.DUPS_OK_ACKNOWLEDGE:有副本的客户端确认消息机制
			 */
			session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
			//创建目的地，目的地名称即队列的名称。消息的消费者需要通过此名称访问对应的队列
			destination = session.createQueue("helloworld-destination");
			//创建消息的生产者 
			producer = session.createProducer(destination);
			//传递消息
//			message = session.createTextMessage(msgTest);
			//传递消息对象
			message = session.createObjectMessage(msgTest);
			//发送消息
			producer.send(message);
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			//回收消息发送者资源
			if(producer != null){
				try {
					producer.close();
				} catch (JMSException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(session != null){
				try {
					session.close();
				} catch (JMSException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(connection != null){
				try {
					connection.close();
				} catch (JMSException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}
public static void main(String[] args) {
    HelloWorldProducer producer = new HelloWorldProducer();
    Users user = new Users();
    user.setAge("11");
    user.setName("dzy");
    producer.sendHelloWorldActiveMQ(user);
}

consumer(直接获取或者通过监听)

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
import javax.jms.Session;
import javax.jms.TextMessage;
public class HelloWorldConsumer {
	/**
	 * 消费消息
	 */
	public void readHelloWorldActiveMQ() {
		// 定义链接工厂
		ConnectionFactory connectionFactory = null;
		// 定义链接对象
		Connection connection = null;
		// 定义会话
		Session session = null;
		// 目的地
		Destination destination = null;
		// 定义消息的发送者
		MessageConsumer consumer = null;
		// 定义消息
		Message message = null;
		try {
			/**
			 * userName:访问ActiveMQ服务的用户名。用户密码。默认的为admin。用户名可以通过jetty-ream.
			 * properties文件进行修改
			 * password:访问ActiveMQ服务的用户名。用户密码。默认的为admin。用户名可以通过jetty-ream.
			 * properties文件进行修改 brokerURL:访问ActiveMQ服务的路径地址。路径结构为:协议名://主机地址:端口号
			 */
			connectionFactory = new ActiveMQConnectionFactory("admin", "admin", "tcp://192.168.3.128:61616");
			// 创建连接对象
			connection = connectionFactory.createConnection();
			// 启动连接
			connection.start();
			/**
			 * transacted:是否使用事务 可选值为：true|false true:使用事务
			 * 当设置次变量值。Session.SESSION_TRANSACTED false:不适用事务,设置次变量
			 * 则acknowledgeMode参数必须设置 acknowledgeMode:
			 * Session.AUTO_ACKNOWLEDGE:自动消息确认机制
			 * Session.CLIENT_ACKNOWLEDGE:客户端确认机制
			 * Session.DUPS_OK_ACKNOWLEDGE:有副本的客户端确认消息机制
			 */
			session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
			// 创建目的地，目的地名称即队列的名称。消息的消费者需要通过此名称访问对应的队列
			destination = session.createQueue("helloworld-destination");
			// 创建消息的消费者
			consumer = session.createConsumer(destination);
            
            //第一种获取消息的方法
			// 创建消息对象
			message = consumer.receive();
			//处理消息
//			String msg = ((TextMessage)message).getText();
//			System.out.println("从ActiveMQ服务中获取的文本信息 "+msg);
			//处理对象消息
			Users msg1 = (Users)((ObjectMessage)message).getObject();
			System.out.println("返回的对象："+msg1.toString());
            
            //第二种获取消息的方法（监听）
            consumer.setMessageListener(new MessageListener() {	
				@Override
				public void onMessage(Message message) {
					//处理消息
					String msg = null;
					try {
						msg = ((TextMessage)message).getText();
					} catch (JMSException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println("从ActiveMQ服务中获取的文本信息 "+msg);
				}
			});
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 回收消息发送者资源
			if (consumer != null) {
				try {
					consumer.close();
				} catch (JMSException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (session != null) {
				try {
					session.close();
				} catch (JMSException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (connection != null) {
				try {
					connection.close();
				} catch (JMSException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}
    
public class Test{
	public static void main(String[] args) {
		HelloWorldConsumer consumer = new HelloWorldConsumer();
		consumer.readHelloWorldActiveMQ();
    }
}
订阅发布模型

producer

public class HelloWorldProducerTopic {

	/**
	* 生产消息
	*/
	public void sendHelloWorldActiveMQ(String msgTest){
		//定义链接工厂
		ConnectionFactory connectionFactory = null;
		//定义链接对象
		Connection connection = null;
		//定义会话
		Session session = null;
		//目的地
		Destination destination = null;
		//定义消息的发送者
		MessageProducer producer = null;
		//定义消息
		Message message = null;
		try{
			connectionFactory = new ActiveMQConnectionFactory("admin", "admin", "tcp://192.168.3.128:61616");
			//创建连接对象
			connection = connectionFactory.createConnection();
			//启动连接
			connection.start();
			session = connection.createSession(false, 
			Session.AUTO_ACKNOWLEDGE);
			//创建目的地，目的地名称即队列的名称。消息的消费者需要通过此名称访问对应的队列
			destination = session.createTopic("test-topic");
			//创建消息的生产者
			producer = session.createProducer(destination);
			//创建消息对象
			message = session.createTextMessage(msgTest);
			//发送消息
			producer.send(message);
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			//回收消息发送者资源
			if(producer != null){
			try {
				producer.close();
			} catch (JMSException e) {
			// TODO Auto-generated catch block
				e.printStackTrace();
			}
			}
			if(session != null){
			try {
				session.close();
			} catch (JMSException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			if(connection != null){
				try {
					connection.close();
				} catch (JMSException e) {
					e.printStackTrace();
				}
			}

			}
		}
	}
}
public class Test {
	public static void main(String[] args) {
		HelloWorldProducerTopic topic = new HelloWorldProducerTopic();
		Users user = new Users();
		user.setAge("11");
		user.setName("dzy");
		topic.sendHelloWorldActiveMQ("tset");
	}
}

consumer

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;

public class HelloWorldConsumerTopic implements Runnable{
	/**
	 * 消费消息
	 */
	public void readHelloWorldActiveMQ() {
		// 定义链接工厂
		ConnectionFactory connectionFactory = null;
		// 定义链接对象
		Connection connection = null;
		// 定义会话
		Session session = null;
		// 目的地
		Destination destination = null;
		// 定义消息的发送者
		MessageConsumer consumer = null;
		// 定义消息
		Message message = null;
		try {
			/**
			 * userName:访问ActiveMQ服务的用户名。用户密码。默认的为admin。用户名可以通过jetty-ream.
			 * properties文件进行修改
			 * password:访问ActiveMQ服务的用户名。用户密码。默认的为admin。用户名可以通过jetty-ream.
			 * properties文件进行修改 brokerURL:访问ActiveMQ服务的路径地址。路径结构为:协议名://主机地址:端口号
			 */
			connectionFactory = new ActiveMQConnectionFactory("admin", "admin", "tcp://192.168.3.128:61616");
			// 创建连接对象
			connection = connectionFactory.createConnection();
			// 启动连接
			connection.start();
			/**
			 * transacted:是否使用事务 可选值为：true|false true:使用事务
			 * 当设置次变量值。Session.SESSION_TRANSACTED false:不适用事务,设置次变量
			 * 则acknowledgeMode参数必须设置 acknowledgeMode:
			 * Session.AUTO_ACKNOWLEDGE:自动消息确认机制
			 * Session.CLIENT_ACKNOWLEDGE:客户端确认机制
			 * Session.DUPS_OK_ACKNOWLEDGE:有副本的客户端确认消息机制
			 */
			session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
			// 创建目的地，目的地名称即队列的名称。消息的消费者需要通过此名称访问对应的队列
			destination = session.createTopic("test-topic");
			// 创建消息的消费者
			consumer = session.createConsumer(destination);
			consumer.setMessageListener(new MessageListener() {
				@Override
				public void onMessage(Message message) {
					String msg = null;
					try {
						msg = ((TextMessage)message).getText();
					} catch (JMSException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println("从ActiveMQ服务中获取的文本信息 "+msg);
				}
			});
		} catch (Exception e) {
			e.printStackTrace();
		} 
	}

	@Override
	public void run() {
		this.readHelloWorldActiveMQ();
	}
}

public class test{
    public static void main(String[] args) {
		HelloWorldConsumerTopic topic = new HelloWorldConsumerTopic();
		Thread t = new Thread(topic);
		t.start();
		HelloWorldConsumerTopic3 topic1 = new HelloWorldConsumerTopic3();
		Thread t1 = new Thread(topic1);
		t1.start();
		HelloWorldConsumerTopic2 topic2 = new HelloWorldConsumerTopic2();
		Thread t2 = new Thread(topic2);
		t2.start();
	}
}

整合spring

producer pom文件
	<dependencies>
		<!-- ActiveMQ客户端完整jar包依赖 -->
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-all</artifactId>
		</dependency>
		<!-- ActiveMQ和Spring整合配置文件标签处理jar包依赖 -->
		<dependency>
			<groupId>org.apache.xbean</groupId>
			<artifactId>xbean-spring</artifactId>
		</dependency>
		<!-- Spring-JMS插件相关jar包依赖 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jms</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-pool</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-jms-pool</artifactId>
		</dependency>
		<!-- 单元测试 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
		</dependency>
		<!-- 日志处理 -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
		</dependency>
		<!-- spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
		</dependency>

		<!-- JSP相关 -->
		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jsp-api</artifactId>
			<scope>provided</scope>
		</dependency>
	</dependencies>
consumer pom文件
	<dependencies>
		<!-- activemq客户端 -->
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-all</artifactId>
		</dependency>
		<!-- spring框架对JMS标准的支持 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jms</artifactId>
		</dependency>
		<!-- ActiveMQ和spring整合的插件 -->
		<dependency>
			<groupId>org.apache.xbean</groupId>
			<artifactId>xbean-spring</artifactId>
		</dependency>


		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
		</dependency>
	</dependencies>
producer applicationContext-jms.xml
<?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:jms="http://www.springframework.org/schema/jms"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:amq="http://activemq.apache.org/schema/core"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/jms
		http://www.springframework.org/schema/jms/spring-jms.xsd
		http://activemq.apache.org/schema/core
		http://activemq.apache.org/schema/core/activemq-core.xsd 
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context.xsd">
    
	<!-- 需要创建一个连接工厂,连接ActiveMQ. ActiveMQConnectionFactory. 需要依赖ActiveMQ提供的amq标签 -->
	<!-- amq:connectionFactory 是bean标签的子标签, 会在spring容器中创建一个bean对象. 可以为对象命名. 
		类似: <bean id="" class="ActiveMQConnectionFactory"></bean> -->
	<amq:connectionFactory brokerURL="tcp://192.168.3.128:61616" 
		userName="admin" password="admin" id="amqConnectionFactory" />
		
	<!-- 配置池化的ConnectionFactory。 为连接ActiveMQ的connectionFactory提供连接池 -->
	<bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactoryBean">
		<property name="connectionFactory" ref="amqConnectionFactory"></property>
		<property name="maxConnections" value="10"></property>
	</bean>
    
	<!-- spring管理JMS相关代码的时候,必须依赖jms标签库. spring-jms提供的标签库. -->
	<!-- 定义Spring-JMS中的连接工厂对象 CachingConnectionFactory - spring框架提供的连接工厂对象. 
		不能真正的访问MOM容器. 类似一个工厂的代理对象. 需要提供一个真实工厂,实现MOM容器的连接访问. -->
	<!-- 配置有缓存的ConnectionFactory，session的缓存大小可定制。 -->
	<bean id="connectionFactory"
		class="org.springframework.jms.connection.CachingConnectionFactory">
		<property name="targetConnectionFactory" ref="amqConnectionFactory"></property>
		<property name="sessionCacheSize" value="3"></property>
	</bean>

	<!-- JmsTemplate配置 -->
	<bean id="template" class="org.springframework.jms.core.JmsTemplate">
		<!-- 给定连接工厂, 必须是spring创建的连接工厂. -->
		<property name="connectionFactory" ref="connectionFactory"></property>
		<!-- 可选 - 默认目的地命名 -->
		<property name="defaultDestinationName" value="test-spring"></property>
	</bean>
</beans>
consumer applicationContext-jms.xml
<?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:jms="http://www.springframework.org/schema/jms" 
	xmlns:amq="http://activemq.apache.org/schema/core"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/jms
		http://www.springframework.org/schema/jms/spring-jms.xsd
		http://activemq.apache.org/schema/core
		http://activemq.apache.org/schema/core/activemq-core.xsd">
	<!-- 需要创建一个连接工厂,连接ActiveMQ. ActiveMQConnectionFactory. 需要依赖ActiveMQ提供的amq标签 -->
	<!-- amq:connectionFactory 是bean标签的子标签, 会在spring容器中创建一个bean对象.
		可以为对象命名. 类似: <bean id="" class="ActiveMQConnectionFactory"></bean>
	 -->
	<amq:connectionFactory brokerURL="tcp://192.168.70.151:61616"
		userName="admin" password="admin" id="amqConnectionFactory"/>

	<!-- spring管理JMS相关代码的时候,必须依赖jms标签库. spring-jms提供的标签库. -->
	<!-- 定义Spring-JMS中的连接工厂对象
		CachingConnectionFactory - spring框架提供的连接工厂对象. 不能真正的访问MOM容器.
			类似一个工厂的代理对象. 需要提供一个真实工厂,实现MOM容器的连接访问.
	 -->
	<bean id="connectionFactory" 
		class="org.springframework.jms.connection.CachingConnectionFactory">
		<property name="targetConnectionFactory" ref="amqConnectionFactory"></property>
		<property name="sessionCacheSize" value="3"></property>
	</bean>
	
	<!-- 注册监听器 -->
	<!-- 开始注册监听. 
		需要的参数有:
			acknowledge - 消息确认机制
			container-type - 容器类型 default|simple
			simple:SimpleMessageListenerContainer最简单的消息监听器容器，只能处理固定数量的JMS会话，且不支持事务。
			default:DefaultMessageListenerContainer是一个用于异步消息监听器容器 ，且支持事务         
			destination-type - 目的地类型. 使用队列作为目的地.
			connection-factory - 连接工厂, spring-jms使用的连接工厂,必须是spring自主创建的
			不能使用三方工具创建的工程. 如: ActiveMQConnectionFactory.
	 -->
	<jms:listener-container acknowledge="auto" container-type="default"
		destination-type="queue" connection-factory="connectionFactory" >
		<!-- 在监听器容器中注册某监听器对象.
			destination - 设置目的地命名
			ref - 指定监听器对象
		 -->
		<jms:listener destination="test-spring" ref="myListener"/>
	</jms:listener-container>
	
</beans>
consumer消息监听处理
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.bjsxt.pojo.Users;
import com.bjsxt.service.UserService;
/**
 * 娑堟伅鏈嶅姟鐩戝惉鍣�
 * @author Administrator
 *
 */
@Component(value="myListener")
public class MyMessageListener implements MessageListener{
	@Autowired
	private UserService userService;
	@Override
	public void onMessage(Message message) {
		//activemq消费者对象
		ObjectMessage objMessage = (ObjectMessage)message;
		Users user=null;
		try {
			user = (Users)objMessage.getObject();
		} catch (JMSException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		this.userService.showUser(user);
	}
}
producer消息发送
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Service;
import com.bjsxt.pojo.Users;
import com.bjsxt.service.UserService;

@Service
public class UserServiceImpl implements UserService {
	@Autowired
	private JmsTemplate jmsTemplate;
	@Override
	public void addUser(final Users user) {
		this.jmsTemplate.send(new MessageCreator() {
			@Override
			public Message createMessage(Session session) throws JMSException {
				Message message = session.createObjectMessage(user);
				return message;
			}
		});
	}
}

end

dzyselfdns
关注
c# winform activemq
10-27
c# 测试activemq源码，亲测可用
activemq
03-10
activemq
java activemq jar包_ActiveMQ_3Java实现
weixin_42498347的博客
02-27 581
Java实现添加相应的jar包org.apache.activemqactivemq-allx.xx.x创建生产者类(点对点)public class ProducerTest {// 异步发送asyn// 死信队列 DLQ// 文件上传// header properties使用// jdbc存储// byteMsg objMsg inputMsg// mq ptp 的使用场景// mq中所有的...
activemq相关依赖jar包
weixin_40857858的博客
08-29 949
<!--JMS规范的jar依赖--> <dependency> <groupId>javax.jms</groupId> <artifactId>javax.jms-api</artifactId> <version>2.0.1</version> /dependency> <!--activeMQ对jms具体实现的jar依赖--> <dependency> <gro
【认识】RabbitMQ：基本用法和说明
最新发布
CS Beginner的博客
04-12 1386
RabbitMQ是一个开源的消息代理软件，它接收、存储和转发消息。通过队列来存储消息，并使用交换机来路由消息到相应的队列。在本文中，我们将学习如何使用RabbitMQ的Java客户端库构建生产者和消费者，实现消息的发送和接收。通过本文的学习，我们深入了解了RabbitMQ的基本用法和说明。我们学习了如何引入RabbitMQ和SLF4J，创建生产者和消费者示例，以及模拟演示结果。RabbitMQ作为一个强大的消息代理软件，在分布式应用程序和微服务架构中有着广泛的应用前景。
ActiveMQ的在（基于xml配置）项目中与Spring发生版本冲突问题
zgphacker2010的专栏
10-09 741
ActiveMQ的在（基于xml配置）项目中与Spring发生版本冲突问题
 activemq-all的jar包冲突报错分析。
q496427196的博客
05-02 999
因为用的activemq，所以用到了activemq-all 这个jar包。去jar包里仔细排查发现包里包含了spring的org.springframework.core.annotation.AnnotatedElementUtils类。导致了跟springjar包的org.springframework.core.annotation.AnnotatedElementUtils类的方法冲突！ 解决办法：只能不使用activemq-all 这个jar包，老实的一个一个导入activemq所需要的包即.
activemq的配置文件及依赖
weixin_45868039的博客
02-21 270
spring配置文件。
jdk activemq
06-12
jdk与activemq对应关系，根据不同的jdk版本下载不同的activemq
ActiveMQ实战资料
12-19
含如下内容：JMS API；Apache-activeMQ；ActiveMQ实战pdf
apache-activemq-5.16.6-bin.zip
12-26
apache-activemq-5.16.6-bin.zip
ActiveMQ jar包
11-06
ActiveMQ所需要的Jar包 geronimo-j2ee-management_1.1_spec-1.0.1
activemq-all.5.14jar包
08-30
activemq-all.5.14jar包，亲测可用！！
activemq-all-5.15.2.jar 和 jms-1.1.jar
03-10
ActiveMQ测试用例依赖的jar包，activemq-all-5.15.2.jar 和 jms-1.1.jar
解决Class path contains multiple SLF4J bindings
sinat_34183216的博客
01-10 805
在pom.xml新引入一个依赖后，启动项目时报错，日志如下： SLF4J: Class path contains multiple SLF4J bindings. SLF4J: Found binding in [jar:file:/F:/mvnRepository/repository/org/apache/activemq/activemq-all/5.9.0/activemq-all-5...
ActiveMQ 安装及使用过程
dhaibo1986的专栏
10-28 710
1.安装jdk 在CentOS操作系统中，可以下载rpm包直接安装。 [root@m161p114 ~]# lsb_release -a LSB Version: :core-4.1-amd64:core-4.1-noarch:cxx-4.1-amd64:cxx-4.1-noarch:desktop-4.1-amd64:desktop-4.1-noarch:languages-4.1-amd64:languages-4.1-noarch:printing-4.1-amd64:printing-4.1-noa
springmvc 集成activemq引入activemq-all-5.14.4有冲突
z1012890225的专栏
04-11 7248
springmvc 4.2.9集成activemq-5.14.4时报错，错误信息如下 NoSuchMethodError: org.springframework.core.annotation.AnnotatedElementUtils.findMergedAnnotationAttributes...... 解决方法：移除activemq-all-5.14.4.jar  分别引入要用到
springmvc配置使用activemq
ITarmi的分享
08-21 705
本文不介绍activemq的安装，Windows下安装很简单，下载安装包解压即可 pom.xml文件引入依赖 一定不要向下面这样引入activemq依赖，因为activemq-all依赖中也包括spring依赖，可能会与你搭建项目时引入的spring依赖冲突 <dependency> <groupId>org.apache.activemq</groupId> <artifactId>activ
Spring Framework JMS 用 activeMQ的实现
qq_28400257的博客
03-07 226
1.maven 中导入 activeMQ的依赖 导入 activeMQ-all 的依赖&lt;dependency&gt; &lt;groupId&gt;org.apache.activemq&lt;/groupId&gt; &lt;artifactId&gt;activemq-all&lt;/artifactId&gt; &lt;version&gt;5.15.0&lt...
pulsar activemq
11-28
Pulsar是一种开源的分布式消息系统，而ActiveMQ是一种流行的开源消息代理系统。Pulsar ActiveMQ是将这两种系统结合在一起的项目。 Pulsar是由Apache软件基金会开发的，旨在解决传统消息队列系统的一些瓶颈和限制。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值