Spring与ActiveMQ的集成详解一

最新推荐文章于 2024-07-16 12:12:15 发布
最新推荐文章于 2024-07-16 12:12:15 发布
阅读量215 收藏
点赞数
分类专栏： ActiveMQ 文章标签： activemq
JMS(ActiveMQ) PTP和PUB/SUB模式实例：[url]http://donald-draper.iteye.com/blog/2347445[/url]
ActiveMQ连接工厂、连接详解:[url]http://donald-draper.iteye.com/blog/2348070[/url]
ActiveMQ会话初始化:[url]http://donald-draper.iteye.com/blog/2348341[/url]
ActiveMQ生产者：[url]http://donald-draper.iteye.com/blog/2348381[/url]
ActiveMQ消费者：[url]http://donald-draper.iteye.com/blog/2348389[/url]
ActiveMQ启动过程详解[url]:http://donald-draper.iteye.com/blog/2348399[/url]
ActiveMQ Broker发送消息给消费者过程详解：[url]http://donald-draper.iteye.com/blog/2348440[/url]
Spring与ActiveMQ的集成：[url]http://donald-draper.iteye.com/blog/2347638[/url]
Spring与ActiveMQ的集成详解一：[url]http://donald-draper.iteye.com/blog/2348449[/url]
Spring与ActiveMQ的集成详解二：[url]http://donald-draper.iteye.com/blog/2348461[/url]
在Spring与ActiveMQ继承这篇文章中，消息的生产和手动消费都是依赖于JmsTemplate，今天我们就来看一
JmsTemplate，
贴上JmsTemplate配置，以便理解 
 <!-- 配置Jms模板  -->  
 <bean id="jmsQueueTemplate"  class="org.springframework.jms.core.JmsTemplate">  
            <property name="connectionFactory" ref="connectionFactoryMQ" />  
            <property name="defaultDestination" ref="testQueue" />  
            <!-- 接收消息时的超时时间 -->
            <!--<property name="receiveTimeout" value="10000" />  --> 
            <!-- 消息类型转换 -->  
        	<property name="messageConverter" ref="msgConverter"></property>  
 </bean> 


 public class JmsTemplate extends JmsDestinationAccessor
    implements JmsOperations
{
    public static final long RECEIVE_TIMEOUT_NO_WAIT = -1L;
    public static final long RECEIVE_TIMEOUT_INDEFINITE_WAIT = 0L;
    private static final Method setDeliveryDelayMethod;
    private final JmsTemplateResourceFactory transactionalResourceFactory;
    private Object defaultDestination;//消息目的地 
    private MessageConverter messageConverter;//消息转换器
    private boolean messageIdEnabled;
    private boolean messageTimestampEnabled;
    private boolean pubSubNoLocal;
    private long receiveTimeout;
    private long deliveryDelay;//传输延时
    private boolean explicitQosEnabled;
    private int deliveryMode;//消息持久化模式
    private int priority;//优先级
    private long timeToLive;//消息生存时间
    static 
    {
       //获取MessageProducer的设置传输延时方法
        setDeliveryDelayMethod = ClassUtils.getMethodIfAvailable(javax/jms/MessageProducer, "setDeliveryDelay", new Class[] {
            Long.TYPE
        });
    }
}

public abstract class JmsDestinationAccessor extends JmsAccessor
{
    private DestinationResolver destinationResolver;//消息目的地解决器
    private boolean pubSubDomain;//是否为订阅主题模式
}

public abstract class JmsAccessor
    implements InitializingBean
{
    private static final Constants sessionConstants = new Constants(javax/jms/Session);
    private ConnectionFactory connectionFactory;//连接工厂
    private boolean sessionTransacted;//是不是事务会话
    private int sessionAcknowledgeMode;//会话确认模式

}

再来看JmsTemplate的构造 
public JmsTemplate()
    {
        transactionalResourceFactory = new JmsTemplateResourceFactory();
        messageIdEnabled = true;
        messageTimestampEnabled = true;
        pubSubNoLocal = false;
        receiveTimeout = 0L;
        deliveryDelay = 0L;
        explicitQosEnabled = false;
        deliveryMode = 2;
        priority = 4;
        timeToLive = 0L;
	//初始化消息转换器
        initDefaultStrategies();
    }
    protected void initDefaultStrategies()
    {
        //初始化消息转换器
        setMessageConverter(new SimpleMessageConverter());
    }


JmsTemplateResourceFactory为JmsTemplate的内部类 
 public class JmsTemplate extends JmsDestinationAccessor
    implements JmsOperations
{
    private class JmsTemplateResourceFactory
        implements org.springframework.jms.connection.ConnectionFactoryUtils.ResourceFactory
    {
        public Connection getConnection(JmsResourceHolder holder)
        {
            return JmsTemplate.this.getConnection(holder);
        }
        public Session getSession(JmsResourceHolder holder)
        {
            return JmsTemplate.this.getSession(holder);
        }
        public Connection createConnection()
            throws JMSException
        {
            return JmsTemplate.this.createConnection();
        }
        public Session createSession(Connection con)
            throws JMSException
        {
            return JmsTemplate.this.createSession(con);
        }
        public boolean isSynchedLocalTransactionAllowed()
        {
            return isSessionTransacted();
        }
        final JmsTemplate this$0;
        private JmsTemplateResourceFactory()
        {
            this$0 = JmsTemplate.this;
            super();
        }
    }
}

从JmsTemplate的构造可以看出，主要是初始化事务资源工厂，消息转换器，传输延时，优先级，消息生存时间
再来看发送消息 
public void send(final Destination destination, final MessageCreator messageCreator)
        throws JmsException
    {
        //创建会话回调接口，发送消息
        execute(new SessionCallback() {

            public Object doInJms(Session session)
                throws JMSException
            {
	        //会话发送消息
                doSend(session, destination, messageCreator);
                return null;
            }

            final Destination val$destination;
            final MessageCreator val$messageCreator;
            final JmsTemplate this$0;


            {
                this.this$0 = JmsTemplate.this;
                destination = destination1;
                messageCreator = messagecreator;
                super();
            }
        }, false);
    }

再来看执行回调接口 
public Object execute(SessionCallback action, boolean startConnection)
        throws JmsException
    {
        Connection conToClose;
        Session sessionToClose;
        Assert.notNull(action, "Callback object must not be null");
        conToClose = null;
        sessionToClose = null;
        Object obj;
        try
        {
	    //从ConnectionFactoryUtils获取事务会话
            Session sessionToUse = ConnectionFactoryUtils.doGetTransactionalSession(getConnectionFactory(), transactionalResourceFactory, startConnection);
            if(sessionToUse == null)
            {
	        //创建连接
                conToClose = createConnection();
		//创建会话
                sessionToClose = createSession(conToClose);
                if(startConnection)
                    conToClose.start();
                sessionToUse = sessionToClose;
            }
            if(logger.isDebugEnabled())
                logger.debug((new StringBuilder()).append("Executing callback on JMS Session: ").append(sessionToUse).toString());
            //执行会话回调接口doInJms方法
	    obj = action.doInJms(sessionToUse);
        }
       //关闭会话
        JmsUtils.closeSession(sessionToClose);
	//释放连接
        ConnectionFactoryUtils.releaseConnection(conToClose, getConnectionFactory(), startConnection);
        return obj;
    }


先看当会话为null时的情况：
创建连接 
conToClose = createConnection();

//JmsAccessor 
protected Connection createConnection()
        throws JMSException
    {
        //从ActiveMQConnectionFactory获取连接ActiveMQConnection
        return getConnectionFactory().createConnection();
    }

创建会话 
sessionToClose = createSession(conToClose);


protected Session createSession(Connection con)
        throws JMSException
    {
        //从ActiveMQConnection获取连接会话ActiveMQSession
        return con.createSession(isSessionTransacted(), getSessionAcknowledgeMode());
    }

当会话不为空的情况：
//ConnectionFactoryUtils 
 public static Session doGetTransactionalSession(ConnectionFactory connectionFactory, ResourceFactory resourceFactory, boolean startConnection)
        throws JMSException
    {
        Assert.notNull(connectionFactory, "ConnectionFactory must not be null");
        Assert.notNull(resourceFactory, "ResourceFactory must not be null");
	//事务同步管理器获取JmsResourceHolder
        JmsResourceHolder resourceHolder = (JmsResourceHolder)TransactionSynchronizationManager.getResource(connectionFactory);
        Connection con;
        if(resourceHolder != null)
        {
	    //如果JmsResourceHolder存在，则从resourceFactory获取会话
            Session session = resourceFactory.getSession(resourceHolder);
            if(session != null)
            {
                if(startConnection)
                {
		    //获取启动，则从resourceFactory获取resourceHolder对应的连接
                    con = resourceFactory.getConnection(resourceHolder);
                    if(con != null)
		        //启动连接
                        con.start();
                }
                return session;
            }
            if(resourceHolder.isFrozen())
                return null;
        }
        if(!TransactionSynchronizationManager.isSynchronizationActive())
            return null;
        JmsResourceHolder resourceHolderToUse = resourceHolder;
        if(resourceHolderToUse == null)
            resourceHolderToUse = new JmsResourceHolder(connectionFactory);
	//从resourceFactory获取resourceHolder对应的连接
        con = resourceFactory.getConnection(resourceHolderToUse);
        Session session = null;
        try
        {
            boolean isExistingCon = con != null;
            if(!isExistingCon)
            {
                con = resourceFactory.createConnection();
                resourceHolderToUse.addConnection(con);
            }
	    //resourceFactory根据连接创建会话
            session = resourceFactory.createSession(con);
	    //将连接与会话关系添加到resourceHolderToUse
            resourceHolderToUse.addSession(session, con);
            if(startConnection)
                con.start();
        }
        if(resourceHolderToUse != resourceHolder)
        {
	    //注册同步器
            TransactionSynchronizationManager.registerSynchronization(new JmsResourceSynchronization(resourceHolderToUse, connectionFactory, resourceFactory.isSynchedLocalTransactionAllowed()));
            //设置事务
	    resourceHolderToUse.setSynchronizedWithTransaction(true);
	    //绑定连接工厂与资源holder的关系
            TransactionSynchronizationManager.bindResource(connectionFactory, resourceHolderToUse);
        }
        return session;
    }

来看从事务同步管理器获取JmsResourceHolder 
JmsResourceHolder resourceHolder = (JmsResourceHolder)TransactionSynchronizationManager.getResource(connectionFactory);
ublic abstract class TransactionSynchronizationManager
{
    private static final ThreadLocal resources = new ThreadLocal();//资源
    private static final ThreadLocal synchronizations = new ThreadLocal();//同步器
    private static final Comparator synchronizationComparator = new OrderComparator();
    private static final ThreadLocal currentTransactionName = new ThreadLocal();//当前事务名
    private static final ThreadLocal currentTransactionReadOnly = new ThreadLocal();//事务读写
    private static final ThreadLocal currentTransactionIsolationLevel = new ThreadLocal();事务级别
    private static final ThreadLocal actualTransactionActive = new ThreadLocal();
    public static Object getResource(Object key)
    {
        Assert.notNull(key, "Key must not be null");
        Map map = (Map)resources.get();
        if(map == null)
            return null;
        Object value = map.get(key);
        if(value != null && logger.isDebugEnabled())
            logger.debug("Retrieved value [" + value + "] for key [" + key + "] bound to thread [" + Thread.currentThread().getName() + "]");
        return value;
    }
}

//事务同步器注册到事务同步管理器 
public static void registerSynchronization(TransactionSynchronization synchronization)
        throws IllegalStateException
    {
        Assert.notNull(synchronization, "TransactionSynchronization must not be null");
        if(!isSynchronizationActive())
        {
            throw new IllegalStateException("Transaction synchronization is not active");
        } else
        {
	    //添加到事务同步管理，同步集
            List synchs = (List)synchronizations.get();
            synchs.add(synchronization);
            return;
        }
    }

//JmsResourceSynchronization 
public abstract class ConnectionFactoryUtils
{
    private static class JmsResourceSynchronization extends ResourceHolderSynchronization
    {
        private final boolean transacted;

        public JmsResourceSynchronization(JmsResourceHolder resourceHolder, Object resourceKey, boolean transacted)
        {
            super(resourceHolder, resourceKey);
            this.transacted = transacted;
        }
    }
}


//ResourceHolderSynchronization 
public abstract class ResourceHolderSynchronization
    implements TransactionSynchronization
{
    private final ResourceHolder resourceHolder;
    private final Object resourceKey;
    private volatile boolean holderActive;
}


绑定连接工厂与资源holder的关系 
TransactionSynchronizationManager.bindResource(connectionFactory, resourceHolderToUse);
//TransactionSynchronizationManager

 public static void bindResource(Object key, Object value)
        throws IllegalStateException
    {
        //从当前线程事务同步化管理获取工厂与资源holder的映射，并将映射关系添加到映射Map中
        Map map = (Map)resources.get();
        if(map == null)
        {
            map = new HashMap();
            resources.set(map);
        }
        if(map.containsKey(key))
            throw new IllegalStateException("Already value [" + map.get(key) + "] for key [" + key + "] bound to thread [" + Thread.currentThread().getName() + "]");
        map.put(key, value);
    }

public class JmsResourceHolder extends ResourceHolderSupport
{
    private ConnectionFactory connectionFactory;//连接工厂
    private boolean frozen;
    private final List connections;//连接
    private final List sessions;//会话
    private final Map sessionsPerConnection;//连接会话映射关系
    public final void addSession(Session session, Connection connection)
    {
        if(!this.sessions.contains(session))
        {   
	   //添加会话
            this.sessions.add(session);
            if(connection != null)
            {
                List sessions = (List)sessionsPerConnection.get(connection);
                if(sessions == null)
                {
                    sessions = new LinkedList();
		    //添加连接会话映射关系
                    sessionsPerConnection.put(connection, sessions);
                }
                sessions.add(session);
            }
        }
    }
}

我们先理一下，TransactionSynchronizationManager，JmsResourceHolder，JmsResourceSynchronization的关系；JmsResourceHolder管理连接，会话，连接工厂，及连接与会话的映射关系，JmsResourceSynchronization为连接工厂和JmsResourceHolder及事务的包装；TransactionSynchronizationManager管理线程的事务JmsResourceSynchronization，
连接工厂和JmsResourceHolder的映射管理。

再来理一下上面这一段说了什么，JmsTemplate发送消息的时候，是将这一过程包装成会话回调接口，然后执行会话回调接口，会话回调结构中有个一参数就是Session，这个Session的获取就是我们上面在讲的，首先从事务同步管理器获取连接工厂对应的JmsResourceHolder，如果JmsResourceHolder存在，则从JmsResourceHolder
获取会话，如果没有则直接从ActiveMQConnectionFactory获取连接及会话

回到执行会话回调接口

来看执行会话回调接口doInJms方法 
obj = action.doInJms(sessionToUse);
 public Object doInJms(Session session)
                throws JMSException
            {
	        //会话发送消息
                doSend(session, destination, messageCreator);
                return null;
            }
 protected void doSend(Session session, Destination destination, MessageCreator messageCreator)
        throws JMSException
    {
        MessageProducer producer;
	//创建生产者
        producer = createProducer(session, destination);
        Message message = messageCreator.createMessage(session);
	//生产者发送消息
        doSend(producer, message);
    }


生产者发送消息 
doSend(producer, message);

protected void doSend(MessageProducer producer, Message message)
        throws JMSException
    {
        if(deliveryDelay > 0L)
        {
            if(setDeliveryDelayMethod == null)
                throw new IllegalStateException("setDeliveryDelay requires JMS 2.0");
            //如果有延时，则延时发送
            ReflectionUtils.invokeMethod(setDeliveryDelayMethod, producer, new Object[] {
                Long.valueOf(deliveryDelay)
            });
        }
        if(isExplicitQosEnabled())
            producer.send(message, getDeliveryMode(), getPriority(), getTimeToLive());
        else
	    //无延时直接发送
            producer.send(message);
    }

再来看发送转换消息 
 public void convertAndSend(Object message)
        throws JmsException
    {
        //获取默认目的地，即我们配置的JmsTemplate的defaultDestination
        Destination defaultDestination = getDefaultDestination();
        if(defaultDestination != null)
            convertAndSend(defaultDestination, message);
        else
            convertAndSend(getRequiredDefaultDestinationName(), message);
    }

    public void convertAndSend(Destination destination, final Object message)
        throws JmsException
    {
        send(destination, new MessageCreator() {

            public Message createMessage(Session session)
                throws JMSException
            {
	        //调用配置JmsTemplate的messageConverter的toMessage方法
                return getRequiredMessageConverter().toMessage(message, session);
            }

            final Object val$message;
            final JmsTemplate this$0;


            {
                this.this$0 = JmsTemplate.this;
                message = obj;
                super();
            }
        });
    }


    public void send(final Destination destination, final MessageCreator messageCreator)
        throws JmsException
    {
        execute(new SessionCallback() {

            public Object doInJms(Session session)
                throws JMSException
            {

	       //委托给doSend(Session session, Destination destination, MessageCreator messageCreator)
                doSend(session, destination, messageCreator);
                return null;
            }

            final Destination val$destination;
            final MessageCreator val$messageCreator;
            final JmsTemplate this$0;


            {
                this.this$0 = JmsTemplate.this;
                destination = destination1;
                messageCreator = messagecreator;
                super();
            }
        }, false);
    }

     protected void doSend(Session session, Destination destination, MessageCreator messageCreator)
        throws JMSException
    {
        MessageProducer producer;
        producer = createProducer(session, destination);
	//调用配置JmsTemplate的messageConverter的toMessage方法
        Message message = messageCreator.createMessage(session);
        if(logger.isDebugEnabled())
            logger.debug((new StringBuilder()).append("Sending created message: ").append(message).toString());
        doSend(producer, message);
    }

小节一下：
JmsTemplate发送消息的时候，是将这一过程包装成会话回调接口，然后执行会话回调接口，会话回调结构中有个一参数就是Session，这个Session的获取就是我们上面在讲的，首先从事务同步管理器获取连接工厂对应的JmsResourceHolder，如果JmsResourceHolder存在，则从JmsResourceHolder获取会话，如果没有则直接从ActiveMQConnectionFactory获取连接及会话，然后由会话创建生产者，有生产者发送消息；对于有消息转换的，则将消息转化器包装到MessageCreator，发送时由MessageCreator，调用消息转换器的消息转化方法，
转换消息，发送消息。

再来看一JmsTemplate的消费消息 
public Message receive()
        throws JmsException
    {
        Destination defaultDestination = getDefaultDestination();
        if(defaultDestination != null)
            return receive(defaultDestination);
    }

    public Message receive(Destination destination)
        throws JmsException
    {
        return receiveSelected(destination, null);
    }
    public Message receiveSelected(final Destination destination, final String messageSelector)
        throws JmsException
    {
        return (Message)execute(new SessionCallback() {

            public Message doInJms(Session session)
                throws JMSException
            {
                return doReceive(session, destination, messageSelector);
            }

            public volatile Object doInJms(Session session)
                throws JMSException
            {
                return doInJms(session);
            }

            final Destination val$destination;
            final String val$messageSelector;
            final JmsTemplate this$0;


            {
                this.this$0 = JmsTemplate.this;
                destination = destination1;
                messageSelector = s;
                super();
            }
        }, true);
    }


这段发送送消息相似，直接忽略掉，直接看接受消息 
doReceive(session, destination, messageSelector);

protected Message doReceive(Session session, Destination destination, String messageSelector)
        throws JMSException
    {
        return doReceive(session, createConsumer(session, destination, messageSelector));
    }

    protected Message doReceive(Session session, MessageConsumer consumer)
        throws JMSException
    {
        Message message1;
        long timeout = getReceiveTimeout();
        JmsResourceHolder resourceHolder = (JmsResourceHolder)TransactionSynchronizationManager.getResource(getConnectionFactory());
        if(resourceHolder != null && resourceHolder.hasTimeout())
            timeout = Math.min(timeout, resourceHolder.getTimeToLiveInMillis());
	//消费消息
        Message message = doReceive(consumer, timeout);
        if(session.getTransacted())
        {
            if(isSessionLocallyTransacted(session))
                JmsUtils.commitIfNecessary(session);
        } else
	//如果需要客户端确认，则调用acknowledge
        if(isClientAcknowledge(session) && message != null)
            message.acknowledge();
        message1 = message;
        JmsUtils.closeMessageConsumer(consumer);
        return message1;
    }
     private Message doReceive(MessageConsumer consumer, long timeout)
        throws JMSException
    {
        if(timeout == -1L)
            return consumer.receiveNoWait();
        if(timeout > 0L)
            return consumer.receive(timeout);
        else
	    //消费者消费消息
            return consumer.receive();
    }
public Object receiveAndConvert()
        throws JmsException
    {
        return doConvertFromMessage(receive());
    }
     protected Object doConvertFromMessage(Message message)
    {
        if(message == null)
            break MISSING_BLOCK_LABEL_22;
	//直接有消息转发器，转换消息
        return getRequiredMessageConverter().fromMessage(message);
        JMSException ex;
        ex;
        throw convertJmsAccessException(ex);
        return null;
    }

消费者手动消费消息分方式同样是包装成会话回调接口，会话获取与生产者发送消息的会话阶段一样，然后从会话创建消费者，消费消息，而转化消息模式，只是将消费者获取的消息通过消息转化器转换一下；

总结：
[color=green]JmsTemplate的构造，主要是初始化事务资源工厂，消息转换器，传输延时，优先级，消息生存时间再来看发送消息。JmsTemplate发送消息的时候，是将这一过程包装成会话回调接口，然后执行会话回调接口，会话回调结构中有个一参数就是Session，这个Session的获取就是我们上面在讲的，首先从事务同步管理器获取连接工厂对应的JmsResourceHolder，如果JmsResourceHolder存在，则从JmsResourceHolder
获取会话，如果没有则直接从ActiveMQConnectionFactory获取连接及会话，然后由会话创建生产者，有生产者发送消息；对于有消息转换的，则将消息转化器包装到MessageCreator，发送时由MessageCreator，调用消息转换器的消息转化方法，转换消息，发送消息。消费者手动消费消息分方式同样是包装成会话回调接口，会话获取与生产者发送消息的会话阶段一样，然后从会话创建消费者，消费消息，而转化消息模式，只是将消费者获取的消息通过消息转化器转换一下；[/color]
iteye_11587
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring JMS和ActiveMQ集成
Scnu_wang的博客
07-31 273
环境：JDK1.8+ActiveMQ 依赖：<dependency> <groupId>org.springframework</groupId> <artifactId>spring-jms</artifactId> <version>4.3.9.RELEASE</version> </dependency>
SpringMVC集成ActiveMQ
嘿の大叔的博客
09-12 395
一、pom文件配置 <!-- activemq --> <dependency> <groupId>org.apache.activemq</groupId> <artifactId>activemq-core</artifactId> <version>5.7.0</version> </dependency>二、配
Spring整合Activemq
m0_62946761的博客
12-24 7649
spring整合activemq
(四) Spring整合ActiveMQ---超详细教程
zxg的博客
11-22 6811
Spring整合ActiveMQ环境配置Spring整合ActiveMQ之队列生产者Spring整合ActiveMQ之队列消费者三级目录 前面三节讲了ActiveMQ的安装、测试。JMS介绍以及四大组成元素，还有ActiveMQ的可靠性（持久化、事务、签收），还有Broker等等。 但是光学会还不够，我们还要把ActiveMQ应用到我们已有的框架中，如Spring和SpringBoot等等。 这一节主要学习如何在Spring中使用ActiveMQ。 环境配置 首先创建一个spring项目，在pom文件中导入
《SpringBoot篇》25.SpringBoot整合ActiveMQ
热门推荐
陈老老老板的博客
01-06 1万+
简介：在先学习整合之前先了解一下ActiaveMQ，ActiveMQ是早期MQ产品之一，是使用JAVA语言编写。大部分现在的项目可能已经不使用，但是公司中的产品咱也说不准，所以还是要学习一下的。简单来说就是用作服务间的通信。Apache ActiveMQ是最流行的开源、多协议、基于Java的消息代理。它支持行业标准协议，因此用户可以在广泛的语言和平台上获得客户端选择的好处。从用JavaScript、C、C++、Python、.Net等编写的客户端连接。使用无处不在的AMQP协议集成多平台应用程序。
ActiveMQ集成
weixin_43708218的博客
08-02 213
1 依赖导入和配置 xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-activemq</artifactId> </dependency> application.yml 配置文件中，对 activemq 做一下配置： spring: activemq: # activemq url
Spring Boot 2.0.3 集成 ActiveMQ 5.15.4 与 内嵌启动 ActiveMQ 服务
蚩尤后裔-汪茂雄
10-12 3462
目录 ActiveMQ 5.15.4 集成 Spring Boot 2.0.3 pom.xml 依赖 application.yml 配置 @JmsListener 接收消息 JmsTemplate 发送消息 运行测试 内嵌启动 ActiveMQ 服务 ActiveMQ 5.15.4 集成 Spring Boot 2.0.3 1、SpringBoot 提供了对 JMS 的支持，对...
spring配置activemq详解
04-06
总之，"spring配置activemq详解"是一个涵盖Spring与ActiveMQ整合的深度话题，涉及了从项目配置到消息生产和消费的全过程。通过理解和实践这些知识点，开发者能够构建出稳定、高效的分布式消息处理系统。
Spring与ActiveMQ整合完整案例
04-03
1. **Spring框架**：Spring是一个全方位的开发框架，提供了依赖注入（Dependency Injection, DI）和面向切面编程（Aspect-Oriented Programming, AOP）等核心特性。通过DI，Spring可以帮助开发者管理对象间的依赖...
详解Java消息队列-Spring整合ActiveMq
08-31
整合ActiveMQ与Spring框架可以使消息处理更加方便，因为Spring提供了对ActiveMQ的内置支持，可以轻松将消息队列集成到Spring应用中。Spring的依赖注入和配置管理使得配置ActiveMQ变得更加简洁，同时，Spring还支持...
Spring和ActiveMQ整合的完整实例
06-19
Spring和ActiveMQ整合的完整实例
SpringIntegrationMQ:spring 集成 - ActiveMQ 示例
06-03
在Java开发中，Spring Integration提供了与ActiveMQ集成的API和配置，使得开发者能够轻松地将消息队列功能引入到Spring应用中。下面将详细介绍Spring Integration与ActiveMQ结合使用的相关知识点： 1. **Spring ...
SpringBoot集成ActiveMQ实例详解.docx
06-26
在本文中，我们将深入探讨如何在Spring Boot应用中集成ActiveMQ，这是一个强大的Java消息服务（JMS）实现。首先，我们需要理解JMS的基本概念。Java消息服务（JMS）是Java平台上的一个标准API，它定义了应用程序如何...
六、Spring/Spring Boot整合ActiveMQ
青啊青斯博客
02-17 1773
Spring/Spring Boot整合ActiveMQ一、Spring整合ActiveMQ1.pom.xml2.Queue - 队列2.1 applicationContext.xml2.2 生产者2.3 消费者3.Topic - 主题3.1 applicationContext.xml3.2 生产者3.3 消费者4.消费者 - 监听器4.1 编写监听器类4.2 配置监听器4.3 生产者+消费者一体二、Spring Boot整合ActiveMQ1.Queue - 队列1.1 生产者1.1.1 创建Mave
SpringBoot（十一） 集成消息队列ActiveMQ
weisian的博客
07-05 788
本例为本地操作消息队列，故需要本地安装ActiveMQ。 1、本地安装ActiveMQ。 （1）、下载地址：http://activemq.apache.org/download.html （2）、解压后，根据电脑操作系统是32位或者64位选择对应的activemq.bat文件，启动ActiveMQ。 启动成功，则显示如下内容 （3）、成功之后在浏览器输入http://127...
Spring整合ActiveMQ
东天里的冬天
12-09 590
1.引入相关jar包 org.apache.activemq activemq-all 5.13.2 org.springframework spring-jm
SpringBoot集成ActiveMQ
清风ai明月的专栏
09-03 2249
springboot集成activemq
ActiveMQ配置延迟投递和定时投递教程
最新发布
余十步的博客
07-16 170
配置activemq.xml中的。
activeMQ.pptx
09-16
它提供了一种与平台无关的方式来访问消息中间件，使得开发者可以使用统一的API与不同的消息系统进行交互，如IBM的MQSeries、BEA的Weblogic JMS service和Progress的SonicMQ等。 JMS的核心模型包括点对点（Point-to-...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值