ActiveMQ使用连接池实现消息的生产和消费

最新推荐文章于 2021-02-24 01:58:22 发布
最新推荐文章于 2021-02-24 01:58:22 发布
阅读量975 收藏 1
点赞数
文章标签： ActiveMQ 连接池

ActiveMQ使用连接池实现消息的生产和消费

使用背景：
应用ActiveMQ的消息队列特性来替换Timer框架的定时任务功能。 Timer定时器是单线程的，很容易出现一个任务出现异常，其余任务全部停止的问题，这就是线程阻塞问题。当然你可以使用线程池的方式实现多线程任务并发执行，但若是应用中定时任务多且逻辑复杂还要考虑内存资源的问题。 所以综合参考网上的众多资源，编写了基于ActiveMQ的连接池实现消息的产生和消费，在此作为记录。

环境搭建
在MQ的官网上下载相关版本的ActiveMQ，需要依据自己环境的jdk版本和Spring版本。本人使用的是Spring3.2，使用的ActiveMQ版本是5.9，且引入相关jar包，见截图：
在这里插入图片描述
代码实现
连接池管理类：

public class MQPoolFactory{
	private static final String USERNAME="admin";
	private static final String PASSWORD="admin";
	private static final String BROKERURL="tcp://127.0.0.1:61616";
	private static final int SESSIONCACHESIZE = 20;//session缓存大小设置
	
	private static final int INIT_CONNECTION_SIZE = 1;//初始化连接数
	private static final int MAX_CONNECTION_SIZE = 5;//最大连接数
	private static final int MAX_SESSION_SIZE = 100;//每个连接可创建的最大session数
	private static final int MIN_SESSION_SIZE = 10;//每个连接可创建的最小session数
	private static final int MAX_PRODUCER_SESSION = 10;//每个session可建的最大producer数
	private static final int MAX_CONSUMER_SESSION = 10;//每个session可建的最大consumer数
	
	private LinkedList<ConnectionPool> connectionPool  = new LinkedList<ConnectionPool>();//存放空闲连接的链表
	private LinkedList<SessionPool> sessionPools = new LinkedList<SessionPool>();

	/**
	 *  缺省设置，默认加载MQ工厂初始化方法
	 * @throws Exception 
	 */
	public MQPoolFactory() throws Exception{
		initMQFactory();
	}
	/**
	 * 初始化MQ
	 */
	public void initMQFactory() throws Exception{
		if(INIT_CONNECTION_SIZE > 0 && INIT_CONNECTION_SIZE <= MAX_CONNECTION_SIZE) {
			try {
				for(int i = 0;i<INIT_CONNECTION_SIZE;i++) {
					Connection connection = buildConnection();
					ConnectionPool connPool = new ConnectionPool();
					connPool.setConnection(connection);
					if(MIN_SESSION_SIZE > 0 && MIN_SESSION_SIZE <= MAX_SESSION_SIZE) {
						connPool.setActiveSessions(MIN_SESSION_SIZE);
						for (int j = 0; j < MIN_SESSION_SIZE; j++) {
							Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);//默认设置MQ自动检测消息是否送达
							SessionPool sessionPool = new SessionPool();
							sessionPool.setConnection(connection);
							sessionPool.setSession(session);
							sessionPools.addLast(sessionPool);
						}
					}
					connectionPool.add(connPool);
				}
			}catch(JMSException e) {
				throw new Exception("MQ初始化异常", e);
			}
		}
	}
	/**
	 * 构建方法
	 * @throws JMSException 
	 */
	private synchronized Connection buildConnection() throws JMSException {
		MqConfigBean bean = new MqConfigBean(BROKERURL, USERNAME, PASSWORD, SESSIONCACHESIZE);
		ActiveMQConnectionFactory targetFactory = new 			 ActiveMQConnectionFactory(bean.getUserName(),bean.getPassword(),bean.getBrokerURL());
		//targetFactory.setUseAsyncSend(true);//强制使用同步返回数据格式
		
		CachingConnectionFactory connectoryFacotry =  new CachingConnectionFactory();
		connectoryFacotry.setTargetConnectionFactory(targetFactory);
		connectoryFacotry.setSessionCacheSize(bean.getSessionCacheSize());//设置缓存大小，优化性能
		Connection connection = connectoryFacotry.createConnection();
		connection.start();//开启连接
		
		return connection;
	}
	/**
	 * 从连接池中获取连接
	 * @throws Exception 
	 */
	private synchronized ConnectionPool getConnectionPool() throws Exception {
		ConnectionPool connPool = null;
		if(connectionPool != null && connectionPool.size() > 0) {
			for (ConnectionPool connectionPool : connectionPool) {
					int poolSessionSize = connectionPool.getActiveSessions();//获取该连接中session活跃的会话数量
			        if (poolSessionSize < MAX_SESSION_SIZE) {//取相对会话比较少的连接
			            connPool = connectionPool;
			    }
			}
			//若当前连接池中的连接全部处于使用状态，则在不超过最大连接数的前提下添加新的连接
			if(connPool == null && connectionPool.size() < MAX_CONNECTION_SIZE) {
				try {
					Connection connection = buildConnection();
					connPool = new ConnectionPool();
					connPool.setConnection(connection);
					if(MIN_SESSION_SIZE > 0 && MIN_SESSION_SIZE <= MAX_SESSION_SIZE) {
						connPool.setActiveSessions(MIN_SESSION_SIZE);
						for (int j = 0; j < MIN_SESSION_SIZE; j++) {
							Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);//默认设置MQ自动检测消息是否送达
							SessionPool sessionPool = new SessionPool();
							sessionPool.setConnection(connection);
							sessionPool.setSession(session);
							sessionPools.addLast(sessionPool);
						}
					}
					connectionPool.add(connPool);
				}catch(JMSException e) {
					throw new Exception("getConnection方法创建Connection异常",e);
				}
			}
		}
		return connPool;
	}
	/**
	 * 获取生产者的session信息
	 */
	private SessionPool getProducerSessionPool() {
		SessionPool sesPool = null;
		if(sessionPools != null && sessionPools.size() > 0) {
			try {
				ConnectionPool connPool = getConnectionPool();
				for(SessionPool pool : sessionPools) {
					if(pool.getConnection() == connPool.getConnection()) {
						int poolProducerSize = pool.getAvailableProducer();//获取当前session中已存在的生产者的数量
						if(poolProducerSize < MAX_PRODUCER_SESSION) {//当前session中生产者较少的优先使用
							sesPool = pool;
						}
					}
				}
				//当前session资源被占满，则重新创建一个新的session
				if(sesPool == null && connPool.getActiveSessions() < MAX_SESSION_SIZE) {
					try {
						Connection conn = connPool.getConnection();
						Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
						sesPool = new SessionPool();
						sesPool.setConnection(conn);
						sesPool.setSession(session);
						sessionPools.addLast(sesPool);
					}catch(Exception e) {
						throw new Exception("getProducerSession方法创建Session异常",e);
					}
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
		}
		return sesPool;
	}
	
	/**
	 * 获取消费者的session信息
	 */
	private SessionPool getConsumerSessionPool() {
		SessionPool sesPool = null;
		if(sessionPools != null && sessionPools.size() > 0) {
			try {
				ConnectionPool connPool = getConnectionPool();
				for(SessionPool pool : sessionPools) {
					if(pool.getConnection() == connPool.getConnection()) {
						int poolConsumerSize = pool.getAvailableConsumer();//获取当前session中已存在的生产者的数量
						if(poolConsumerSize < MAX_CONSUMER_SESSION) {//当前session中消费者较少的优先使用
							sesPool = pool;
						}
					}
				}
				//当前session资源被占满，则重新创建一个新的session
				if(sesPool == null && connPool.getActiveSessions() < MAX_SESSION_SIZE) {
					try {
						Connection conn = connPool.getConnection();
						Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
						sesPool = new SessionPool();
						sesPool.setConnection(conn);
						sesPool.setSession(session);
						sessionPools.addLast(sesPool);
					}catch(Exception e) {
						throw new Exception("getProducerSession方法创建Session异常",e);
					}
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
		}
		return sesPool;
	}
	
	/**
	 * 获取生产者的连接信息
	 * @param name 消息队列名称  messageType p2p or topic
	 * @param isVIP  可扩展  若为true则代表 当前session中无消费者和生产者
	 * @throws Exception 
	 */
	public ProducerPool getProducerPool(String name,String messageType) throws Exception{
		SessionPool sessionPool = getProducerSessionPool();
		Session session = sessionPool.getSession();
		try {
			Destination dt = null;
			if(messageType.equals(MessageTypeEnum.TOPIC.getTypeName())) {
				dt = session.createTopic(name);
			}else if(messageType.equals(MessageTypeEnum.QUEUE.getTypeName())) {
				dt = session.createQueue(name);
			}
			MessageProducer producer = session.createProducer(dt);
			ProducerPool producerPool = new ProducerPool();
			producerPool.setProducer(producer);
			producerPool.setConnection(sessionPool.getConnection());
			producerPool.setSession(session);
			producerIncreament(sessionPool);
			return producerPool;
		}catch(Exception e) {
			throw new Exception("获取生产者连接异常",e);
		}
	}
	/**
	 * 获取消费者的连接信息
	 * @param name 消息队列名称  messageType p2p or topic
	 * @param isVIP  可扩展  若为true则代表 当前session中无消费者和生产者
	 * @throws Exception 
	 */
	public ConsumerPool getConsumerPool(String name,String messageType) throws Exception{
		SessionPool sessionPool = getConsumerSessionPool();
		Session session = sessionPool.getSession();
		try {
			Destination dt = null;
			if(messageType.equals(MessageTypeEnum.TOPIC.getTypeName())) {
				dt = session.createTopic(name);
			}else if(messageType.equals(MessageTypeEnum.QUEUE.getTypeName())) {
				dt = session.createQueue(name);
			}
			MessageConsumer consumer = session.createConsumer(dt);
			ConsumerPool consumerPool = new ConsumerPool();
			consumerPool.setConsumer(consumer);
			consumerPool.setConnection(sessionPool.getConnection());
			consumerPool.setSession(session);
			consumerIncreament(sessionPool);
			return consumerPool;
		}catch(Exception e) {
			throw new Exception("获取消费者连接异常",e);
		}
	}
	/**
	 * 连接池中可用生产者加一
	 * @param sessionPool
	 */
	private void producerIncreament(SessionPool sessionPool){
		if(sessionPool!=null){
			for(SessionPool sePool : sessionPools){
				if(sePool==sessionPool){
					int cnt = sePool.getAvailableProducer();
					cnt++;
					sePool.setAvailableProducer(cnt);
				}
			}
		}
	}
	/**
	 * 连接池中可用生产者减一
	 * @param producerPool
	 */
	public void producerDecreament(ProducerPool producerPool){
		if(producerPool!=null){
			for(SessionPool sessionPool : sessionPools){
				if(sessionPool.getConnection()==producerPool.getConnection() 
						&& sessionPool.getSession()==producerPool.getSession()){
					int cnt = sessionPool.getAvailableProducer();
					cnt--;
					sessionPool.setAvailableProducer(cnt);
				}
			}
		}
	}
	/**
	 * 连接池中可用消费者加一
	 * @param sessionPool
	 */
	private void consumerIncreament(SessionPool sessionPool){
		if(sessionPool!=null){
			for(SessionPool sePool : sessionPools){
				if(sePool==sessionPool){
					int cnt = sePool.getAvailableConsumer();
					cnt++;
					sePool.setAvailableConsumer(cnt);
				}
			}
		}
	}
	/**
	 * 连接池中可用消费者减一
	 * @param consumerPool
	 */
	public void consumerDecreament(ConsumerPool consumerPool){
		if(consumerPool!=null){
			for(SessionPool sessionPool : sessionPools){
				if(sessionPool.getConnection()==consumerPool.getConnection() 
						&& sessionPool.getSession()==consumerPool.getSession()){
					int cnt = sessionPool.getAvailableConsumer();
					cnt--;
					sessionPool.setAvailableConsumer(cnt);
				}
			}
		}
	}
	/**
	 * 释放所有连接
	 * @return
	 * @throws AMQFactoryException
	 */
	public boolean disposeAll() throws Exception{
		try {
			if(sessionPools!=null && sessionPools.size()>0){
				for (SessionPool sessionPool : sessionPools) {
					sessionPool.getSession().close();
				}
				sessionPools.clear();
			}
			if(connectionPool!=null && connectionPool.size()>0){
				for(ConnectionPool connectionPool : connectionPool){
					connectionPool.getConnection().stop();
					connectionPool.getConnection().close();
				}
				connectionPool.clear();
			}
			return true;
		} catch (JMSException e) {
			throw new Exception("释放连接出错",e);
		}
	}
	/**
	 * 释放生产者连接
	 * @throws Exception 
	 */
	public void closeProducerConnection(MessageProducer producer) throws Exception {
		if(producer!=null){
			try {
				producer.close();
			} catch (JMSException e) {
				throw new Exception("释放producer连接出错",e);
			}
		}
	}
	/**
	 * 释放消费者连接
	 * @throws Exception 
	 */
	public void closeConsumerConnection(MessageConsumer consumer) throws Exception {
		if(consumer!=null){
			try {
				consumer.close();
			} catch (JMSException e) {
				throw new Exception("释放consumer连接出错",e);
			}
		}
	}
	/**
	 * 编写MQ配置bean
	 */
	@SuppressWarnings("unused")
	private static class MqConfigBean{
		private String brokerURL;
	    private String userName;
	    private String password;
	    private int sessionCacheSize;
	    
		public MqConfigBean(){
	    	
	    }
	    public MqConfigBean(String brokerURL, String userName, String password, int sessionCacheSize) {
	        this.brokerURL = brokerURL;
	        this.userName = userName;
	        this.password = password;
	        this.sessionCacheSize = sessionCacheSize;
	    }
		public String getBrokerURL() {
			return brokerURL;
		}
		public void setBrokerURL(String brokerURL) {
			this.brokerURL = brokerURL;
		}
		public String getUserName() {
			return userName;
		}
		public void setUserName(String userName) {
			this.userName = userName;
		}
		public String getPassword() {
			return password;
		}
		public void setPassword(String password) {
			this.password = password;
		}
		public int getSessionCacheSize() {
			return sessionCacheSize;
		}
		public void setSessionCacheSize(int sessionCacheSize) {
			this.sessionCacheSize = sessionCacheSize;
		}
	}
}

枚举类

public enum MessageTypeEnum {
	TOPIC("topic"),QUEUE("queue");
	
	private String typeName;
	
	MessageTypeEnum(String typeName){
		this.typeName = typeName;
	}
	
	public String getTypeName() {
		return typeName;
	}
}

消息发送管理类

public class MQPoolSender {
	public boolean sendStrMsg(AMQPoolFactory amqFactory,String name,String messageType,String msg) {
		if(amqFactory == null) {
			log.error("MQ工厂实例为null");
		}
		if("".equals(name) || name == null) {
			log.error("消息队列名称为空");
		}
		if("".equals(msg) || msg == null) {
			log.error("待发送的消息为空");
		}
		try {
			//获取生产者的连接池信息
			ProducerPool producerPool = null;
			if(onUsing) {//若内存中有则拿出来进行复用
				if(mapProPool.containsKey(name)){
					producerPool = mapProPool.get(name);
	       	  	}
			}else if(producerPool == null){
       	  		producerPool = amqFactory.getProducerPool(name,messageType);
       	  	}
			
			Session session = producerPool.getSession();
			MessageProducer producer = producerPool.getProducer();
			try {
				TextMessage textMsg = session.createTextMessage(msg);
				long time = 60 * 1000;// 延时1分钟发送
//				long period = 10 * 1000;// 每个10s  
//		        int repeat = 6;// 6次  
		        textMsg.setLongProperty(ScheduledMessage.AMQ_SCHEDULED_DELAY, time);  
//		        textMsg.setLongProperty(ScheduledMessage.AMQ_SCHEDULED_PERIOD, period);  
//		        textMsg.setIntProperty(ScheduledMessage.AMQ_SCHEDULED_REPEAT, repeat);  
		        
				producer.send(textMsg);
				System.out.println(">>>>>>>>>>>>>>>>向消息队列"+name+"发送消息为："+textMsg.getText());
				return true;
			}catch (JMSException e) {
				System.out.println("消息发送失败"+e);
			}finally {
					//释放生产者连接
					amqFactory.closeProducerConnection(producer);
					//连接池中的可用生产者减一
					amqFactory.producerDecreament(producerPool);
				}
			}
		}catch(Exception e) {
			System.out.println("消息发送失败"+e);
		}
		return false;
	}
}

消息接受监听管理类

public class MQReceiverListeners {
	public boolean setListener(AMQPoolFactory amqFactory,String name,Class<?> className,String messageType) {
		try {
			ConsumerPool consumerPool = amqFactory.getConsumerPool(name, messageType);
			MessageConsumer consumer = null;
			try {
				//利用反射机制实例化监听类
				DjMessageListener listener = (DjMessageListener) className.newInstance();
				consumer = consumerPool.getConsumer();
				consumer.setMessageListener(listener);
				return true;
			}catch (JMSException e) {
				System.out.println("消息监听异常"+e);
			}finally {
				amqFactory.closeConsumerConnection(consumer);
				amqFactory.consumerDecreament(consumerPool);
			}
		}catch (Exception e) {
			System.out.println("消息监听异常"+e);
		}
		return false;
	}
}

消息监听实现类

public class DjMessageListener implements MessageListener {

public void onMessage(Message message) {
	System.out.println(">>>>>>>>>>>>>>>>>>>>>监听到有消息进来");
	try {
		TextMessage textMsg = (TextMessage) message;
		String text = textMsg.getText();
		System.out.println("》》》》》》》》》》》》》》》》》》》》》》》》收到消息"+text);
	} catch (JMSException e) {
		e.printStackTrace();
	}
}

MQ消息队列调度管理类

public class MQManager{
	private static volatile MQManager instance = null;
	private MQPoolFactory amqFactory = null;
	private MQPoolSender poolSender = new MQPoolSender();
	private MQReceiverListeners poolReceiver = new MQReceiverListeners ();
	//缺省模式
	private MQManager() {
		initMQ();
	};
	/**
	 * 使用单例模式进行类实例化
	 */
     public static AMQManager getInstance() {
    	 if(instance == null) {
    		 synchronized(AMQManager.class) {
    			 if(instance == null) {
    				 instance = new AMQManager();
    			 }
    		 }
    	 }
    	 return instance;
     }
      /**
      * 使用缺省设置来初始化MQ连接
      * @param isUsePool
      */
     public void initMQ(boolean isUsePool) {
	   	 try {
	   	 		 amqFactory = new AMQPoolFactory();
	    	 }catch (Exception e) {
	    		 e.printStackTrace();
			}
     }
     /**
      * 使用连接池的方式来发送的信息
      * 
      */
     public boolean sendStrMsg(String messageNme,String messageType,String msg,boolean onUsing){
    	 return poolSender.sendStrMsg(amqFactory, messageNme, messageType, msg, onUsing);
     }
     
     /**
  	  * 使用连接池的方式设置消费者监听
      */
     public boolean setListener(String messageNme, Class<?> className,String messageType) {
    	 return poolReceiver.setListener(amqFactory, messageNme, className, messageType);
     }
}

测试：

public static void main(String[] agrs) {
	MQManager amqManager = MQManager.getInstance();
	for(int i=0;i<10;i++) {
		amqManager.sendStrMsg("testQueue", "queue", "第"+i+"个定时任务");
	}
}

测试结果：
在这里插入图片描述
总结：
之前都是直接使用MQ的工厂模式直接创建连接、生产者和消费者，这个其实在小型应用中是没什么问题的，但是在一些大型应用，且存在高并发的情况下，频繁去创建连接，会占用消耗内存资源，这次是综合参考网上诸多demo加上一些特定场景来实现的。 当然MQ也有自带的连接池，有时间会把自带的连接池详细写一下。若有不足之处，欢迎评论区批评。

怡达达
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java activemq连接池_ActiveMQ使用线程池实现消息的生产与消费
weixin_42151305的博客
02-23 672
jar文件：spring3.1jar，以及项目src路径下文件：config.properties读取config.properties文件JAVA类：package com.lejob.lejobmy.config;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOExcep...
ActiveMQ使用线程池实现消息的生产与消费
爱分享的淘金达人
12-17 2182
1。 首先先引入相关的lib包，重点需引用activemq-client-5.8.0.jar，activemq-core-5.7.0.jar，activemq-pool-5.8.0.jar，activemq-protobuf-1.1.jar等包，其他包 自行配置。 2。 一些公共工具类的代码： JMSProducer.Java [java] view plain
activemq的连接池，通过spring的JmsTemplate发送消息到指定的Destination
leeking888的专栏
03-31 2万+
我们使用jms一般是使用spring-jms和activemq相结合，通过spring的JmsTemplate发送消息到指定的Destination。       首先定义一个activemq的连接池：   Xml代码 JMS、activemq中消费者收不到生产者发送的消息的原因解析" alt="复制代码" src="http://newleague.iteye.com/imag
自己实现的ActiveMQ连接池和新版本ActiveMQ自带的连接池，封装好的工具类，可直接使用
07-10
本资源提供的内容是关于ActiveMQ的连接池实现，分为两部分：一是作者自己实现的ActiveMQ连接池，二是新版本ActiveMQ自带的连接池。连接池是一种资源管理技术，通过复用已建立的数据库连接或网络连接，减少创建和销毁...
ActiveMQ相关jar包--使用Connection连接池
09-18
以下是使用ActiveMQ连接池的基本步骤： 1. 引入依赖：确保在项目中添加了ActiveMQ和Commons Pool的正确jar包。从描述中可以看出，jar包的版本选择非常重要，因为不同的版本可能有不同的API和特性。通常，最新稳定...
编码实现MQ连接池实现JMS消息发送连接管理
12-29
总结来说，"MQPoolService"项目提供了一个学习MQ连接池实现的实例，通过这个项目，开发者可以了解如何在Java应用中高效地管理和使用MQ资源，提升系统性能和稳定性。实践中，结合具体的JMS提供商和连接池实现库，可以...
ActiveMQ结合Spring收发消息的示例代码
08-26
4. `activemq-pool`：ActiveMQ连接池库，可以更有效地管理和复用连接。 接下来，我们需要配置ActiveMQ的相关信息。这通常在一个名为`ActiveMQ.xml`的Spring配置文件中完成。以下是一个简单的配置示例： ```xml ...
ActiveMQ生产者
03-29
- 考虑到性能和资源使用，合理配置ActiveMQ的连接池和线程池大小。 通过理解这些基本概念和步骤，你可以构建起一个简单的ActiveMQ生产者，为你的应用添加消息队列通信的能力。随着对ActiveMQ特性的深入理解和实践...
MQ原理、使用场景、IBM WebSphere MQ介绍及spring集成配置
热门推荐
格色情调的博客
10-31 2万+
一、MQ简介及特点         MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过写和检索出入列队的针对应用程序的数据（消息）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过队列来通信。队列的使用除去了接收和
firefly框架分析之netconnect package(三)
9527的专栏
10-10 1179
manager.py库 用来管理connection连接 class ConnectionManager: 包括一个管理connection对象的字典 def getNowConnCnt(self): 获取当前连接数量 def addConnection(self, conn): 根据conn创建connection对象，并加到字典中
ActiveMQ——消息的生产和消费
如不來的博客
07-16 3612
是一对一，还是一对多 消费者
ActiveMQ生产者和消费者事务_9
Be_nurturing的博客
06-28 560
一、生产者事务 创建session的时候，我们传了两个参数，第一个是事务，第二个是签收，我们来说说事务。 Session session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE); 方法的第一个参数就是事务，它的值可以是true或false，代表session的提交是事务提交还是非事务提交。 当事务的值是false时，只要执行了messageProducer.send()方法，消息就到了队列中，也就是自动提交了。 当事务
实战Spring4+ActiveMQ整合实现消息队列(生产者+消费者)
chamabo4215的博客
07-15 447
引言: 最近公司做了一个以信息安全为主的项目，其中有一个业务需求就是，项目定时监控操作用户的行为，对于一些违规操作严重的行为，以发送邮件(FoxMail)的形式进行邮件告警，可能是多人，也可能是一个人，第一次是以单人的形式，,直接在业务层需要告警的地方发送邮件即可，可是后边需求变更了，对于某些告警邮件可能会发送多人，这其中可能就会有阻塞发邮件的可能，直到把所有邮件发送完毕后再继续做下边的业务，领导...
ActiveMQ点对点通讯，生产者-消费者
怪只怪满眼尽是人间烟火
03-24 830
首先引入pom依赖： <!--activemq的依赖 --> <dependency> <groupId>org.apache.activemq</groupId> <artifactId>activemq-all</artifactId> ...
初次尝试ActiveMQ，实现简单的消息生产和消息消费
weixin_34357887的博客
07-15 149
   初次使用ActiveMQ，借助百度（近来常规方式google无法访问）搜索了JMS1.1规范阅读了一下，于是动手开始尝试实现一个消息生产和消费的示例。       言简意赅，先来一个HelloWorld再说！ 拜访http://activemq.apache.org/ 了解activemq的相关信息，并下载 activemq for windows 了解activemq的快速开始的手册，然后...
java ibm mq 连接池_MQ--API总结
weixin_29628637的博客
02-24 1298
研究MQ很长时间了， 每个类，方法，都查了很长时间，在此总结一下！Java编写访问MQ的程序1、MQQueueManager―――队列管理器访问类常用方法：public MQQueueManager(String queueManagerName)―――建立一个管理器实例创建队列管理器有两种方式：1：绑定方式，这种方式要求MQ服务器与应用程序同属一台服务器，效率比较高。2：客户机方式：这种方式应用...
MQ--API总结
申公的专栏
07-15 9029
研究MQ很长时间了， 每个类，方法，都查了很长时间，在此总结一下！ Java编写访问MQ的程序  1、MQQueueManager―――队列管理器访问类  常用方法：  public MQQueueManager(String queueManagerName)―――建立一个管理器实例  创建队列管理器有两种方式： 1：绑定方式，这种方式要求MQ服务器与应用程序同属一台服务器，效率比较
activemq 连接池
最新发布
06-06
ActiveMQ 提供了多种连接池实现，可以根据自己的需求选择合适的连接池。以下是两种常用的连接池实现： 1. PooledConnectionFactory：这是 ActiveMQ 自带的连接池实现，它是基于 Apache Commons Pool 实现的。使用时只需要创建一个 PooledConnectionFactory 对象，并设置相关参数，然后通过该对象获取 Connection 对象即可。 2. Spring 提供的连接池实现：如果你的项目中使用了 Spring 框架，可以使用 Spring 提供的连接池实现。Spring 提供了多种连接池实现，如 C3P0、DBCP、HikariCP 等，可以根据自己的需求选择合适的连接池实现。使用 Spring 的连接池实现需要在配置文件中定义数据源和连接池相关参数，然后通过 Spring 的 JMS 模板获取 Connection 对象即可。 总的来说，连接池的作用是缓存 Connection 对象，避免频繁地创建和销毁 Connection 对象，从而提高性能和效率。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值