消息中间件-activemq实战之整合Spring(四)

最新推荐文章于 2024-08-06 15:44:50 发布
最新推荐文章于 2024-08-06 15:44:50 发布
阅读量2.7k 收藏 5
点赞数 1
分类专栏： 消息中间件 文章标签： 消息中间件 activemq jms
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a953713428/article/details/71190769
版权

前面的理论准备已经很充分，这一节我们来实战：将activemq整合到Spring框架才行中，因为Spring已经集成了JMS，这也为我们配置activermq带来了方便。

1. Spring对jms的支持

因为Spring已经将JMS集成到框架里面了，对jms做了自己的封装，我们使用起来更加方便，在Spring中使用jms比较麻烦的就是配置，在Spring中配置JMS大体需要8个部分：

  1. ConnectionFactory： 和jms服务器的连接, 可以是外部的jms server, 也可以使用embedded ActiveMQ Broker；
  2. Destination： 有topic和queue两种方式；
  3. JmsTemplate： spring提供的jms模板；
  4. MessageConverter： 消息转换器；
  5. MessageProducer： 消息生产者；
  6. MessageConsumer： 消息消费者；
  7. MessageListener： 消息监听器；
  8. MessageListenerContainer： 消息监听容器。

下面我把完整的配置文件按照上面的步骤拆开分别讲解：

1.1首先我们配置ConnectionFactory：

<amq:connectionFactory id="amqConnectionFactory"
                       brokerURL="tcp://127.0.0.1:61616"
                       userName="admin"
                       password="admin" />

brokerURL是指要连接的activeMQ server的地址，该配置即使用activemq独立的消息存储环境，即使服务器重启消息也不会丢失。

<!-- 配置JMS连接工厂 -->
<bean id="connectionFactory"
      class="org.springframework.jms.connection.CachingConnectionFactory">
    <constructor-arg ref="amqConnectionFactory" />
    <property name="sessionCacheSize" value="100" />
</bean>

我们从Spring给我们提供的connectionFactory中获取Connection，并且把该connectionFactory注册到上面定义的activemq server中。

1.2 Destination：

由前面我们知道Destination有两种形式：P2P和Pub/Sub。那么在配置中表示就是：

 <!-- 定义消息队列（Queue） -->
<bean id="demoQueueDestination" class="org.apache.activemq.command.ActiveMQQueue">
    <!-- 设置消息队列的名字 -->
    <constructor-arg>
        <value>first-queue</value>
    </constructor-arg>
</bean>

或：

<!-- 定义消息队列（topic） -->
<bean id="demoQueueDestination" class="org.apache.activemq.command.ActiveMQTopic">
    <!-- 设置消息队列的名字 -->
    <constructor-arg>
        <value>first-queue</value>
    </constructor-arg>
</bean>

1.3 JmsTemplate：

将connectionFactory和defaultDestination注入JmsTemplate中：

<!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 -->
<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
    <property name="connectionFactory" ref="connectionFactory" />
    <property name="defaultDestination" ref="demoQueueDestination" />
    <property name="receiveTimeout" value="10000" />
    <!-- true是topic，false是queue，默认是false，此处显示写出false -->
    <property name="pubSubDomain" value="false" />
</bean>

在Java相关处理文件中添加(这里用的是@Inject注解，当然也可以用@Autowired)：

@Resource(name="jmsTemplate")
private JmsTemplate jmsTemplate;

TextMessage textMessage = (TextMessage) jmsTemplate.receive(destination);

1.4 MessageConverter

MessageConverter实现的是org.springframework.jms.support.converter.MessageConverter接口, 提供消息的转换功能。

<bean id="defaultMessageConverter" class="cn.edu.hust.activemq.filter.DefaultMessageConverter" />

1.5 MessageProducer和MessageConsumer

此处灵活使用，可以以服务的形式提供也可以以工具类的形式提供，详情见下面的示例代码。

1.6 MessageListener

消息的消费者应有的有对应的Listener。

 <!-- 配置消息队列监听者（Queue） -->
 <bean id="queueMessageListener" class="cn.edu.hust.activemq.filter.QueueMessageListener" />

1.7 MessageListenerContainer

MessageListenerContainer即Listener的容器，用来对Listener坐一些配置，每一个listener都对应着一个Container：

<!-- 显示注入消息监听容器（Queue），配置连接工厂，监听的目标是demoQueueDestination，监听器是上面定义的监听器 -->
<bean id="queueListenerContainer"
      class="org.springframework.jms.listener.DefaultMessageListenerContainer">
    <property name="connectionFactory" ref="connectionFactory" />
    <property name="destination" ref="demoQueueDestination" />
    <property name="messageListener" ref="queueMessageListener" />
</bean>

Spring为我们听过了两种类型的MessageListenerContainer：SimpleMessageListenerContainer和DefaultMessageListenerContainer。

  • SimpleMessageListenerContainer会在一开始的时候就创建一个会话Session和消费者Consumer，并且会适用标准的JMS的MessageConsumer.setMessageListener()方法注册监听器让JMS提供调用监听器的回调函数。它不会动态的适应运行时需要和参与外部的事务管理。兼容性方面，它非常接近于独立的JMS规范，但一般不兼容J2EE的JMS限制。大多数情况下，我们还是使用DefaultMessageListenerContainer。
  • DefaultMessageListenerContainer，与SimpleMessageListenerContainer相比，它会动态的适应运行时的需求，并且能够参与外部的事务管理。

上面就是mq的配置文件部分，如果从上到下的配置部分都清楚地话使用起来肯定没有问题，我们再做一个简要的总结：

  1. 可以有一个或者多个消息生产者向同一个destination发送消息；
  2. queue类型的只能有一个消息消费者；
  3. topic类型的可以有多个消息消费者；
  4. 每个消费者对应一个MessageListener和一个MessageListenerContainer。

下面我们看一下整合的全部代码：

首先上pom.xml看一下依赖的jar包：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>q</groupId>
  <artifactId>q</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>q Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <properties>
    <springframework>4.3.0.RELEASE</springframework>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.10</version>
      <scope>test</scope>
    </dependency>
    <!-- spring -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${springframework}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${springframework}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${springframework}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${springframework}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jms</artifactId>
      <version>${springframework}</version>
    </dependency>
    <!-- xbean 如<amq:connectionFactory /> -->
    <dependency>
      <groupId>org.apache.xbean</groupId>
      <artifactId>xbean-spring</artifactId>
      <version>3.16</version>
    </dependency>

    <!-- activemq -->
    <dependency>
      <groupId>org.apache.activemq</groupId>
      <artifactId>activemq-core</artifactId>
      <version>5.7.0</version>
    </dependency>
    <dependency>
      <groupId>org.apache.activemq</groupId>
      <artifactId>activemq-pool</artifactId>
      <version>5.12.1</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>q</finalName>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.6</source>
          <target>1.6</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

然后是我们的Spring配置文件applicationContext.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!-- 查找最新的schemaLocation 访问 http://www.springframework.org/schema/ -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">

    <!-- 指定Sping组件扫描的基本包路径 -->
    <context:component-scan base-package="cn.edu.hust.activemq" >
        <!-- 这里只扫描Controller，不可重复加载Service -->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
    <!-- 启用MVC注解 -->
    <mvc:annotation-driven />

    <!-- JSP视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/" />
        <property name="suffix" value=".jsp" />
        <!--  定义其解析视图的order顺序为1 -->
        <property name="order" value="1" />
    </bean>
</beans>

activemq的配置文件applicationContext-ActiveMQ.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:amq="http://activemq.apache.org/schema/core"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.1.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
http://activemq.apache.org/schema/core
http://activemq.apache.org/schema/core/activemq-core-5.12.1.xsd">

    <context:component-scan base-package="cn.edu.hust.activemq" />
    <mvc:annotation-driven />

    <amq:connectionFactory id="amqConnectionFactory"
                           brokerURL="tcp://127.0.0.1:61616"
                           userName="admin"
                           password="admin" />

    <!-- 配置JMS连接工厂 -->
    <bean id="connectionFactory"
          class="org.springframework.jms.connection.CachingConnectionFactory">
        <constructor-arg ref="amqConnectionFactory" />
        <property name="sessionCacheSize" value="100" />
    </bean>

    <!-- 定义消息队列（Queue） -->
    <bean id="demoQueueDestination" class="org.apache.activemq.command.ActiveMQQueue">
        <!-- 设置消息队列的名字 -->
        <constructor-arg>
            <value>first-queue</value>
        </constructor-arg>
    </bean>

    <!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="defaultDestination" ref="demoQueueDestination" />
        <property name="receiveTimeout" value="10000" />
        <!-- true是topic，false是queue，默认是false，此处显示写出false -->
        <property name="pubSubDomain" value="false" />
    </bean>

    <!-- 配置消息队列监听者（Queue） -->
    <bean id="queueMessageListener" class="cn.edu.hust.activemq.filter.QueueMessageListener" />

    <!-- 显示注入消息监听容器（Queue），配置连接工厂，监听的目标是demoQueueDestination，监听器是上面定义的监听器 -->
    <bean id="queueListenerContainer"
          class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="destination" ref="demoQueueDestination" />
        <property name="messageListener" ref="queueMessageListener" />
    </bean>

</beans>

配置的介绍在上面我已经讲过了，不明白的地方翻到上面去看看。

web.xml文件的配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
          http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">
<display-name>Archetype Created Web Application</display-name>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext-ActiveMQ.xml</param-value>
    </context-param>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- 处理编码格式 -->
    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

我们的工程目录结构如下：

这里写图片描述

上service的代码：

ProducerService.java

import javax.jms.Destination;


/**
 * Created by Administrator on 2017/5/3.
 */
public interface ProducerService {

    void sendMessage(Destination destination,final String msg);

    void sendMessage(final String msg);
}

ProducerServiceImpl.java

import cn.edu.hust.activemq.service.ProducerService;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Service;

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

/**
 * Created by Administrator on 2017/5/3.
 */
@Service
public class ProducerServiceImpl implements ProducerService {

    @Resource(name="jmsTemplate")
    private JmsTemplate jmsTemplate;

    @Override
    public void sendMessage(Destination destination, final String msg) {
        System.out.println(Thread.currentThread().getName()+" 向队列"+destination.toString()+"发送消息--------->"+msg);
        jmsTemplate.send(destination, new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(msg);
            }
        });
    }

    @Override
    public void sendMessage(final String msg) {
        String destination = jmsTemplate.getDefaultDestinationName();
        System.out.println(Thread.currentThread().getName()+" 向队列"+destination+"发送消息-------->"+msg);
        jmsTemplate.send(new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(msg);
            }
        });
    }
}

ConsumerService.java

import javax.jms.Destination;
import javax.jms.TextMessage;
/**
 * Created by Administrator on 2017/5/3.
 */
public interface ConsumerService {

    TextMessage receive(Destination destination);
}

ConsumerServiceImpl.java

import cn.edu.hust.activemq.service.ConsumerService;

import javax.jms.Destination;
import javax.jms.TextMessage;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.jms.JMSException;

/**
 * Created by Administrator on 2017/5/3.
 */
@Service
public class ConsumerServiceImpl implements ConsumerService {
    @Resource(name="jmsTemplate")
    private JmsTemplate jmsTemplate;

    @Override
    public TextMessage receive(Destination destination){
        TextMessage textMessage = (TextMessage) jmsTemplate.receive(destination);
        try{
            System.out.println("从队列" + destination.toString() + "收到了消息：\t"
                    + textMessage.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
        return textMessage;
    }
}

QueueMessageListener.java

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

/**
 * Created by Administrator on 2017/5/3.
 */
public class QueueMessageListener implements MessageListener {
    public void onMessage(Message message) {
        TextMessage tm = (TextMessage) message;
        try {
            System.out.println("QueueMessageListener监听到了文本消息：\t"
                    + tm.getText());
            //do something ...
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

接下来是controller:

import cn.edu.hust.activemq.service.ConsumerService;
import cn.edu.hust.activemq.service.ProducerService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import javax.jms.Destination;
import javax.jms.TextMessage;

/**
 * Created by Administrator on 2017/5/3.
 */
@Controller
public class MessageController {
    private Logger logger = LoggerFactory.getLogger(MessageController.class);
    @Resource(name = "demoQueueDestination")
    private Destination destination;

    //队列消息生产者
    @Resource
    private ProducerService producer;

    //队列消息消费者
    @Resource
    private ConsumerService consumer;

    @RequestMapping(value = "/SendMessage", method = RequestMethod.GET)
    @ResponseBody
    public void send(String msg) {
        logger.info(Thread.currentThread().getName()+"------------开始发送消息");
        producer.sendMessage(msg);
        logger.info(Thread.currentThread().getName()+"------------发送完毕");
    }

    @RequestMapping(value= "/ReceiveMessage",method = RequestMethod.GET)
    @ResponseBody
    public Object receive(){
        logger.info(Thread.currentThread().getName()+"------------开始接受消息");
        TextMessage tm = consumer.receive(destination);
        logger.info(Thread.currentThread().getName()+"------------接受完毕");
        return tm;
    }

}

代码就是上面这些，我们先启动acticemq server，然后下启动工程，在地址栏中输入：http://localhost:8080/SendMessage?msg=nihao，
代码很简单我就没有写前台页面啦，msg部分你可以随便写。回车之后我们去看一下控制台消息就发送出去了。

这里写图片描述

rickiyang
关注
专栏目录
ActiveMq 基础实战
mulinsen77的博客
01-09 1106
开始实战之前，我们先来看一下JMS的基础 知识： 消息中间件初识 然后进入敲代码阶段： 队列模式： 首先我们来创建一个队列模式的ActiveMq。 AppProducer的代码如下： package com.martina.jms.test1; import org.apache.activemq.ActiveMQConnectionFactory; import javax.jms.*; ...
Spring整合ActiveMq
马小果v:ma-xiaoguo的博客
02-19 862
1、概述 多种语言和协议编写客户端。语言: Java, C, C++, C#, Ruby, Perl, Python, PHP。应用协议: OpenWire,Stomp REST,WS Notification,XMPP,AMQP 完全支持JMS1.1和J2EE 1.4规范 (持久化,XA消息,事务) 对Spring的支持,ActiveMQ可以很容易内嵌到使用Spring的系统里面去,而且也支持Spring2.0的特性 通过了常见J2EE服务器(如 Geronimo,JBoss 4, GlassFish,W
C# ActiveMQ 和Spring.NET框架开发示例
04-26
C#下使用消息中间件 ActiveMQ 和Spring.NET框架开发示例
深入浅出JMS(四)--Spring和ActiveMQ整合的完整实例
专栏
10-21 133
深入浅出JMS(四)--Spring和ActiveMQ整合的完整实例  
RabbitMQ 消息队列中间件详解
最新发布
heyongjin22的博客
08-06 1307
RabbitMQ是一个开源的消息队列中间件，实现了高级消息队列协议（AMQP）。它主要用于异步通信、任务调度和负载均衡等场景，广泛应用于分布式系统中。RabbitMQ由Erlang编写，具有高并发、高可用和高可靠性的特点。RabbitMQ作为一款强大的消息队列中间件，广泛应用于各种分布式系统中。本文详细介绍了RabbitMQ的基本概念、安装配置方法以及在Java环境下的使用示例。希望有疑问和补充欢迎大家在评论区探讨。
中间件-------activityMQ整合springboot
wenge1477的博客
08-01 815
springboot整合activityMQ 启动activityMQ 创建项目 添加maven的依赖，导入相应的jar包 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w...
ActiveMQ实战：安装与配置详解
程序员光剑
01-28 1720
1.背景介绍 1. 背景介绍 Apache ActiveMQ 是一个开源的消息中间件，它提供了一种高效、可靠的消息传递机制，使得多个应用程序之间可以轻松地交换信息。ActiveMQ 支持多种消息传递协议，如 JMS、AMQP、MQTT 等，可以满足不同应用程序的需求。 在现代软件架构中，消息中间件是一种常见的设计模式，它可以解耦应用程序之间的通信，提高系统的可扩展性和可靠性。ActiveMQ...
spring-activeMQ-demo:spring-activeMQ-演示
05-07
在"spring-activeMQ-demo"中，我们可以看到如何设置消息生产者（发送消息）和消费者（接收消息）的代码实例，以及如何在Spring环境中启动和关闭ActiveMQ连接。这个例子是学习和理解Spring与ActiveMQ整合的绝佳起点，...
ActiveMQ 入门实战(3)--SpringBoot 整合 ActiveMQ（csdn）————程序.pdf
12-01
- **ActiveMQ**：Apache ActiveMQ 是一个开源的消息中间件，它实现了 Java Message Service (JMS) 规范，提供可靠的消息传递和队列管理。 - **JMS**：Java Message Service 是一个标准接口，用于在分布式环境中交换...
消息中间件-RabbitMQ 实战教程
qq_45770532的博客
07-18 822
1 什么是消息中间件 1.1消息中间件(MQ)的定义     一般认为，消息中间件属于分布式系统中一个子系统，关注于数据的发送和接收，利用高效可靠的异步消息传递机制对分布式系统中的其余各个子系统进行集成。 高效：对于消息的处理处理速度快。 可靠：一般消息中间件都会有消息持久化机制和其他的机制确保消息不丢失。 异步：指发送完一个请求，不需要等待返回，随时可以再发送下一个请求，既不需要等待。     消息中间件不生产消息，只是消息的搬运工。 1.2 消息中间件的组成 1) Broker     消息服务器，作为
2小时学会Spring+Dubbo整合ActiveMQ消息队列
06-18
让你更了解互联网是如何解决高并发 学完SSM框架的同学就可以学习,能让你切身感受到企业级开发环境目标1：理解消息中间件、JMS等概念目标2：掌握JMS点对点与发布订阅模式的收发消息目标3：掌握SpringJms目标4：完成...
ActiveMQ实战(英文版)
01-05
ActiveMQ实战(英文版) ActiveMQ实战(英文版) ActiveMQ实战(英文版)
ActiveMQ-jms jar包
07-30
包含这两个javax.jms.jar javax.management.j2ee-api-1.1.1.jar
Spring和ActiveMQ整合的完整实例
06-19
Spring和ActiveMQ整合的完整实例
消息中间件-ACTIVEMQ-5：ActiveMQ和Spring整合
苍煜
09-07 391
目录 1：导包 2：写配置-applicationContext.xml 3：测试 3.1：生产者 3.2：消费者 注：此时如果想向主题发送，那么在配置文件中配置jmsTemplate的地方将目的地换了就行，但是必须先启动消费者 4：创建监听器，监听主题/队列中的信息并处理 4.1：编写监听器 4.2：配置监听器 4.3：进行测试 1：测试主题 2：测试队列 1：导包 <?xml version="1.0" encoding="UTF-8"?> <pr.
ActiveMQ消息中间件和Spring框架整合--队列模式和发布订阅模式
zzzgd_666的博客
06-17 652
1.使用方法 官方网站：http://activemq.apache.org/ 下载最新版本 解压 启动 bin/win64/activemq.bat 访问 http://127.0.0.1:8161/admin/ 用户和密码都是admin pom的依赖坐标 &lt;dependencies&gt; &lt;dependency&gt; &lt;grou...
消息中间件ActiveMQ的简单使用-Spring整合开发(1)
又又又又的博客
09-17 110
1.引入Spring整合ActivwMQ开发的maven坐标 <!-- spring 与 mq整合 start --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jms</artifactId> <v...
ActiveMQ介绍及Spring整合实例
poorCoder_的博客
03-10 3975
前言ActiveMQ 是Apache出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现。主要解决进场通讯，应用耦合，流量削锋。实现高性能，高可用，可伸缩和最终一致性架构。异步消息是一个应用程序向另外一个应用程序间接发送消息的一种方式，这种方式无需等待对方的相应。比如用户注册之后发送短信，秒杀程序的流量削锋，聊天室
消息中间件RabbitMQ-实战一
伍意的博客
06-02 1381
1.安装erlang环境 http://www.erlang.org/downloads apt-get install erlang yum install erlang 2.安装rabbitmq apt-get install rabbitmq-server http://www.rabbitmq.com/download.html 3.创建用户 (自己编译rabbitmq-s
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值