SpringBoot与JMS集成(中间件为ActiveMQ)

最新推荐文章于 2024-06-27 09:49:52 发布
最新推荐文章于 2024-06-27 09:49:52 发布
阅读量1.2k 收藏 1
点赞数
文章标签： SpringBoot集成JMS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lingbomanbu_lyl/article/details/82912368
版权

一、ActiveMQ学习
1、基本概念以及介绍
Apache ActiveMQ是最受欢迎和强有力的开源消息和集成模式服务器，支持许多跨语言客户端和协议，便利使用企业集成模式还有许多先进的特性。

相关命令
activemq start：启动
activemq stop：关闭

管理界面：
http://127.0.0.1:8161/admin/
login:admin
password:admin

监听端口
ActiveMQ默认端口是61616。
windows查看端口：netstat -an|find "61616"

unix查看端口：netstat -nl|grep 61616

2、两种消息模式
(1)点对点模式
点对点的模式主要建立在一个队列上面，当连接一个队列的时候，发送端不需要知道接收端是否正在接收，发送的消息，将会先进入消息队列中，如果
有接收端在监听，则会发向接收端，如果没有接收端接收，则会保存到activemq服务器，直到接收端接收信息，点对点的消息模式可以有多个发送端，
多个接收端，但是一条消息，只会被一个接收端接收，那个接收端先连上activemq，则会先接收到，而后来的接收端则接收不到那条信息。

(2)订阅/发布模式
订阅/发布模式，同样可以有多个发送端与接收端，但是接收端和发送端存在时间上的依赖，如果发送端发送消息的时候，接收端并没有接收信息，那么
activemq不会保存信息，认为消息已经发送。换一种说法，就是发送端发送消息的时候，接收端不在线，是接收端不到信息的，哪怕以后监听消息，同样
也是接收不到的。这个模式还有一个特点，发送端发送的消息，将会被所有的接收端接收。不类似点对点，一条消息只会被一个接收端接收到。

点对点模式发送端
public class QueueSender {

  public static void main(String[] args) throws Exception {
    ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616");
    Connection conn = factory.createConnection();
    Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    // 开启连接
    conn.start();
    Destination des = session.createQueue("sampleQueue");
    MessageProducer producer = session.createProducer(des);
    // 默认为persistent，当activemq关闭时，队列数据将会被保存。当为non_persistent时，activemq关闭时，队列数据将会被清空。
    producer.setDeliveryMode(DeliveryMode.PERSISTENT);
    producer.send(session.createTextMessage("Hello World!"));
    producer.close();
    session.close();
    conn.close();
  }
}

点对点模式接收端
public class QueueConsumer {

  public static void main(String[] args) throws Exception {
    ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616");
    Connection conn = factory.createConnection();
    // 开启连接
    conn.start();
    Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Destination des = session.createQueue("sampleQueue");
    MessageConsumer consumer = session.createConsumer(des);
    consumer.setMessageListener(message -> {
      if (message instanceof TextMessage) {
        TextMessage tm = TextMessage.class.cast(message);
        try {
          System.out.println(tm.getText());
        } catch (JMSException e) {
          e.printStackTrace();
        }
      }
    });
    // 程序等待
    System.in.read();
    consumer.close();
    session.close();
    conn.close();
  }
}

订阅模式发送端
public class TopicSender {

  public static void main(String[] args) throws Exception {
    ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616");
    Connection conn = factory.createConnection();
    // 开启连接
    conn.start();
    Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Destination des = session.createTopic("myTopic");
    MessageProducer producer = session.createProducer(des);
    // 默认为persistent，当activemq关闭时，队列数据将会被保存。当为non_persistent时，activemq关闭时，队列数据将会被清空。
    producer.setDeliveryMode(DeliveryMode.PERSISTENT);
    producer.send(session.createTextMessage("Hello World!"));
    producer.close();
    session.close();
    conn.close();
  }
}

订阅模式接收端
public class TopicConsumer {

  public static void main(String[] args) throws Exception {
    ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616");
    Connection conn = factory.createConnection();
    // 开启连接
    conn.start();
    Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Destination des = session.createTopic("myTopic");
    MessageConsumer consumer = session.createConsumer(des);
    consumer.setMessageListener(message -> {
      if (message instanceof TextMessage) {
        TextMessage tm = TextMessage.class.cast(message);
        try {
          System.out.println(tm.getText());
        } catch (JMSException e) {
          e.printStackTrace();
        }
      }
    });
    // 程序等待
    System.in.read();
    consumer.close();
    session.close();
    conn.close();
  }
}

3、发送消息的数据类型
//纯字符串的数据
session.createTextMessage();
//序列化的对象
session.createObjectMessage();
//流，可以用来传递文件等
session.createStreamMessage();
//用来传递字节
session.createBytesMessage();
//这个方法创建出来的就是一个map，可以把它当作map来用，当你看了它的一些方法，你就懂了
session.createMapMessage();
//这个方法，拿到的是javax.jms.Message，是所有message的接口
session.createMessage();

4、保证消息的成功处理
创建session的时候使用客户端确认模式，如：
session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
AUTO_ACKNOWLEDGE：
当消息发送给接收端之后，就自动确认成功了，而不管接收端有没有处理成功，而一旦确认成功后，就会把队列里面的消息给清除掉，避免下一个接收端
收到同样的消息。
CLIENT_ACKNOWLEDGE：
由客户端进行确认，当客户端接收到消息进行处理后，客户端调用Message接口的acknowledge方法进行确认，如果不确定，activemq将会发给下一个接收端处理。
注意：CLIENT_ACKNOWLEDGE模式只在点对点模式有效，订阅/发布模式中，即使不确认，也不会保存消息。

二、Spring中的JMS
1、Spring集成JMS各包介绍
Spring提供了JMS集成框架，简化了JMS API的使用，JMS大致能分为两块功能：消息的生产和消费。JMSTemplate类用于消息的生产和异步消息的接收，
Spring提供了许多消息消息监听器容器用来创建消息驱动的POJO，同时也提供了声明式的方法来创建消息监听器。

org.springframework.jms.core提供了使用JMS的核心功能，包括通过处理资源创建和释放来简化JMS API使用的JMS模板类。Spring模板类的设计原则是提供
帮助方法执行通用的操作和为了更加复杂的使用，而把处理任务的核心委托给用户实现的回调接口。
org.springframework.jms.support提供了JMSException的异常转化功能，会把受检的JMSException转换成非受检异常，例如javax.jms.JMSException会被包装为
UncategorizedJmsException。
org.springframework.jms.support.converter提供了在Java对象和JMS消息之间的消息转换器抽象。
org.springframework.jms.support.destination提供了许多管理JMS目的地的策略，比如为存储在JNDI的目的地提供服务定位器。
org.springframework.jms.annotation提供了支持使用@JMSListener注解的必要设施。
org.springframework.jms.config提供了jms命名空间的解析实现以及配置监听器容器的java配置支持。
org.springframework.jms.connection提供了独立应用程序中适合使用的连接工厂的使用。同时也包含了JMS的平台事务管理器，也就是JmsTransactionManager。

2、使用Spring JMS
(1)JmsTemplate
JmsTemplate类简化了JMS的使用，因为当发送消息和异步接收消息它会处理资源的创建和释放，使用JmsTemplate只需要实现回调接口。
MessageCreator回调接口指定session就能创建消息，对于更复杂的使用，SessionCallback提供用户Jms会话和ProducerCallbacn回调。
备注：JmsTemplate实例一旦配置就是线程安全的，这就意味着可以配置一个JmsTemplate类的实例然后注入共享引用到多个协作者中，
简单来说，JmsTemplate是有状态的，因为它维护者一个连接工厂的引用，但是这种状态是非会话状态。

(2)Connections
JmsTemplate需要一个连接工厂的引用，通常被客户端应用作为工厂创建连接，而且它还包含了一些配置参数，许多参数是供应相关的，比如SSL配置选项。

(3)Caching Messaging Resources
在连接工厂和发送操作间，有三个中间对象会被创建和销毁，如下：
ConnectionFactory->Connection->Session->MessageProducer->send
为了优化资源的使用、提升性能，将会提供两个连接工厂。

(4)连接工厂分类
SingleConnectionFactory：每次都会创建一个新的连接，适合测试
CachingConnectionFactory：基于SingleConnectionFactory的基础上增加了Sessions、MessageProducers和MessageConsumer的缓存，初始缓存大小为1，
通过sessionCacheSize可以增加缓存sessions的数量。
注意：实际缓存Sessions的数量将会比设定的要大，因为缓存的sessions是基于确认模式的。

备注：推荐使用apache的PooledConnectionFactory，PooledConnectionFactory支持Connection、Session和MessageProducer的池化，连接、会话和消息生产者实例
使用后会返回池里，以便后续使用。而Consumer不会池化，消费者处理完消息后应该关闭，而不是放到池里后续使用。尽管消费者空闲，但ActiveMQ会继续发送消息
到消费者的预获取缓冲区，消息会在预获取缓冲区阻塞，直到消费者再次被激活。

(5)Destination Management
JmsTemplate会把目的地名的解析委托给JMS目的地解析对象，也就是DestinationResolver的实现。DynamicDestinationResolver是JmsTemplate使用的
默认实现，它提供解析动态目的地。
通常在JMS应用中的目的地只在运行时得知，当应用程序部署时是不会被创建的。这是因为在交互式的系统组件中有共享程序逻辑，这些系统组件会根据
一个已知的命名规则在运行期间创建目的地。

(6)Message Listener Containers
消息监听容器用来接收来自JMS消息队列的消息并驱动已注入的消息监听器。监听容器负责所有消息接收的线程并分发消息给监听器，消息监听器容器是在
MDP(message-driven POJO)和消息提供者的媒介，它关注接收消息的注册、参与事务、资源获取和释放以及异常转化。

分类：
SimpleMessageListenerContainer
这种消息监听容器会在启动时创建固定数量的JMS sessions和consumers,并且用标准的MessageConsumer.setMessageListener()注册监听器，然后让JMS
消息生产者调用回调接口。
注意：SimpleMessageListenerContainer并不允许动态适应运行时需求以及参与外部事务，它只支持本地事务，将sessionTransacted标识设为true即可。来自消息监听器的异常
会导致回滚，而且消息会重新发送。

DefaultMessageListenerContainer
这种消息监听器是使用最多的，和SimpleMessageListenerContainer相反，这种容器变体允许动态适应运行时需求，当配置了JtaTransactionManager时，每条被
接收的消息都会伴随XA transaction而注册。这种监听器在JMS生产者的低需求、参与外部管理事务的功能和兼容Java EE环境中打造了平衡。

(7)Transaction management
Spring提供了JmsTransactionManager为单个连接工厂管理事务，允许应用程序利用Spring的事务管理特性。JmsTransactionManager管理本地资源事务，
绑定来自指定连接工厂的JMS连接/会话对到线程中，JmsTemplate自动检测事务资源并相应进行操作。

三、SpringBoot与ActiveMQ集合使用

1、加入相关依赖

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.iboxpay</groupId>
	<artifactId>activemq_learning</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<name>activemq_learning</name>
	<description>activemq_learning for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.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>
		<!-- spring框架 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-activemq</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
			<scope>provided</scope>
		</dependency>
		<!-- spring测试框架 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<!-- mybatis与spring集成 -->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.2</version>
		</dependency>
		<!-- mysql连接驱动 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<!-- druid -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid-spring-boot-starter</artifactId>
			<version>1.1.10</version>
		</dependency>

		<!-- mq连接池 -->
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-pool</artifactId>
		</dependency>

		<!-- jsp -->
		<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
			<scope>provided</scope>
		</dependency>
		<!-- jstl中包含标准标签库 -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
		</dependency>

		<!--javamelody应用监控 -->
		<dependency>
			<groupId>net.bull.javamelody</groupId>
			<artifactId>javamelody-spring-boot-starter</artifactId>
			<version>1.74.0</version>
		</dependency>

		<!-- fastjson -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.49</version>
		</dependency>

		<!-- commons lang -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
		</dependency>
		<!-- commons code -->
		<dependency>
			<groupId>commons-codec</groupId>
			<artifactId>commons-codec</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-configuration-processor</artifactId>
			<optional>true</optional>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>


</project>

2、集成相关配置

@Configuration
@PropertySource("classpath:jms.properties")
public class ActiveMQConfig {

  @Autowired
  private JmsConfig jmsConfig;

  @Autowired
  private MyListener myListener;

  /**
   * ActiveMQ连接池
   * @return
   */
  @Bean(name = "pooledConnectionFactory", destroyMethod = "stop")
  public PooledConnectionFactory pooledConnectionFactory() {
    ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
    connectionFactory.setBrokerURL(jmsConfig.getBrokerUrl());
    return new PooledConnectionFactory(connectionFactory);
  }

  /**
   * 发送或接收目的地
   * @return
   */
  @Bean("activeMQQueue")
  public ActiveMQQueue activeMQQueue() {
    return new ActiveMQQueue(jmsConfig.getDestinationName());
  }

  /**
   * JmsTemplate消息发送模板类配置
   * @param connectionFactory
   * @param activeMQQueue
   * @return
   */
  @Bean
  public JmsTemplate jmsTemplate(@Qualifier("pooledConnectionFactory") PooledConnectionFactory connectionFactory,
      @Qualifier("activeMQQueue") ActiveMQQueue activeMQQueue) {
    JmsTemplate jmsTemplate = new JmsTemplate();
    // 指定连接工厂
    jmsTemplate.setConnectionFactory(connectionFactory);
    // 开启事务
    jmsTemplate.setSessionTransacted(true);
    // 指定确认模式，默认为自动确认
    jmsTemplate.setSessionAcknowledgeMode(Session.AUTO_ACKNOWLEDGE);
    // 指定发送目的地
    jmsTemplate.setDefaultDestination(activeMQQueue);
    return jmsTemplate;
  }

  /**
   * jms事务管理器,创建session时需打开事务
   * @param connectionFactory
   * @return
   */
  @Bean(name = "jmsTransactionManager")
  public JmsTransactionManager jmsTransactionManager(
      @Qualifier("pooledConnectionFactory") PooledConnectionFactory connectionFactory) {
    return new JmsTransactionManager(connectionFactory);
  }

  /**
   * 消息监听器容器,用来接收来自指定目的地的消息
   * @param connectionFactory
   * @param jmsTransactionManager
   * @param threadPoolTaskExecutor
   * @param activeMQQueue
   * @return
   */
  @Bean
  public DefaultMessageListenerContainer defaultMessageListenerContainer(
      @Qualifier("pooledConnectionFactory") PooledConnectionFactory connectionFactory,
      @Qualifier("jmsTransactionManager") JmsTransactionManager jmsTransactionManager,
      @Qualifier("threadPoolTaskExecutor") ThreadPoolTaskExecutor threadPoolTaskExecutor,
      @Qualifier("activeMQQueue") ActiveMQQueue activeMQQueue) {
    DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
    container.setConnectionFactory(connectionFactory);
    // 开启事务
    container.setSessionTransacted(true);
    container.setSessionAcknowledgeMode(Session.AUTO_ACKNOWLEDGE);
    container.setDestination(activeMQQueue);
    // 指定事务管理器
    container.setTransactionManager(jmsTransactionManager);

    // 指定消息监听器
    container.setMessageListener(myListener);
    // 并发消费者数量
    container.setConcurrentConsumers(jmsConfig.getConcurrentConsumers());
    // 最大并发消费者数量
    container.setMaxConcurrentConsumers(jmsConfig.getMaxConcurrentConsumers());
    // 指定任务执行器运行监听线程
    container.setTaskExecutor(threadPoolTaskExecutor);
    // 接收时长
    container.setReceiveTimeout(jmsConfig.getReceiveTimeout());
    return container;
  }

  /**
   * 线程池任务执行器配置
   * @return
   */
  @Bean("threadPoolTaskExecutor")
  public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
    ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
    threadPoolTaskExecutor.setCorePoolSize(20);
    threadPoolTaskExecutor.setMaxPoolSize(100);
    threadPoolTaskExecutor.setKeepAliveSeconds(300);
    threadPoolTaskExecutor.setQueueCapacity(1000);
    threadPoolTaskExecutor.setWaitForTasksToCompleteOnShutdown(true);
    return threadPoolTaskExecutor;
  }

}
@Component
@ConfigurationProperties(prefix = "jms")
public class JmsConfig {

  /**
   * broker地址
   */
  private String brokerUrl;

  /**
   * 并发连接消费者数
   */
  private Integer concurrentConsumers;

  /**
   * 最大并发连接消费者数
   */
  private Integer maxConcurrentConsumers;

  /**
   * 目的地
   */
  private String destinationName;

  /**
   * 消息接收时长
   */
  private Integer receiveTimeout;

  public String getBrokerUrl() {
    return brokerUrl;
  }

  public Integer getConcurrentConsumers() {
    return concurrentConsumers;
  }

  public Integer getMaxConcurrentConsumers() {
    return maxConcurrentConsumers;
  }

  public String getDestinationName() {
    return destinationName;
  }

  public Integer getReceiveTimeout() {
    return receiveTimeout;
  }

  public void setBrokerUrl(String brokerUrl) {
    this.brokerUrl = brokerUrl;
  }

  public void setConcurrentConsumers(Integer concurrentConsumers) {
    this.concurrentConsumers = concurrentConsumers;
  }

  public void setMaxConcurrentConsumers(Integer maxConcurrentConsumers) {
    this.maxConcurrentConsumers = maxConcurrentConsumers;
  }

  public void setDestinationName(String destinationName) {
    this.destinationName = destinationName;
  }

  public void setReceiveTimeout(Integer receiveTimeout) {
    this.receiveTimeout = receiveTimeout;
  }

  @Override
  public String toString() {
    return "JmsConfig [brokerUrl=" + brokerUrl + ", concurrentConsumers=" + concurrentConsumers
        + ", maxConcurrentConsumers=" + maxConcurrentConsumers + ", destinationName=" + destinationName
        + ", receiveTimeout=" + receiveTimeout + "]";
  }

}
#================ jms相关配置 ===============#

#broker地址
jms.brokerURL=tcp://127.0.0.1:61616
#并发消费者数量
jms.concurrentConsumers=1
#最大并发消费者数量
jms.maxConcurrentConsumers=1
#发送目的地名称
jms.destinationName=spring_jms_test
#消息监听器容器接收时长
jms.receiveTimeout=0

以上为jms.properties属性文件内容

3、消息监听器配置

@Component
public class MyListener implements MessageListener {

  private static Logger logger = LoggerFactory.getLogger(MyListener.class);

  @Override
  public void onMessage(Message message) {
    if (message instanceof TextMessage) {
      try {
        TextMessage textMessage = TextMessage.class.cast(message);
        System.out.println(textMessage.getText());
      } catch (JMSException e) {
        logger.error("接收消息失败:{}", e.getMessage(), e);
      }
    }
  }

}

4、消息发送控制器

@Controller
public class JmsController {

  @Autowired
  private JmsTemplate jmsTemplate;

  @Autowired
  private ThreadPoolTaskExecutor threadPoolTaskExecutor;

  @RequestMapping("sendMessage.action")
  @ResponseBody
  public Map<String, Object> sendMessage(String textMessage) {
    Map<String, Object> resp = new HashMap<>();
    if (StringUtils.isBlank(textMessage)) {
      resp.put("statusCode", 0);
      resp.put("msg", "消息不能为空!");
      return resp;
    }

    // 异步发送消息
    threadPoolTaskExecutor.execute(() -> {
      // 实现回调接口创建消息
      jmsTemplate.send(session -> {
        return session.createTextMessage(textMessage);
      });
    });

    resp.put("statusCode", 1);
    resp.put("msg", "消息发送成功!");
    return resp;
  }

}

该学习项目github地址：https://github.com/liuyalou1996/activemq_learning

凌波漫步&
关注
springboot集成activemq实现消息接收demo
01-18
springboot集成activemq实现消息接收demo
SpringBoot学习笔记二：JMS(java Message Service)java消息服务
公子&小白的博客
10-12 810
1. SpringBoot学习笔记二：JMS(java Message Service)java消息服务 文章目录1. SpringBoot学习笔记二：JMS(java Message Service)java消息服务1.1. 什么是JMS1.2. 使用场景1.3. 一些概念1.4. 消息队列的编程模型2. ActiveMQ学习2.1. SpringBoot整合ActiveMQ2.2. 消息队列的...
Spring Boot与JMS消息中间件的集成
最新发布
技术研究中心
06-27 608
JMS是Java平台中的一项消息传递API，用于在两个应用程序或分布式系统之间发送消息。它提供了一种异步通信机制，可以提高系统的可扩展性和解耦性。常见的JMS消息中间件包括ActiveMQ、RabbitMQ和IBM MQ。通过本文的介绍，我们了解了如何在Spring Boot中集成ActiveMQ和RabbitMQ作为JMS消息中间件。通过这些配置和代码示例，可以轻松地在Spring Boot应用中实现消息的发送和接收，提升系统的可扩展性和解耦性。
SpringBoot2整合Jms超级简单攻略(基于ActiveMQ)
04-12
SpringBoot2整合Jms超级简单攻略(基于ActiveMQ).。消息主题(Topic)，需要一个固定的主题，例如大家都是在谈论外卖，那主题就是外卖，别人讨论其他的跟你无关。 消息队列(MQ) ，存放或者实现JMS的功能，需要用到队列，有人放入消息到外卖队列，有人从外卖队列读取消息，就是一个消息队列的模型。 发送者(Sender)，通过什么事或者想做什么事，就发个信息，例如点个外卖呗。 接收者(Receiver)，然后外卖员就收到信息，办事。 1、运行springoboot主类 2、直接访问localhost：8080/test?id=123 3.在控制台就可以看到mq打印消息，因为消费者2运算量太大，所以一直等待输出，消费者1消费两个消息
SpringBoot之Starter
weixin_34347651的博客
01-16 251
序 SpringBoot的starter主要用来简化依赖用的。本文主要分两部分，一部分是列出一些starter的依赖，另一部分是教你自己写一个starter。 部分starters的依赖 Starter(Group ID: org.springframework.boot) 传递依赖于 spring-boot-starter-l...
SpringBoot整合JMS
lwd2307997664的博客
04-11 2087
SpringBoot整合JMS 文章目录SpringBoot整合JMS前言一、JMS、AMQP概念以及区别二、ActiveMQ安装三、SpringBoot整合ActiveMQ：队列模式实例1、创建demo项目2、添加依赖3、添加application配置4、添加配置文件ActiveMQConfig5、创建JMS组件文件6、发送消息控制器7、测试验证四、SpringBoot整合ActiveMQ：广播模式实例1、创建demo项目2、添加依赖3、添加application配置4、添加配置文件ActiveMQCon
Springboot 整合 JMS
IT__learning的博客
09-27 2037
ActiveMQ JMS 仅支持 Java 平台。 由于 JMS 是一套标准，所以 SpringBoot 整合 JMS 必然是整合 JMS 的某一个实现。 Apache ActiveMQ 是一个开源的消息中间件，完全支持 JMS 1.1 规范，支持多种编程语言( C、C++、C#、Delphi、Erlang、AdobeFlash、Haskell,Java、Javascript、Perl、PHP、Pike、Python、Ruby )和协议 (OpenWire、REST、STOMP、WS-Notificatio
分布式中间件技术实战:基于springboot集成redis,mysql,activemq，-component.zip
11-07
分布式中间件技术实战：基于SpringBoot集成Redis、MySQL和ActiveMQ是现代企业级应用程序开发中的常见实践。在本文中，我们将深入探讨如何利用SpringBoot框架有效地整合这些关键组件，以构建高可用、高性能的分布式...
springboot集成activeMQ
09-04
而ActiveMQ则是Apache出品的一款开源的消息中间件，它实现了多种消息协议，如OpenWire、AMQP、STOMP等，是Java消息服务（JMS）的一个优秀实现。本文将详细介绍如何在Spring Boot项目中集成ActiveMQ，以及利用其特性...
SpringBoot使用JMS的小例子（ActiveMQ实现）
10-02
在本文中，我们将深入探讨如何使用SpringBoot与ActiveMQ结合实现JMS（Java消息服务）的应用。SpringBoot简化了配置和应用开发，而ActiveMQ是Apache出品的一个开源、高效的JMS提供者，常用于实现消息队列和消息中间件...
基于Springboot+ActiveMQ事务==本地事件表+activemq.zip
12-12
基于Springboot+ActiveMQ事务==本地事件表+activemq，即利用activemq+本地事件表实现分布式事务的功能
SpringBoot 整合实现ActiveMQ
12程序猿的博客
05-24 3302
目录一、ActiveMQ介绍二、ActiveMQ安装、服务端开启2.1 安装2.2 服务端启动三、SpringBoot 整合实现ActiveMQ3.1添加依赖3.2添加配置文件（yml文件）3.3 Queue3.3.1 Queue配置3.3.2 创建生产者3.3.3 创建消费者3.3.4 启动类添加@EnableJms 注解，启动消息队列3.3.5 测试3.4 Topic3.4.1 Topic配置3.4.2 发布者3.4.3 订阅者3.4.4 测试3.4.5 创建一个配置类，在配置类中提供监听工厂配置3.4
Spring Boot 整合JMS(ActiveMQ)
洺润Star的博客
10-22 314
一: ActiveMQ安装 安装环境为CentOS 7, 同时需要安装java运行环境 下载ActiveMQ wget https://mirrors.tuna.tsinghua.edu.cn/apache//activemq/5.15.10/apache-activemq-5.15.10-bin.tar.gz 解压 tar -zxvf apache-activemq-5.15.10-b...
spring boot集成JMS
chenjin_chenjin的博客
03-08 2575
 本文主要写在spring boot下怎样实现JMS的queue 和 topic的消息的发送以及接受。前序：(1)、安装ActiveMQ。点击打开链接(2)、解压后启动activemq.bat文件(3)、登录http://127.0.0.1:8161/admin 管理界面**初始账号密码都是admin(1)、创建spring boot项目，添加web 以及 activemq的依赖。项目构建成功后的...
SpringBoot 中整合JMS
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
09-13 471
两个 springboot 项目分别作为消息提供者（provider）和消费者（consumer）（1）在两个项目中的 application.properires 配置消息队列。（2）在提供者和消费者的启动类添加 @EnableJms 开启消息队列。（2）ProviderController 发送消息。@EnableJms //启动消息队列。@EnableJms //启动消息队列。3、服务提供者 provider。（1）配置类定义消息队列。
SpringBoot 集成 JMS 与 IBMMQ 代码示例教程
demo_yo的博客
10-16 2464
SpringBoot 集成 IBMMQ，实现两个服务间的消息通信。使用 SpringBoot JMS 集成 IBMMQ 十分的方便。
ActiveMQ深度解析：JMS中间件原理与应用
"本文详细介绍了Java消息服务（JMS）中间件ActiveMQ的相关知识，包括JMS的作用、模型、基本构件，以及ActiveMQ的特点和应用场景。" JMS中间件ActiveMQ详解 JavaMessageService（JMS）是Java平台中用于处理消息传递...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

凌波漫步&

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值