activemq_activemq 周阳 - CSDN
activemq 订阅
Apache ActiveMQ是Apache软件基金会所研发的开放源代码消息中间件;由于ActiveMQ是一个纯Java程序,因此只需要操作系统支持Java虚拟机,ActiveMQ便可执行。 展开全文
Apache ActiveMQ是Apache软件基金会所研发的开放源代码消息中间件;由于ActiveMQ是一个纯Java程序,因此只需要操作系统支持Java虚拟机,ActiveMQ便可执行。
信息
支持系统
windows,linux
支持语言
Java,C,C++,C#,Python,Ruby,Perl
外文名
Apache ActiveMQ
出品厂商
Apache
中文名
ActiveMQ
支持规范
JMS1.1,J2EE 1.4 AMQP 1.0
应用协议
OpenWire,Stomp REST
ActiveMQ简介
Apache ActiveMQ是Apache软件基金会所研发的开放源代码消息中间件;由于ActiveMQ是一个纯Java程序,因此只需要操作系统支持Java虚拟机,ActiveMQ便可执行。 [1] 
收起全文
精华内容
参与话题
  • ActiveMQ详解

    千次阅读 2018-07-31 08:34:20
    ActiveMQ 消息中间件概述 1.1消息中间件产生的背景 在客户端与服务器进行通讯时.客户端调用后,必须等待服务对象完成处理返回结果才能继续执行。  客户与服务器对象的生命周期紧密耦合,客户进程和服务对象进程...

    ActiveMQ

    • 消息中间件概述

    1.1消息中间件产生的背景

    在客户端与服务器进行通讯时.客户端调用后,必须等待服务对象完成处理返回结果才能继续执行。

     客户与服务器对象的生命周期紧密耦合,客户进程和服务对象进程都都必须正常运行;如果由于服务对象崩溃或者网络故障导致用户的请求不可达,客户会受到异常

    点对点通信: 客户的一次调用只发送给某个单独的目标对象。

    1.2 什么是消息中间件


    面向消息的中间件(MessageOrlented MiddlewareMOM)较好的解决了以上问
    题。发送者将消息发送给消息服务器,消息服务器将消感存放在若千队列中,在合适
    的时候再将消息转发给接收者。

    这种模式下,发送和接收是异步的,发送者无需等
    待;
     二者的生命周期未必相同: 发送消息的时候接收者不一定运行,接收消息的时候
    发送者也不一定运行;一对多通信:
     对于一个消息可以有多个接收者。

    二 、JMS介绍

    2.1 什么是JMS?

    JMS是java的消息服务,JMS的客户端之间可以通过JMS服务进行异步的消息传输。

    2.2 什么是消息模型

    ○ Point-to-Point(P2P) --- 点对点

    ○ Publish/Subscribe(Pub/Sub)---  发布订阅

    即点对点和发布订阅模型

     

    2.2.1 P2P (点对点)

    P2P

    1. P2P模式图 
    2. 涉及到的概念 
       
      1. 消息队列(Queue)
      2. 发送者(Sender)
      3. 接收者(Receiver)
      4. 每个消息都被发送到一个特定的队列,接收者从队列中获取消息。队列保留着消息,直到他们被消费或超时。
    3. P2P的特点
      1. 每个消息只有一个消费者(Consumer)(即一旦被消费,消息就不再在消息队列中)
      2. 发送者和接收者之间在时间上没有依赖性,也就是说当发送者发送了消息之后,不管接收者有没有正在运行,它不会影响到消息被发送到队列
      3. 接收者在成功接收消息之后需向队列应答成功

    如果你希望发送的每个消息都应该被成功处理的话,那么你需要P2P模式。

    应用场景

    A用户与B用户发送消息

     

     

    2.2.2Pub/Sub (发布与订阅)

    Pub/Sub模式图 

    涉及到的概念 
     

    主题(Topic)

    发布者(Publisher)

    订阅者(Subscriber) 
    客户端将消息发送到主题。多个发布者将消息发送到Topic,系统将这些消息传递给多个订阅者。

    Pub/Sub的特点

    每个消息可以有多个消费者

    发布者和订阅者之间有时间上的依赖性。针对某个主题(Topic)的订阅者,它必须创建一个订阅者之后,才能消费发布者的消息,而且为了消费消息,订阅者必须保持运行的状态。

    为了缓和这样严格的时间相关性,JMS允许订阅者创建一个可持久化的订阅。这样,即使订阅者没有被激活(运行),它也能接收到发布者的消息。

    如果你希望发送的消息可以不被做任何处理、或者被一个消息者处理、或者可以被多个消费者处理的话,那么可以采用Pub/Sub模型

    消息的消费 
    在JMS中,消息的产生和消息是异步的。对于消费来说,JMS的消息者可以通过两种方式来消费消息。 
    ○ 同步 
    订阅者或接收者调用receive方法来接收消息,receive方法在能够接收到消息之前(或超时之前)将一直阻塞 
    ○ 异步 
    订阅者或接收者可以注册为一个消息监听器。当消息到达之后,系统自动调用监听器的onMessage方法。

      应用场景:

       用户注册、订单修改库存、日志存储

       画图演示

    三、 MQ产品的分类

     

    RabbitMQ

    是使用Erlang编写的一个开源的消息队列,本身支持很多的协议:AMQPXMPP, SMTP, STOMP,也正是如此,使的它变的非常重量级,更适合于企业级的开发。同时实现了一个经纪人(Broker)构架,这意味着消息在发送给客户端时先在中心队列排队。对路由(Routing),负载均衡(Load balance)或者数据持久化都有很好的支持。

    Redis

    是一个Key-ValueNoSQL数据库,开发维护很活跃,虽然它是一个Key-Value数据库存储系统,但它本身支持MQ功能,所以完全可以当做一个轻量级的队列服务来使用。对于RabbitMQRedis的入队和出队操作,各执行100万次,每10万次记录一次执行时间。测试数据分为128Bytes512Bytes1K10K四个不同大小的数据。实验表明:入队时,当数据比较小时Redis的性能要高于RabbitMQ,而如果数据大小超过了10KRedis则慢的无法忍受;出队时,无论数据大小,Redis都表现出非常好的性能,而RabbitMQ的出队性能则远低于Redis

     

    入队

    出队

     

    128B

    512B

    1K

    10K

    128B

    512B

    1K

    10K

    Redis

    16088

    15961

    17094

    25

    15955

    20449

    18098

    9355

    RabbitMQ

    10627

    9916

    9370

    2366

    3219

    3174

    2982

    1588

    ZeroMQ

    号称最快的消息队列系统,尤其针对大吞吐量的需求场景。ZMQ能够实现RabbitMQ不擅长的高级/复杂的队列,但是开发人员需要自己组合多种技术框架,技术上的复杂度是对这MQ能够应用成功的挑战。ZeroMQ具有一个独特的非中间件的模式,你不需要安装和运行一个消息服务器或中间件,因为你的应用程序将扮演了这个服务角色。你只需要简单的引用ZeroMQ程序库,可以使用NuGet安装,然后你就可以愉快的在应用程序之间发送消息了。但是ZeroMQ仅提供非持久性的队列,也就是说如果down机,数据将会丢失。其中,TwitterStorm中使用ZeroMQ作为数据流的传输。

    ActiveMQ

    Apache下的一个子项目。 类似于ZeroMQ,它能够以代理人和点对点的技术实现队列。同时类似于RabbitMQ,它少量代码就可以高效地实现高级应用场景。RabbitMQZeroMQActiveMQ均支持常用的多种语言客户端 C++Java.Net,Python Php Ruby等。

    Jafka/Kafka

    KafkaApache下的一个子项目,是一个高性能跨语言分布式Publish/Subscribe消息队列系统,而Jafka是在Kafka之上孵化而来的,即Kafka的一个升级版。具有以下特性:快速持久化,可以在O(1)的系统开销下进行消息持久化;高吞吐,在一台普通的服务器上既可以达到10W/s的吞吐速率;完全的分布式系统,BrokerProducerConsumer都原生自动支持分布式,自动实现复杂均衡;支持Hadoop数据并行加载,对于像Hadoop的一样的日志数据和离线分析系统,但又要求实时处理的限制,这是一个可行的解决方案。Kafka通过Hadoop的并行加载机制来统一了在线和离线的消息处理,这一点也是本课题所研究系统所看重的。Apache Kafka相对于ActiveMQ是一个非常轻量级的消息系统,除了性能非常好之外,还是一个工作良好的分布式系统。

    其他一些队列列表HornetQApache QpidSparrowStarlingKestrelBeanstalkdAmazon SQS就不再一一分析。

    四、 ActiveMQ使用

    4.1 、window下 ActiveMQ安装

    ActiveMQ部署其实很简单,和所有Java一样,要跑java程序就必须先安装JDK并配置好环境变量,这个很简单。

    然后解压下载的apache-activemq-5.10-20140603.133406-78-bin.zip压缩包到一个目录,得到解压后的目录结构如下图:

    进入bin目录,发现有win32win64两个文件夹,这2个文件夹分别对应windows32位和windows64位操作系统的启动脚本。

    我的实验环境是windowsXP,就进入win32目录,会看到如下目录结构。

    其中activemq.bat便是启动脚本,双击启动。

    ActiveMQ默认启动到8161端口,启动完了后在浏览器地址栏输入:http://localhost:8161/admin要求输入用户名密码,默认用户名密码为admin、admin,这个用户名密码是在conf/users.properties中配置的。输入用户名密码后便可看到如下图的ActiveMQ控制台界面了。

    4.1.1控制台介绍

    Number Of Consumers  消费者 这个是消费者端的消费者数量 
    Number Of Pending Messages 等待消费的消息 这个是当前未出队列的数量。可以理解为总接收数-总出队列数 
    Messages Enqueued 进入队列的消息  进入队列的总数量,包括出队列的。 这个数量只增不减 
    Messages Dequeued 出了队列的消息  可以理解为是消费这消费掉的数量 
    这个要分两种情况理解 
    在queues里它和进入队列的总数量相等(因为一个消息只会被成功消费一次),如果暂时不等是因为消费者还没来得及消费。 
    在 topics里 它因为多消费者从而导致数量会比入队列数高。 
    简单的理解上面的意思就是 
    当有一个消息进入这个队列时,等待消费的消息是1,进入队列的消息是1。 
    当消息消费后,等待消费的消息是0,进入队列的消息是1,出队列的消息是1. 
    在来一条消息时,等待消费的消息是1,进入队列的消息就是2. 


    没有消费者时  Pending Messages   和 入队列数量一样 
    有消费者消费的时候 Pedding会减少 出队列会增加 
    到最后 就是 入队列和出队列的数量一样多 
    以此类推,进入队列的消息和出队列的消息是池子,等待消费的消息是水流。 

    4.2 、实现点对点通讯模式

     使用ActiveMQ完成点对点(p2p)通讯模式

    引入pom文件依赖

      <dependencies>

            <dependency>

                <groupId>org.apache.activemq</groupId>

                <artifactId>activemq-core</artifactId>

                <version>5.7.0</version>

            </dependency>

        </dependencies>

     

    生产者

    public class Producter {

          public static void main(String[] args) throws JMSException {

               // ConnectionFactory :连接工厂,JMS 用它创建连接

               ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER,

                          ActiveMQConnection.DEFAULT_PASSWORD, "tcp://127.0.0.1:61616");

               // JMS 客户端到JMS Provider 的连接

               Connection connection = connectionFactory.createConnection();

               connection.start();

               // Session 一个发送或接收消息的线程

               Session session = connection.createSession(Boolean.falst, Session.AUTO_ACKNOWLEDGE);

               // Destination :消息的目的地;消息发送给谁.

               // 获取session注意参数值my-queueQuery的名字

               Destination destination = session.createQueue("my-queue");

               // MessageProducer:消息生产者

               MessageProducer producer = session.createProducer(destination);

               // 设置不持久化

               producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

               // 发送一条消息

               for (int i = 1; i <= 5; i++) {

                     sendMsg(session, producer, i);

               }

               session.commit();

               connection.close();

          }

          /**

           * 在指定的会话上,通过指定的消息生产者发出一条消息

           *

           * @param session

           *            消息会话

           * @param producer

           *            消息生产者

           */

          public static void sendMsg(Session session, MessageProducer producer, int i) throws JMSException {

               // 创建一条文本消息

               TextMessage message = session.createTextMessage("Hello ActiveMQ" + i);

               // 通过消息生产者发出消息

               producer.send(message);

          }

    }

    消费者

    public class JmsReceiver {

          public static void main(String[] args) throws JMSException {

               // ConnectionFactory :连接工厂,JMS 用它创建连接

               ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER,

                          ActiveMQConnection.DEFAULT_PASSWORD, "tcp://127.0.0.1:61616");

               // JMS 客户端到JMS Provider 的连接

                Connection connection = connectionFactory.createConnection();

               connection.start();

               // Session 一个发送或接收消息的线程

               Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);

               // Destination :消息的目的地;消息发送给谁.

               // 获取session注意参数值xingbo.xu-queue是一个服务器的queue,须在在ActiveMqconsole配置

               Destination destination = session.createQueue("my-queue");

               // 消费者,消息接收者

               MessageConsumer consumer = session.createConsumer(destination);

               while (true) {

                     TextMessage message = (TextMessage) consumer.receive();

                     if (null != message) {

                          System.out.println("收到消息:" + message.getText());

                          session.commit();

                     } else

                          break;

               }

               session.close();

               connection.close();

          }

    }

     

     

    4.3 、JMS消息可靠机制

    ActiveMQ消息签收机制:

    客戶端成功接收一条消息的标志是一条消息被签收,成功应答。

    消息的签收情形分两种:

    1、带事务的session

       如果session带有事务,并且事务成功提交,则消息被自动签收。如果事务回滚,则消息会被再次传送。

    2、不带事务的session

       不带事务的session的签收方式,取决于session的配置。

       Activemq支持一下三種模式:

       Session.AUTO_ACKNOWLEDGE  消息自动签收

     

       Session.CLIENT_ACKNOWLEDGE  客戶端调用acknowledge方法手动签收

    textMessage.acknowledge();//手动签收

       Session.DUPS_OK_ACKNOWLEDGE 不是必须签收,消息可能会重复发送。在第二次重新传送消息的时候,消息

    只有在被确认之后,才认为已经被成功地消费了。消息的成功消费通常包含三个阶段:客户接收消息、客户处理消息和消息被确认。 在事务性会话中,当一个事务被提交的时候,确认自动发生。在非事务性会话中,消息何时被确认取决于创建会话时的应答模式(acknowledgement mode)。该参数有以下三个可选值:
     

     

     

     

    Number Of Consumers  消费者 这个是消费者端的消费者数量 

    Number Of Pending Messages 等待消费的消息 这个是当前未出队列的数量。可以理解为总接收数-总出队列数 
    Messages Enqueued 进入队列的消息  进入队列的总数量,包括出队列的。 这个数量只增不减 
    Messages Dequeued 出了队列的消息  可以理解为是消费这消费掉的数量 

     

    4.4 、发布订阅

    生产者:

     

     

     

    public class TOPSend {

     

        private static String BROKERURL = "tcp://127.0.0.1:61616";

        private static String TOPIC = "my-topic";

     

        public static void main(String[] args) throws JMSException {

            start();

        }

     

        static public void start() throws JMSException {

            System.out.println("生产者已经启动....");

            // 创建ActiveMQConnectionFactory 会话工厂

            ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(

                    ActiveMQConnection.DEFAULT_USER, ActiveMQConnection.DEFAULT_PASSWORD, BROKERURL);

            Connection connection = activeMQConnectionFactory.createConnection();

            // 启动JMS 连接

            connection.start();

            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

            MessageProducer producer = session.createProducer(null);

            producer.setDeliveryMode(DeliveryMode.PERSISTENT);

            send(producer, session);

            System.out.println("发送成功!");

            connection.close();

        }

     

        static public void send(MessageProducer producer, Session session) throws JMSException {

            for (int i = 1; i <= 5; i++) {

                System.out.println("我是消息" + i);

                TextMessage textMessage = session.createTextMessage("我是消息" + i);

                Destination destination = session.createTopic(TOPIC);

                producer.send(destination, textMessage);

            }

        }

     

    }

     

     

    消费者:

     

     

    public class TopReceiver {

        private static String BROKERURL = "tcp://127.0.0.1:61616";

        private static String TOPIC = "my-topic";

     

        public static void main(String[] args) throws JMSException {

            start();

        }

     

        static public void start() throws JMSException {

            System.out.println("消费点启动...");

            // 创建ActiveMQConnectionFactory 会话工厂

            ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(

                    ActiveMQConnection.DEFAULT_USER, ActiveMQConnection.DEFAULT_PASSWORD, BROKERURL);

            Connection connection = activeMQConnectionFactory.createConnection();

            // 启动JMS 连接

            connection.start();

            // 不开消息启事物,消息主要发送消费者,则表示消息已经签收

            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

            // 创建一个队列

            Topic topic = session.createTopic(TOPIC);

            MessageConsumer consumer = session.createConsumer(topic);

            // consumer.setMessageListener(new MsgListener());

            while (true) {

                TextMessage textMessage = (TextMessage) consumer.receive();

                if (textMessage != null) {

                    System.out.println("接受到消息:" + textMessage.getText());

                    // textMessage.acknowledge();// 手动签收

                    // session.commit();

                } else {

                    break;

                }

            }

            connection.close();

        }

     

    }

     

    4.5 、SpringBoot整合ActiveMQ

    生产者:

    4.5.1 引入 maven依赖

    <parent>

               <groupId>org.springframework.boot</groupId>

               <artifactId>spring-boot-starter-parent</artifactId>

               <version>1.5.4.RELEASE</version>

               <relativePath/> <!-- lookup parent from repository -->

          </parent>

          <properties>

               <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

               <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

               <java.version>1.8</java.version>

          </properties>

          <dependencies>

               <dependency>

                     <groupId>org.springframework.boot</groupId>

                     <artifactId>spring-boot-starter</artifactId>

               </dependency>

               <!-- spring boot web支持:mvc,aop... -->

               <dependency>

                     <groupId>org.springframework.boot</groupId>

                     <artifactId>spring-boot-starter-web</artifactId>

               </dependency>

               <dependency>

                     <groupId>org.springframework.boot</groupId>

                     <artifactId>spring-boot-starter-test</artifactId>

                     <scope>test</scope>

               </dependency>

               <dependency>

                     <groupId>org.springframework.boot</groupId>

                     <artifactId>spring-boot-starter-activemq</artifactId>

               </dependency>

          </dependencies>

          <build>

               <plugins>

                     <plugin>

                          <groupId>org.springframework.boot</groupId>

                          <artifactId>spring-boot-maven-plugin</artifactId>

                     </plugin>

               </plugins>

          </build>

    4.5.2 引入 YML配置

    spring:

      activemq:

        broker-url: tcp://127.0.0.1:61616

        user: admin

        password: admin

    queue: kmx.pas.job.sgtest

    4.5.3 创建QueueConfig

    @Configuration

    public class QueueConfig {

          @Value("${queue}")

          private String queue;

     

          @Bean

          public Queue logQueue() {

               return new ActiveMQQueue(queue);

          }

    }

    4.5.4 创建Producer

    @Component

    @EnableScheduling

    public class Producer {

        @Autowired

        private JmsMessagingTemplate jmsMessagingTemplate;

        @Autowired

        private Queue queue;

     

        @Scheduled(fixedDelay = 5000)

        public void send() {

            jmsMessagingTemplate.convertAndSend(queue, "测试消息队列" + System.currentTimeMillis());

        }

    }

     

    4.5.5 启动

    @SpringBootApplication

    public class App {

        public static void main(String[] args) {

            SpringApplication.run(App.class, args);

        }

    }

     

     

    消费者:

    4.5.1 引入 maven依赖

    <parent>

               <groupId>org.springframework.boot</groupId>

               <artifactId>spring-boot-starter-parent</artifactId>

               <version>1.5.4.RELEASE</version>

               <relativePath/> <!-- lookup parent from repository -->

          </parent>

          <properties>

               <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

               <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

               <java.version>1.8</java.version>

          </properties>

          <dependencies>

               <dependency>

                     <groupId>org.springframework.boot</groupId>

                     <artifactId>spring-boot-starter</artifactId>

               </dependency>

               <!-- spring boot web支持:mvc,aop... -->

               <dependency>

                     <groupId>org.springframework.boot</groupId>

                     <artifactId>spring-boot-starter-web</artifactId>

               </dependency>

               <dependency>

                     <groupId>org.springframework.boot</groupId>

                     <artifactId>spring-boot-starter-test</artifactId>

                     <scope>test</scope>

               </dependency>

               <dependency>

                     <groupId>org.springframework.boot</groupId>

                     <artifactId>spring-boot-starter-activemq</artifactId>

               </dependency>

          </dependencies>

          <build>

               <plugins>

                     <plugin>

                          <groupId>org.springframework.boot</groupId>

                          <artifactId>spring-boot-maven-plugin</artifactId>

                     </plugin>

               </plugins>

          </build>

    4.5.2 引入 YML配置

    application.yml

    spring:

      activemq:

        broker-url: tcp://127.0.0.1:61616

        user: admin

        password: admin

    queue: kmx.pas.job.sgtest

    4.5.3 创建Consumer

    @Component

    public class Consumer {

     

        @JmsListener(destination = "${queue}")

        public void receive(String msg) {

            System.out.println("监听器收到msg:" + msg);

        }

     

    }

     

     

    4.5.4 启动

    @SpringBootApplication

    public class App {

        public static void main(String[] args) {

            SpringApplication.run(App.class, args);

        }

    }

     

     

    展开全文
  • ActiveMQ详细入门使用教程

    万次阅读 多人点赞 2018-01-22 15:47:12
    ActiveMQ介绍  MQ是消息中间件,是一种在分布式系统中应用程序借以传递消息的媒介,常用的有ActiveMQ,RabbitMQ,kafka。ActiveMQ是Apache下的开源项目,完全支持JMS1.1和J2EE1.4规范的JMS Provider实现。 特点:...

    ActiveMQ介绍

         MQ是消息中间件,是一种在分布式系统中应用程序借以传递消息的媒介,常用的有ActiveMQ,RabbitMQ,kafka。ActiveMQ是Apache下的开源项目,完全支持JMS1.1和J2EE1.4规范的JMS Provider实现。
    特点:
    1、支持多种语言编写客户端
    2、对spring的支持,很容易和spring整合
    3、支持多种传输协议:TCP,SSL,NIO,UDP等
    4、支持AJAX
    消息形式:
    1、点对点(queue)
    2、一对多(topic)

    ActiveMQ安装

    这里写图片描述
    我这里提供一个安装好的虚拟机:http://download.csdn.net/download/liuyuanq123/10217892
    服务器运行后,我们可以直接访问到activeMQ的界面:
    这里写图片描述
    然后点击queues可以看到现在没有一条消息:
    这里写图片描述

    ActiveMQ测试


          编写一个测试类对ActiveMQ进行测试,首先得向pom文件中添加ActiveMQ相关的jar包:

         <dependency>  
             <groupId>org.apache.activemq</groupId>  
             <artifactId>activemq-all</artifactId>  
        </dependency>  

    queue的发送代码如下:

        public void testMQProducerQueue() throws Exception{
            //1、创建工厂连接对象,需要制定ip和端口号
            ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.156.44:61616");
            //2、使用连接工厂创建一个连接对象
            Connection connection = connectionFactory.createConnection();
            //3、开启连接
            connection.start();
            //4、使用连接对象创建会话(session)对象
            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            //5、使用会话对象创建目标对象,包含queue和topic(一对一和一对多)
            Queue queue = session.createQueue("test-queue");
            //6、使用会话对象创建生产者对象
            MessageProducer producer = session.createProducer(queue);
            //7、使用会话对象创建一个消息对象
            TextMessage textMessage = session.createTextMessage("hello!test-queue");
            //8、发送消息
            producer.send(textMessage);
            //9、关闭资源
            producer.close();
            session.close();
            connection.close();
        }

    接收代码:

        public void TestMQConsumerQueue() throws Exception{
            //1、创建工厂连接对象,需要制定ip和端口号
            ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.156.44:61616");
            //2、使用连接工厂创建一个连接对象
            Connection connection = connectionFactory.createConnection();
            //3、开启连接
            connection.start();
            //4、使用连接对象创建会话(session)对象
            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            //5、使用会话对象创建目标对象,包含queue和topic(一对一和一对多)
            Queue queue = session.createQueue("test-queue");
            //6、使用会话对象创建生产者对象
            MessageConsumer consumer = session.createConsumer(queue);
            //7、向consumer对象中设置一个messageListener对象,用来接收消息
            consumer.setMessageListener(new MessageListener() {
    
                @Override
                public void onMessage(Message message) {
                    // TODO Auto-generated method stub
                    if(message instanceof TextMessage){
                        TextMessage textMessage = (TextMessage)message;
                        try {
                            System.out.println(textMessage.getText());
                        } catch (JMSException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            });
            //8、程序等待接收用户消息
            System.in.read();
            //9、关闭资源
            consumer.close();
            session.close();
            connection.close();
        }

    然后当我们运行queue发送的时候可以看到队列里已经有一条消息了,但没有发送出去:
    这里写图片描述
    然后在运行queue 的接收端,可以看到消息已经发出了:
    这里写图片描述
    这里写图片描述
    接着对topic进行测试,发送代码如下:

        public void TestTopicProducer() throws Exception{
            //1、创建工厂连接对象,需要制定ip和端口号
            ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.156.44:61616");
            //2、使用连接工厂创建一个连接对象
            Connection connection = connectionFactory.createConnection();
            //3、开启连接
            connection.start();
            //4、使用连接对象创建会话(session)对象
            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            //5、使用会话对象创建目标对象,包含queue和topic(一对一和一对多)
            Topic topic = session.createTopic("test-topic");
            //6、使用会话对象创建生产者对象
            MessageProducer producer = session.createProducer(topic);
            //7、使用会话对象创建一个消息对象
            TextMessage textMessage = session.createTextMessage("hello!test-topic");
            //8、发送消息
            producer.send(textMessage);
            //9、关闭资源
            producer.close();
            session.close();
            connection.close();
        }

    接收代码:

        public void TestTopicConsumer() throws Exception{
            //1、创建工厂连接对象,需要制定ip和端口号
            ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.156.44:61616");
            //2、使用连接工厂创建一个连接对象
            Connection connection = connectionFactory.createConnection();
            //3、开启连接
            connection.start();
            //4、使用连接对象创建会话(session)对象
            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            //5、使用会话对象创建目标对象,包含queue和topic(一对一和一对多)
            Topic topic = session.createTopic("test-topic");
            //6、使用会话对象创建生产者对象
            MessageConsumer consumer = session.createConsumer(topic);
            //7、向consumer对象中设置一个messageListener对象,用来接收消息
            consumer.setMessageListener(new MessageListener() {
    
                @Override
                public void onMessage(Message message) {
                    // TODO Auto-generated method stub
                    if(message instanceof TextMessage){
                        TextMessage textMessage = (TextMessage)message;
                        try {
                            System.out.println(textMessage.getText());
                        } catch (JMSException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            });
            //8、程序等待接收用户消息
            System.in.read();
            //9、关闭资源
            consumer.close();
            session.close();
            connection.close();
        }

    然后运行topic发送:
    这里写图片描述
    可以看到消息已经发送出去。再运行topic接收:
    这里写图片描述
    可以看到有了一个消费者,但是没有接收的消息,这是因为正常情况下我们的topic消息不会再服务器持久化,所以要先打开消费者,再打开生产者,这个时候我们再运行生产者发送一条消息看到消息已经接收到了:
    这里写图片描述
    这里写图片描述

    ActiveMQ整合spring及项目中运用


          activeMQ与spring看一整合到一起使用,除了添加ActiveMQ相关的jar包外,还需要添加spring的jar包:

        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-context</artifactId>  
        </dependency>  

    然后编写applicationContext-activemq.xml文件,
    代码如下:

    <?xml version="1.0" encoding="UTF-8"?>  
    <beans xmlns="http://www.springframework.org/schema/beans"  
        xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"  
        xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"  
        xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"  
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd  
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd  
        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd  
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">  
    
        <!-- 配置能够产生connection的connectionfactory,由JMS对应的服务厂商提供 -->
        <bean id="tagertConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
            <constructor-arg name="brokerURL" value="tcp://192.168.156.44:61616"/>
        </bean>
        <!-- 配置spring管理真正connectionfactory的connectionfactory,相当于spring对connectionfactory的一层封装 -->
        <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
            <property name="targetConnectionFactory" ref="tagertConnectionFactory"/>
        </bean>
        <!-- 配置生产者 -->
        <!-- Spring使用JMS工具类,可以用来发送和接收消息 -->
        <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
            <!-- 这里是配置的spring用来管理connectionfactory的connectionfactory -->
            <property name="connectionFactory" ref="connectionFactory"/>
        </bean>
        <!-- 配置destination -->
        <!-- 队列目的地 -->
        <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
            <constructor-arg value="spring-queue"/>
        </bean>
        <!-- 话题目的地 -->
        <bean id="itemAddTopic" class="org.apache.activemq.command.ActiveMQTopic">
            <constructor-arg value="item-add-topic"/>
        </bean>
    </beans>  

    然后在我们淘淘商城中,商品添加到数据库的时候,对应也要添加数据到我们的solr索引中,所以生产者应该在插入数据后创建:
    这里写图片描述
    当然,在xml文件中配置好的jmstemplate和destination也要注入进来:

        @Autowired
        private JmsTemplate jmsTemplate;
        @Resource(name="itemAddTopic")
        private Destination destination;

    然后消费者应该写在我们的搜索工程中,首先添加spring和activeMQ的jar包,然后配置xml文件,再编写一个监听器,当接收到消息时,就讲数据存入索引库,xml文件代码如下:

    <?xml version="1.0" encoding="UTF-8"?>  
    <beans xmlns="http://www.springframework.org/schema/beans"  
        xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"  
        xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"  
        xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"  
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd  
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd  
        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd  
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">  
    
        <!-- 配置能够产生connection的connectionfactory,由JMS对应的服务厂商提供 -->
        <bean id="tagertConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
            <constructor-arg name="brokerURL" value="tcp://192.168.156.44:61616"/>
        </bean>
        <!-- 配置spring管理真正connectionfactory的connectionfactory,相当于spring对connectionfactory的一层封装 -->
        <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
            <property name="targetConnectionFactory" ref="tagertConnectionFactory"/>
        </bean>
        <!-- 配置destination -->
        <!-- 队列目的地 -->
        <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
            <constructor-arg value="spring-queue"/>
        </bean>
        <!-- 话题目的地 -->
        <bean id="itemAddTopic" class="org.apache.activemq.command.ActiveMQTopic">
            <constructor-arg value="item-add-topic"/>
        </bean>
        <!-- 配置监听器 -->
        <bean id="myListener" class="com.taotao.search.listener.MyListener"/>
        <bean id="itemAddListener" class="com.taotao.search.listener.ItemAddListener"/>
        <!-- 系统监听器 -->
    <!--    <bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
            <property name="connectionFactory" ref="connectionFactory"/>
            <property name="destination" ref="queueDestination"/>
            <property name="messageListener" ref="myListener"/>
        </bean> -->
        <bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
            <property name="connectionFactory" ref="connectionFactory"/>
            <property name="destination" ref="itemAddTopic"/>
            <property name="messageListener" ref="itemAddListener"/>
        </bean>
    </beans>  

    接收消息代码:
    这里写图片描述
    最后同时打开测试即可。

    展开全文
  • ActiveMQ 面试题(长期更新)

    万次阅读 2019-05-02 16:38:51
    什么是activemq activeMQ是一种开源的,实现了JMS1.1规范的,面向消息(MOM)的中间件,为应用程序提供高效的、可扩展的、稳定的和安全的企业级消息通信。 activemq的作用以及原理 Activemq的作用就是系统之间进行...
    1. 什么是activemq

    activeMQ是一种开源的,实现了JMS1.1规范的,面向消息(MOM)的中间件,为应用程序提供高效的、可扩展的、稳定的和安全的企业级消息通信。

    1. activemq的作用以及原理

    Activemq 的作用就是系统之间进行通信。 当然可以使用其他方式进行系统间通信, 如果使用 Activemq 的话可以对系统之间的调用进行解耦, 实现系统间的异步通信。 原理就是生产者生产消息, 把消息发送给activemq。 Activemq 接收到消息, 然后查看有多少个消费者, 然后把消息转发给消费者, 此过程中生产者无需参与。 消费者接收到消息后做相应的处理和生产者没有任何关系

    1. activemq的几种通信方式

    3.1publish(发布)-subscribe(订阅)(发布-订阅方式)

    发布/订阅方式用于多接收客户端的方式.作为发布订阅的方式,可能存在多个接收客户端,并且接收端客户端与发送客户端存在时间上的依赖。一个接收端只能接收他创建以后发送客户端发送的信息。作为subscriber ,在接收消息时有两种方法,destinationreceive方法,和实现message listener 接口的onMessage 方法。 图解如下:

    3.2 p2p(point-to-point)(点对点)

    p2p的过程则理解起来比较简单。它好比是两个人打电话,这两个人是独享这一条通信链路的。一方发送消息,另外一方接收,就这么简单。在实际应用中因为有多个用户对使用p2p的链路,它的通信场景如下图所示:

       p2p的场景里,相互通信的双方是通过一个类似于队列的方式来进行交流。和前面pub-sub的区别在于一个topic有一个发送者和多个接收者,而在p2p里一个queue只有一个发送者和一个接收者。

    1. activemq如果数据提交不成功怎么办(消息丢失)http://blog.csdn.net/fulai0_0/article/details/52127320(持久订阅)

    上面说到activemq的消息方式有两种(其实有三种还有一种请求响应方式不是规范的方式这里不做说明),对于两种方式处理不一样

    1. publish(发布)-subscribe(订阅)方式的处理

    发布订阅模式的通信方式, 默认情况下只通知一次, 如果接收不到此消息就没有了。 这种场景只适用于对消息送达率要求不高的情况。 如果要求消息必须送达不可以丢失的话, 需要配置持久订阅。 每个订阅端定义一个 id  <property name="clientId" 在订阅是向 activemq 注册。 发布消息 <property name="subscriptionDurable" value="true"/>和接收消息时需要配置发送模式为持久化template.setDeliveryMode(DeliveryMode.PERSISTENT);。 此时如果客户端接收不到消息, 消息会持久化到服务端(就是硬盘上) 直到客户端正常接收后为止。

    1. 4.2p - p(点对点)方式的处理

     

    点对点模式的话, 如果消息发送不成功此消息默认会保存到 activemq 服务端直到有消费者将其消费, 所以此时消息是不会丢失的。

     

    1. 如何解决消息重复问题

    所谓消息重复,就是消费者接收到了重复的消息,一般来说我们对于这个问题的处理要把握下面几点,

    ①.消息不丢失(上面已经处理了)

    ②.消息不重复执行

    一般来说我们可以在业务段加一张表,用来存放消息是否执行成功,每次业务事物commit之后,告知服务端,已经处理过该消息,

    这样即使你消息重发了,也不会导致重复处理

    大致流程如下:

            业务端的表记录已经处理消息的id,每次一个消息进来之前先判断该消息是否执行过,如果执行过就放弃,如果没有执行就开始执行消息,消息执行完成之后存入这个消息的id

     

    展开全文
  • 消息中间件之ActiveMQ

    千人学习 2019-06-21 10:09:17
    消息中间件之ActiveMQ 消息中间件已经成为互联网企业应用系统内部通信的核心手段,是目前企业内主流标配技术, 它具有解耦、异步、削峰、签收、事务、流量控制、最终一致性等一系列高性能架构所需功能。 当前使用较...
  • 什么是ActiveMQ

    千次阅读 2019-07-17 00:36:47
    Apache ActiveMQ™是最流行的开源,多协议,基于Java的消息服务器。它支持行业标准协议,因此用户可以通过广泛的语言和平台获得客户选择的好处。可以使用C,C ++,Python,.Net等连接。使用无处不在的AMQP协议集成您...

    一、官方简介

    Apache ActiveMQ™是最流行的开源,多协议,基于Java的消息服务器。它支持行业标准协议,因此用户可以通过广泛的语言和平台获得客户选择的好处。可以使用C,C ++,Python,.Net等连接。使用无处不在的AMQP协议集成您的多平台应用程序。使用STOMP通过websockets 在Web应用程序之间交换消息
    官网:http://activemq.apache.org/

    二、Queue与Topic 消息传递模式区别

    1)点对点(point-to-point,简称PTP)Queue消息传递模型:
    通过该消息传递模型,一个应用程序(即消息生产者)可以向另外一个应用程序(即消息消费者)发送消息。在此传递模型中,消息目的地类型是队列(即Destination接口实现类实例由Session接口实现类实例通过调用其createQueue方法并传入队列名称而创建)。消息首先被传送至消息服务器端特定的队列中,然后从此对列中将消息传送至对此队列进行监听的某个消费者。同一个队列可以关联多个消息生产者和消息消费者,但一条消息仅能传递给一个消息消费者。如果多个消息消费者正在监听队列上的消息,,JMS消息服务器将根据“先来者优先”的原则确定由哪个消息消费者接收下一条消息。如果没有消息消费者在监听队列,消息将保留在队列中,直至消息消费者连接到队列为止。这种消息传递模型是传统意义上的懒模型或轮询模型。在此模型中,消息不是自动推动给消息消费者的,而是要由消息消费者从队列中请求获得。
    2)发布/订阅(publish/subscribe,简称pub/sub)Topic消息传递模型:
    通过该消息传递模型,应用程序能够将一条消息发送给多个消息消费者。在此传送模型中,消息目的地类型是主题(即Destination接口实现类实例由Session接口实现类实例通过调用其createTopic方法并传入主题名称而创建)。消息首先由消息生产者发布至消息服务器中特定的主题中,然后由消息服务器将消息传送至所有已订阅此主题的消费者。主题目标也支持长期订阅。长期订阅表示消费者已注册了主题目标,但在消息到达目标时该消费者可以处于非活动状态。当消费者再次处于活动状态时,将会接收该消息。如果消费者均没有注册某个主题目标,该主题只保留注册了长期订阅的非活动消费者的消息。与PTP消息传递模型不同,pub/sub消息传递模型允许多个主题订阅者接收同一条消息。JMS一直保留消息,直至所有主题订阅者都接收到消息为止。pub/sub消息传递模型基本上是一个推模型。在该模型中,消息会自动广播,消息消费者无须通过主动请求或轮询主题的方法来获得新的消息。
    3)具体区别对比如下:

    类型 Topic Queue
    概要 Publish Subscribe messaging 发布订阅消息 Point-to-Point 点对点
    有无状态 topic数据默认不落地,是无状态的 Queue数据默认会在mq服务器上以文件形式保存,比如Active MQ一般保存在$AMQ_HOME\data\kr-store\data下面。也可以配置成DB存储。
    完整性保障 并不保证publisher发布的每条数据,Subscriber都能接受到。 Queue保证每条数据都能被receiver接收。
    消息是否会丢失 一般来说publisher发布消息到某一个topic时,只有正在监听该topic地址的sub能够接收到消息;如果没有sub在监听,该topic就丢失了。 Sender发送消息到目标Queue,receiver可以异步接收这个Queue上的消息。Queue上的消息如果暂时没有receiver来取,也不会丢失。
    消息发布接收策略 一对多的消息发布接收策略,监听同一个topic地址的多个sub都能收到publisher发送的消息。Sub接收完通知mq服务器 一对一的消息发布接收策略,一个sender发送的消息,只能有一个receiver接收。receiver接收完后,通知mq服务器已接收,mq服务器对queue里的消息采取删除或其他操作。

    三、SpringBoot与ActiveMQ整合

    3.1 安装ActiveMQ

    下载地址: http://activemq.apache.org/download.html

    3.2 目录结构

    在这里插入图片描述
    producer : 消息生产者
    consumer-a : 消息消费者
    consumer-b : 消息消费者
    pom文件:

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-activemq</artifactId>
    </dependency>
    

    如果使用pool的话, 就需要在pom中加入以下依赖:

    <dependency>
         <groupId>org.apache.activemq</groupId>
         <artifactId>activemq-pool</artifactId>
         <version>5.14.5</version>
    </dependency>
    

    3.3 producer

    1)目录结构
    在这里插入图片描述
    2)yml文件:

    server:
      port: 8080
      context-path: /pro
    spring:
      activemq:
        user: admin
        password: admin
        broker-url: tcp://192.168.153.129:61616
        pool:
          enabled: true
          max-connections: 10
    
    queueName: publish.queue
    topicName: publish.topic
    

    这里我开启了连接池, 默认是不开的.
    这里要注意端口8080
    context-path 表示上下文的前缀,请求url的时候一定添加上
    3)配置文件 ActiveMQConfig

    @Configuration
    public class ActiveMQConfig {
        @Value("${queueName}")
        private String queueName;
    
        @Value("${topicName}")
        private String topicName;
    
        @Value("${spring.activemq.user}")
        private String usrName;
    
        @Value("${spring.activemq.password}")
        private  String password;
    
        @Value("${spring.activemq.broker-url}")
        private  String brokerUrl;
    
        @Bean
        public Queue queue(){
            return new ActiveMQQueue(queueName);
        }
    
        @Bean
        public Topic topic(){
            return new ActiveMQTopic(topicName);
        }
    
        @Bean
        public ActiveMQConnectionFactory connectionFactory() {
            return new ActiveMQConnectionFactory(usrName, password, brokerUrl);
        }
    
        @Bean
        public JmsListenerContainerFactory<?> jmsListenerContainerQueue(ActiveMQConnectionFactory connectionFactory){
            DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory();
            bean.setConnectionFactory(connectionFactory);
            return bean;
        }
    
        @Bean
        public JmsListenerContainerFactory<?> jmsListenerContainerTopic(ActiveMQConnectionFactory connectionFactory){
            DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory();
            //设置为发布订阅方式, 默认情况下使用的生产消费者方式
            bean.setPubSubDomain(true);
            bean.setConnectionFactory(connectionFactory);
            return bean;
        }
    }
    

    这里本来不需要配置这么多的, 但是在consumer中也会用到, 所以就暂时弄一份一样的, 拷贝一下完事.
    4) PublishController

    
    @RestController
    @RequestMapping("/publish")
    public class PublishController {
    
        @Autowired
        private JmsMessagingTemplate jms;
    
        @Autowired
        private Queue queue;
    
        @Autowired
        private Topic topic;
    
        @RequestMapping("/queue")
        public String queue(){
    
            for (int i = 0; i < 10 ; i++){
                jms.convertAndSend(queue, "queue"+i);
            }
    
            return "queue 发送成功";
        }
    
        @JmsListener(destination = "out.queue")
        public void consumerMsg(String msg){
            System.out.println(msg);
        }
    
        @RequestMapping("/topic")
        public String topic(){
    
            for (int i = 0; i < 10 ; i++){
                jms.convertAndSend(topic, "topic"+i);
            }
    
            return "topic 发送成功";
        }
    }
    

    3.4 consumer

    1)目录结构

    在这里插入图片描述
    a,b是一样的, 只是显示的信息不同.
    2)配置文件
    yml配置文件是一样的, 只是修改了端口和context-path.
    ActiveMQConfig文件内容是一样的.
    3)listener

    @Component
    public class QueueListener {
    
        @JmsListener(destination = "publish.queue", containerFactory = "jmsListenerContainerQueue")
        @SendTo("out.queue")
        public String receive(String text){
            System.out.println("QueueListener: consumer-a 收到一条信息: " + text);
            return "consumer-a received : " + text;
        }
    }
    

    SendTo 会将此方法返回的数据, 写入到 queue : out.queue 中去.

    @Component
    public class TopicListener {
    
        @JmsListener(destination = "publish.topic", containerFactory = "jmsListenerContainerTopic")
        public void receive(String text){
            System.out.println("TopicListener: consumer-a 收到一条信息: " + text);
        }
    }
    

    这里通过传入不同的factory, 来实现发送不同类型的信息

    3.5 测试验证结果

    1)queue测试
    浏览器中访问: http://localhost:8080/pro/publish/queue
    在这里插入图片描述
    然后看一下, 控制台, 那些用户接收到了信息.
    在这里插入图片描述
    在这里插入图片描述
    从上两幅图看的出来, a, b并不能同时接收数据. 这是queue的方式, 点对点.
    在这里插入图片描述
    2)topic测试
    浏览器访问页面: http://localhost:8080/pro/publish/topic
    在这里插入图片描述
    在这里插入图片描述
    a用户完全接收到信息了. 再看看b用户
    在这里插入图片描述

    四、感谢

    1)https://blog.csdn.net/lspj201007186/article/details/70176427
    2)https://www.cnblogs.com/elvinle/p/8457596.html

    展开全文
  • ActiveMQ——高级特性

    千次阅读 2019-08-07 12:51:51
    ActiveMQ支持两种消息投递方式:同步投递和异步投递。消息投递指的是消息生产者端将消息发送到消息服务器(即Broker)的过程,若采用同步投递的方式,则生产者端每次向消息服务器发送消息时都需要同步地等待消息...
  • ActiveMQ[图文详解]

    千次阅读 2018-07-31 16:50:24
    附属链接:【阿里云CentOS安装ActiveMQ详细步骤】 https://blog.csdn.net/weixin_38964895/article/details/81316392 1、下载安装ActiveMQ  ActiveMQ官网下载地址:...
  • ActiveMQ的作用总结(应用场景及优势)

    万次阅读 多人点赞 2018-06-08 11:45:51
    业务场景说明:消息队列在大型电子商务类网站,如京东、淘宝、去哪儿等网站有着深入的应用,队列的主要作用是消除高并发访问高峰,加快网站的响应速度。在不使用消息队列的情况下,用户的请求数据直接写入数据库,在...
  • MQ 系列之 JMSTemplate

    千次阅读 2020-08-05 15:44:13
    JMSTemplate 是由 Spring 提供的一个 JMS 消息发送模板,可以用来方便地进行消息的发送,消息发送方法 convertAndSend 的第一个参数是消息队列,第二个参数是消息内容,@JmsListener 注解则表示相应的方法是一个消息...
  • activemq的web管理界面

    万次阅读 2011-07-11 11:14:58
    activemq的web管理界面,http://127.0.0.1:8161/admin
  • JAVA版本列表 发布版本号 内部版本号(十进制) 内部版本号(十六进制) 1.5 31 49 1.6 32 50 ...ActiveMQ 依赖JDK版本 MQ版本号 JDK版本 apache-activemq-5.0.0 1.5+
  • maven引入ActiveMQ和spring冲突的大坑

    万次阅读 2018-12-06 18:28:26
    千万不要这样引入!!!! &lt;!-- https://mvnrepository.com/artifact/org.apache.activemq/activemq-all --&...org.apache.activemq&lt;/groupId&gt;  &lt;artifactId&gt;activem...
  • docker安装activemq

    万次阅读 2017-04-08 13:27:10
    默认要安装activemq的主机上已经安装了docker. 查询activemq: docker search activemq 我使用的是阿里云的仓库,所有查出来跟使用官方的稍微不一样,但是拉去镜像的时候都是按照name。 docker pull ...
  • ActiveMq 本地安装及启动(Windows)

    万次阅读 2018-05-23 12:37:37
    首先下载MQ的安装包http://activemq.apache.org/download.html1....这里有windows版本和linux版本,这里我们...启动activeMq, 我们用windows命令行模式启动, window+R, 输入cmd打开命令窗口5.启动命令窗口之后进入解压后...
  • 设置ActiveMQ的访问密码

    万次阅读 2016-11-01 12:11:10
    1、设置ActiveMQ的访问密码,以提高ActiveMQ的安全性 2、在ActiveMQ的conf目录的activemq.xml中添加账号密码  2.1 添加的代码如下  2.2 添加在active.xml的位置如下 3、...
  • Linux下activeMQ的安装和启动

    万次阅读 2016-02-14 11:32:04
    ActiveMQ的安装和启动 如何安装ActiveMQActiveMQ的启动ActiveMQ的关闭 ActiveMQ 在linux下的安装 安装JAVA配置JAVA环境下载ActiveMQ解压压缩包  tar zxvf activemq-x.x.x-bin.tar.gz 至此,linux下ActiveMQ的...
  • Linux上运行ActiveMQ命令

    万次阅读 2018-10-24 17:02:20
    进入到linux中安装ActiveMQ的位置,cd ../apache-activemq-5.15.2/bin activemq启动分linux-x86-32和linux-x86-64 进入bin/linux-x86-64下: cd linux-x86-64/ 启动: ./activemq start 启动成功后,可以访问,...
  • activeMQ 的启动 停止 查看状态

    千次阅读 2019-03-31 00:06:57
    1 启动 : 进入到activeMQ 的 bin 目录,执行 ./activemq start 开启 ,如下: 2 查看activeMQ 是不是启动的状态,./activemqstatus ,如下: 3 停止 activemq 命令 ./activemq stop , 如下 : ...
  • Ubuntu16.04 安装ActiveMQ

    千次阅读 2017-03-07 11:28:37
    下载并安装activemq sudo apt-get install activemq 二.cd /usr/bin ./activemq setup [/etc/default/activemq] 三.启动 ./activemq start 四.验证 打开浏览器输入:localhost:8161/admin
  • ActiveMQ安装部署(Windows)

    万次阅读 多人点赞 2014-07-26 15:57:26
    JMS(Java Messaging Service)是Java平台上有关面向消息中间件的技术规范,它便于消息系统中的Java应用程序进行消息交换,并且通过提供标准的产生、发送、接收消息的接口简化企业应用的开发,ActiveMQ而是这个规范的...
1 2 3 4 5 ... 20
收藏数 57,092
精华内容 22,836
关键字:

activemq