chapter11：SpringBoot与消息

于 2023-07-19 22:47:43 发布
阅读量168 收藏
点赞数
分类专栏： SpringBoot 文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013044713/article/details/131819452
版权

Spring Boot与消息视频

1. 消息概述

（1）大多数应用中，可通过消息服务中间件来提升系统异步通信、扩展解耦能力；

（2）消息服务中两个重要概念：消息代理（message broker）和目的地（destination）；

​ 当消息发送者发送消息以后，将由消息代理接管，消息代理保证消息传递到指定目的地。

（3）消息队列主要有两种形式的目的地

  • 队列（queue）：点对点消息通信；

    • 消息发送者发送消息，消息代理将其放入一个队列中，消息接收者从队列中获取消息内容，消息读取后被移出队列；
    • 消息只有唯一的发送者和接受者，但并不是说只能有一个接收者；

  • 主题（topic）：发布（publish）/订阅（subscribe）消息通信；

    • 发送者发送消息到主题中，多个接收者（订阅者）订阅这个主题就会监听这个主题，那么就会在消息到达时同时收到消息。

（4） JMS（Java Message Service） Java消息服务； 基于JVM消息代理的规范。 ActiveMQ是JMS实现。

（5）AMQP（Advanced Message Queuing Protocol）：高级消息队列协议，也是一个消息代理的规范，兼容JMS。RabbitMQ是AMQP的实现。

JMS与AMQP的对比
在这里插入图片描述

（6）Spring支持

  • Spring-jms提供了对JMS的支持；

  • Spring-rabbit提供了AMQP的支持；

  • 需要ConnectionFactory的实现来连接消息代理；

  • 提供JmsTemplate、RabbitTemplate模板类来发送消息；

  • @JmsListener（JMS)，@RabbitListener（AMQP）注解在方法上监听消息代理发布的消息；

  • @EnableJms，@EnableRabbit开启支持；

（7）SpringBoot自动配置

  • JmsAutoConfiguration

  • RabbitAutoConfiguration

2.消息应用场景

异步处理
在这里插入图片描述
应用解耦，流量削峰
在这里插入图片描述

3. RabbitMQ简介

RabbitMQ是一个由erlang语言开发的AMQP（Advanced Message Queue Protocol）的开源实现。

核心概念： Message，Publisher，Exchange，…

3.1 Message

消息，由消息头和消息体组成。消息体是不透明的，而消息头则由一系列的可选属性组成， 这些属性包括路由键（routing-key），相对其他消息的优先权（priority），指出该消息可能需要持久性存储）等；

3.2 Publisher

消息的生产者，也是一个向交换器发布消息的客户端应用程序。

3.3 Exchange

交换器，用来接收生产者发送的消息并将这些消息路由给服务器中的队列。

Exchange有4种类型： direct（默认），fanout，topic和headers；不同类型的Exchange转发消息的策略有所区别。

3.4 Queue

消息队列，用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。一个消息可投入一个或多个队列；消息一直在队列里面，等待消费者连接到这个队列将其消费（取出）。

3.5 Binding

绑定，用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则， 所以可以将交换器理解成一个由绑定构成的路由表。

3.6 Connection

网络连接， 比如一个TCP连接。

3.7 Channel

信道，多路复用连接中的一条独立的双向数据流通道。信道是建立在真实的TCP连接内的虚拟连接，AMQP命令都是通过信道发出去的，不管是发布消息、订阅队列还是接收消息，这些动作都是通过信道完成。因为对于操作系统来说建立和销毁TCP都是非常昂贵的开销，所以引入了信道的概念， 以复用一条TCP连接。

3.8 Consumer

消息的消费者，表示一个从消息队列中取得消息的客户端应用程序。

3.9 Virtual Host

虚拟主机，表示一批交换器、消息队列和相关对象。虚拟主机是共享相同的身份认证和加密环境的独立服务器域。每个vhost本质上是一个mini版的RabbitMQ服务器，拥有自己的队列、交换器、绑定和权限机制。vhost是AMQP概念的基础，必须在连接时指定，RabbitMQ默认的vhost是/。

3.10 Broker

表示消息队列服务器实体。
在这里插入图片描述

4. RabbitMQ运行机制

AMQP中的消息路由

AMQP中消息的路由过程和Java开发属性的JMS存在一些差异，AMQP中增加了Exchange和Binding的角色。生产者把消息发布到Exchange上，消息最终到达队列并被消费者接收，而根据Binding的routing key决定交换器的消息应该发送到哪个队列上。
在这里插入图片描述

5. Exchange类型

RabbitMQ中，Exchange分发消息时根据类型的不同分发策略有区别，目前共四种类型： direct、fanout、topic、headers。headers匹配AMQP消息的header而不是路由键，headers交换器和direct交换器完全一致，但性能差很多，目前几乎用不到，所以直接看另外三种类型：

5.1Direct Exchange

典型的点对点发送模型。消息中的路由键（routing key）如果和Binding中的binding key一致，交换器就将消息发送到对于的队列中。路由键与队列名完全匹配，如果一个队列绑定到交换机要求路由键为dog，则只会转发routing key标记为dog的消息，不会转发dog.puppy，也不会转发dog.guard等等。它是完全匹配、单播的模式。
在这里插入图片描述

5.2 Fanout Exchange

广播模式，每个发到fanout类型交换器的消息都会分到所有绑定的队列上去。fanout交换器不处理路由键（routing key），只是简单的将队列绑定到交换器上，每个发送到交换器的消息都会被转发到与该交换器绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息，fanout类型转发消息是最快的。
在这里插入图片描述

5.3 Topic Exchange

topic交换器通过模式匹配分配消息的路由键属性，将路由键和某个模式（固定的单词或通配符）进行匹配，此时队列需要绑定到一个模式上。它将路由键和绑定键的字符串切分成单词，这些单词之间用点隔开。它同样也会识别两个通配符，符合#和符号*。 #匹配0个或多个单词， *匹配一个单词。
在这里插入图片描述

6. RabbitMQ安装及配置

6.1 安装RabbitMQ

安装rabbitMQ， 参考 centos7安装rabbitmq教程1, centos7安装rabbitmq教程2

通过http://192.168.111.129:15672/打开RabbitMQ控制台。
在这里插入图片描述

6.2 RabbitMQ配置

根据下面的交换器，路由键进行配置。
在这里插入图片描述

点击Exchanges标签页，进行交换器的配置, 新增exchange.direct、exchange.fanout、exchange.topic交换器。durability=Durable表示持久化。
在这里插入图片描述
点击Queues标签页，进行队列的配置， 新增atguigu、atguigu.news、atguigu.emps、gulixueyuan.news队列。
在这里插入图片描述
对exchange.direct交换器进行队列绑定, 绑定了atguigu、atguigu.news、atguigu.emps、gulixueyuan.news队列。
在这里插入图片描述

对exchange.fanout交换器进行队列绑定, 绑定了atguigu、atguigu.news、atguigu.emps、gulixueyuan.news队列。
在这里插入图片描述
对exchange.topic交换器进行队列绑定, 绑定了atguigu、atguigu.news、atguigu.emps、gulixueyuan.news队列。routing key使用了通配符进行匹配。
在这里插入图片描述

6.3 使用交换器发送消息

使用点对点交换机exchange.direct发送消息, routing key=atguigu。
在这里插入图片描述

direct是点对点模式，只有atguigu队列可以接收到exchange.direct交换器发送的消息。
在这里插入图片描述

读取消息
在这里插入图片描述
使用exchange.fanout交换器发送消息, routing key=atguigu.news
在这里插入图片描述

atguigu、atguigu.news、atguigu.emps、gulixueyuan.news队列都会接收到exchange.fanout交换器发送的消息，exchange.fanout发送消息的匹配规则与发送消息的路由键没有关系，是广播模式。
在这里插入图片描述
在这里插入图片描述

使用exchange.topic交换器发送消息， routing key=atguigu.news。
在这里插入图片描述
因为exchange.topic绑定了atguigu.# 和 *.news的路由匹配规则，所以atguigu、atguigu.news、atguigu.emps、gulixueyuan.news队列都会接收到exchange.topic交换器通过atguigu.news发送的消息。
在这里插入图片描述
读取消息
在这里插入图片描述

使用exchange.topic交换器发送消息， routing key=hello.news。根据*.news的匹配规则， atguigu.news、gulixueyuan.news队列会接收到exchange.topic交换器通过hello.news发送的消息。
在这里插入图片描述
读取消息
在这里插入图片描述

7. 项目中实践RabbitMQ

7.1 创建SpringBoot项目

引入 spring-boot-starter-amqp

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.10.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>cn.crysw</groupId>
    <artifactId>springboot02-amqp</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot02-amqp</name>
    <description>springboot02-amqp</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <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.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

    </dependencies>

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

7.2 添加rabbitmq配置

application.properties配置

# rabbitmq config
spring.rabbitmq.host=192.168.111.129
spring.rabbitmq.username=root
spring.rabbitmq.password=123456
spring.rabbitmq.port=5672
spring.rabbitmq.connection-timeout=30000
#spring.rabbitmq.virtual-host=/
# debug
#debug=true

7.3 RabbitTemplate

7.3.1 点对点模式发送消息
@RunWith(SpringRunner.class)
@SpringBootTest
public class AmqpApplicationTests {

    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    public void test() {
        String exchange = "exchange.direct";
        String routingKey = "atguigu.news";
        // Message需要自己构造一个；定义消息体内容和消息头
        // rabbitTemplate.send("", "", message);
        Map<String, Object> map = new HashMap<>();
        map.put("msg", "这是第一个点对点的消息");
        map.put("data", Arrays.asList("hello rabbit world", "123"));
        // 只需要传入要发送的对象，自动转成Message对象发送给rabbitmq; 对象被默认序列化
//        rabbitTemplate.convertAndSend(exchange, routingKey, map);
        rabbitTemplate.convertAndSend(exchange, routingKey, 
                       Book.builder().bookName("西游记").author("吴承恩").build());
    }
    
    /**
     * 接收消息
     */
    @Test
    public void testReadMsg() {
        Object msg = rabbitTemplate.receiveAndConvert("atguigu.news");
        System.out.println("接收消息类型：" + (msg.getClass()));
        System.out.println("接收消息：" + msg);
    }
}

测试发现读取的消息是乱码, 因为RabbitTemplate模板中默认使用的是SimpleMessageConverter消息转换器进行序列化的。

接收消息类型：class [B
接收消息：[B@333c8791

可以自定义消息转换器来覆盖默认的配置

/**
 * 自定义AMQP配置
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/7/17 22:38
 */
@Configuration
public class MyAmqpConfig {
    @Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }
}

再次测试ok

rabbitConnectionFactory#65e21ce3:0/SimpleConnection@2cae9b8 [delegate=amqp://root@192.168.111.129:5672/, localPort= 9067]
接收消息类型：class cn.crysw.bean.Book
接收消息：Book(bookName=西游记, author=吴承恩)
7.3.2 广播模式发送消息
@RunWith(SpringRunner.class)
@SpringBootTest
public class AmqpApplicationTests {

    @Autowired
    private RabbitTemplate rabbitTemplate;
    
 	/**
     * 广播模式，不用指定routingKey，所有绑定的队列都会收到消息
     */
    @Test
    public void testExchangeFanout() {
        String routingKey="";
        rabbitTemplate.convertAndSend("exchange.fanout", routingKey, 
                   Book.builder().bookName("三国演义").author("罗贯中").build());
    }   
}

其他模式的也都有相应的api支持。

HeadersExchange，TopicExchange，CustomExchange，DirectExchange，FanoutExchange

7.4 监听并接收消息

@EnableRabbit + @RabbitListener监听消息队列中的消息。

在启动类上开启rabbitmq监听配置开关。

@SpringBootApplication
@EnableRabbit // 开启rabbitmq配置
public class Springboot02AmqpApplication {

    public static void main(String[] args) {
        SpringApplication.run(Springboot02AmqpApplication.class, args);
    }
}

在方法上添加@RabbitListener声明要监听的队列，就能实现自动监听并接收队列消息。

@Service
public class BookService {
    @RabbitListener(queues = {"atguigu.news"})
    public void receive(Book book) {
        System.out.println("收到消息：" + book);
    }

    @RabbitListener(queues = {"atguigu"})
    public void receiveMsg(Message message) {
        System.out.println("消息头：" + message.getMessageProperties());
        System.out.println("消息体：" + message.getBody());
    }
}

7.6 AmqpAdmin组件

AmqpAdmin是RabbitMQ系统管理功能组件, 提供了创建和删除Queue，Exchange，Binding的功能。

7.6.1 创建Exchange
@RunWith(SpringRunner.class)
@SpringBootTest
public class AmqpApplicationTests {

    @Autowired
    private AmqpAdmin amqpAdmin;
    /**
     * 使用amqpAdmin创建Exchange
     */
    @Test
    public void createExchange() {
        amqpAdmin.declareExchange(new DirectExchange("exchange.amqpadmin"));
        System.out.println("创建Exchange完成");
    }    
}
7.6.2 创建Queue
@RunWith(SpringRunner.class)
@SpringBootTest
public class AmqpApplicationTests {

    @Autowired
    private AmqpAdmin amqpAdmin;
    /**
     * 使用amqpAdmin创建Queue
     */
    @Test
    public void createQueue() {
        amqpAdmin.declareQueue(new Queue("amqpadmin.news", true));
        System.out.println("创建Queue完成");
    }
}
7.6.3 创建Binding
@RunWith(SpringRunner.class)
@SpringBootTest
public class AmqpApplicationTests {

    @Autowired
    private AmqpAdmin amqpAdmin;
    /**
     * 使用amqpAdmin创建Binding
     */
    @Test
    public void createBinding() {
        amqpAdmin.declareBinding(new Binding("amqpadmin.news", 	Binding.DestinationType.QUEUE, "exchange.amqpadmin", "*.news", null));
        System.out.println("创建binding关系完成");
    }
}

查看rabbitmq控制台， AmqpAdmin组件创建交换器，队列和绑定关系成功。
在这里插入图片描述

7.7 RabbitMQ自动配置

RabbitMQ的自动配置在RabbitAutoConfiguration类中， 配置属性封装在RabbitProperties中，使用spring.rabbitmq.xxx修改配置属性。

自动配置类中创建了连接工厂CachingConnectionFactory，RabbitTemplate模板，AmqpAdmin管理组件等;

@Configuration
@ConditionalOnClass({ RabbitTemplate.class, Channel.class })
@EnableConfigurationProperties(RabbitProperties.class)
@Import(RabbitAnnotationDrivenConfiguration.class)
public class RabbitAutoConfiguration {
    @Configuration
	@ConditionalOnMissingBean(ConnectionFactory.class)
	protected static class RabbitConnectionFactoryCreator {
		//连接工厂
		@Bean
		public CachingConnectionFactory rabbitConnectionFactory(RabbitProperties config)
				throws Exception {
			RabbitConnectionFactoryBean factory = new RabbitConnectionFactoryBean();
			if (config.determineHost() != null) {
				factory.setHost(config.determineHost());
			}
			factory.setPort(config.determinePort());
			if (config.determineUsername() != null) {
				factory.setUsername(config.determineUsername());
			}
			if (config.determinePassword() != null) {
				factory.setPassword(config.determinePassword());
			}
			if (config.determineVirtualHost() != null) {
				factory.setVirtualHost(config.determineVirtualHost());
			}
			if (config.getRequestedHeartbeat() != null) {
				factory.setRequestedHeartbeat(config.getRequestedHeartbeat());
			}
			RabbitProperties.Ssl ssl = config.getSsl();
			if (ssl.isEnabled()) {
				factory.setUseSSL(true);
				if (ssl.getAlgorithm() != null) {
					factory.setSslAlgorithm(ssl.getAlgorithm());
				}
				factory.setKeyStore(ssl.getKeyStore());
				factory.setKeyStorePassphrase(ssl.getKeyStorePassword());
				factory.setTrustStore(ssl.getTrustStore());
				factory.setTrustStorePassphrase(ssl.getTrustStorePassword());
			}
			if (config.getConnectionTimeout() != null) {
				factory.setConnectionTimeout(config.getConnectionTimeout());
			}
			factory.afterPropertiesSet();
			CachingConnectionFactory connectionFactory = new CachingConnectionFactory(
					factory.getObject());
			connectionFactory.setAddresses(config.determineAddresses());
			connectionFactory.setPublisherConfirms(config.isPublisherConfirms());
			connectionFactory.setPublisherReturns(config.isPublisherReturns());
			if (config.getCache().getChannel().getSize() != null) {
				connectionFactory
						.setChannelCacheSize(config.getCache().getChannel().getSize());
			}
			if (config.getCache().getConnection().getMode() != null) {
				connectionFactory
						.setCacheMode(config.getCache().getConnection().getMode());
			}
			if (config.getCache().getConnection().getSize() != null) {
				connectionFactory.setConnectionCacheSize(
						config.getCache().getConnection().getSize());
			}
			if (config.getCache().getChannel().getCheckoutTimeout() != null) {
				connectionFactory.setChannelCheckoutTimeout(
						config.getCache().getChannel().getCheckoutTimeout());
			}
			return connectionFactory;
		}
	}
    
    @Configuration
	@Import(RabbitConnectionFactoryCreator.class)
	protected static class RabbitTemplateConfiguration {
        // RabbitTemplate模板
        @Bean
		@ConditionalOnSingleCandidate(ConnectionFactory.class)
		@ConditionalOnMissingBean(RabbitTemplate.class)
		public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
			RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
			MessageConverter messageConverter = this.messageConverter.getIfUnique();
			if (messageConverter != null) {
				rabbitTemplate.setMessageConverter(messageConverter);
			}
			rabbitTemplate.setMandatory(determineMandatoryFlag());
			RabbitProperties.Template templateProperties = this.properties.getTemplate();
			RabbitProperties.Retry retryProperties = templateProperties.getRetry();
			if (retryProperties.isEnabled()) {
				rabbitTemplate.setRetryTemplate(createRetryTemplate(retryProperties));
			}
			if (templateProperties.getReceiveTimeout() != null) {
				rabbitTemplate.setReceiveTimeout(templateProperties.getReceiveTimeout());
			}
			if (templateProperties.getReplyTimeout() != null) {
				rabbitTemplate.setReplyTimeout(templateProperties.getReplyTimeout());
			}
			return rabbitTemplate;
		}
        // AmqpAdmin管理组件
        @Bean
		@ConditionalOnSingleCandidate(ConnectionFactory.class)
		@ConditionalOnProperty(prefix = "spring.rabbitmq", name = "dynamic", matchIfMissing = true)
		@ConditionalOnMissingBean(AmqpAdmin.class)
		public AmqpAdmin amqpAdmin(ConnectionFactory connectionFactory) {
			return new RabbitAdmin(connectionFactory);
		}
    }
}

7.8 遇到的问题

测试过程中，发现一直失败，无法连接到centOS7的rabbitmq服务；设置超时时间也没有用。

Exception in thread "main" java.util.concurrent.TimeoutException...

超时问题分析及解决方案 ：

客户端远程登录linux主机，每次登录输入密码后都会等很长一段时间才会进入，这是因为linux主机在返回信息时需要解析ip导致连接很慢。如果在linux主机的hosts文件事先加入客户端的ip地址，这时再从客户端远程登录linux就会变很快，ip解析优先从本机hosts文件读取，其实是加快了DNS解析过程。

这里所说的远程登录不仅仅是ssh，还可能是mysql远程登录, 连接rabbitmq服务等。

centOS7服务器的/etc/hosts文件添加本机ip，客户端ip解析配置；

127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
127.0.0.1   centos7-1
192.168.111.1 crysw-PC

客户端（PC电脑）的C:\Windows\System32\drivers\etc\hosts文件添加本机ip，原远程服务端ip解析配置；

# localhost name resolution is handled within DNS itself.
#	127.0.0.1       localhost
#	::1             localhost
192.168.111.129		centos7-1
127.0.0.1 			crysw-PC

刷新windows系统的网络 ： ipconfig /flushdns

参考1：https://blog.csdn.net/qq_34958326/article/details/116832748

参考2：https://www.cnblogs.com/jerryqi/p/9714566.html

crysw
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解在spring boot中消息推送系统设计与实现
08-26
主要介绍了详解在spring boot中消息推送系统设计与实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
springboot与消息(rabbtiMQ)
weixin_30394669的博客
09-01 190
1.大多应用中，可通过消息服务中间件来提升系统异步通信、扩展解耦能力 1.1异步通信 1.2解耦 1.3削峰 2.消息服务中两个重要概念： 消息代理（message broker）和目的地（destination）当消息发送者发送消息以后，将由消息代理接管，消息代理保证消息传递到指定目的地。　　消息队列主要有两种形式的目的地　　　　队列（queue）：点...
SpringBoot-消息
liberty12345678的专栏
10-24 156
SpringBoot整合rabbitmq 1、引入相关依赖： &lt;dependency&gt;             &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;             &lt;artifactId&gt;spring-boot-starter-amqp&lt;/artifactId&gt; ...
SpringBoot——消息
长不大的大灰狼
01-22 840
SpringBoot——消息中间件（ActiveMQ）一、消息服务的基本概念二、JMS规范 一、消息服务的基本概念 1、消息服务中两个重要概念： 消息代理（message broker，消息服务器）和目的地（destination）当消息发送者发送消息以后，将由消息代理接管，消息代理保证消息传递到指定目的地。 2、消息队列主要有两种形式的目的地： （1） 队列（queue）：点对点消息通信（point-to-point）。 发送者发送消息，消息代理将其放入一个队列中，在合适的时候，消息接收者从队列中获取消
九、SpringBoot与消息
qq_19768387的博客
03-23 2664
springboot与rabbitmq集成
word源码java-springboot:springboot学习
06-05
SpringBoot 项目目录 两个项目 配置使用 ==chapter2-7-1 springboot 集成 HttpClient == ==chapter2-0-8 springboot 集成 MockMvc和Swagger2== 工程配置 ==chapter0-0-0 springboot demo== ==chapter0-0-1 ...
chapter11_4.rar
02-15
过滤器是处于客户端与服务器资源文件之间的一道过滤网，过滤一些不符合要求的请求。通常他被用作Session校验，判断用户权限，如果不符合设定条件，就会被拦截到特殊的地址或者给予特殊的响应。java中的拦截器是动态...
springboot学习
01-29
chapter3-2-11：Spring Boot中增强对MongoDB的配置（连接池等） 事务管理 chapter3-3-1：使用事务管理 chapter3-3-2：[分布式事务（未完成）] 其他内容 chapter4-1-1：使用@Scheduled创建定时任务 chapter4-1-2：...
SpringBoot mongoDB 项目 [免费]
02-11
自己写的SpringBoot连接MongoDB的测试项目，里面实现比较简单，但是最基本的原理已经讲清楚了，希望对你们有所帮助
基于springboot开发的pay支付案列
08-08
H5支付：https://pay.weixin.qq.com/wiki/doc/api/H5.php?chapter=15_1 公众号支付：https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_1 扫码支付模式一：...
【SpringBoot学习10】消息
一个正在努力学习的iter
04-13 2091
文章目录1. 消息的概念2. 消息的模式3. Java处理消息的标准规范3.1 JMS3.2 AMQP3.3 MQTT3.4 kafka4. 购物订单发送手机短信案例4.1 订单业务4.2 短信处理业务 1. 消息的概念 从广义角度来说，消息其实就是信息，但是和信息又有所不同。信息通常被定义为一组数据，而消息除了具有数据的特征之外，还有消息的来源与接收的概念。通常发送消息的一方称为消息的生产者，接收消息的一方称为消息的消费者。这样比较后，发现其实消息和信息差别还是很大的。 为什么要设置生产者和消费者呢？这就
8.SpringBoot 与消息
m0_62520968的博客
09-12 876
ActiveMQ是MQ产品中的元⽼级产品，早期标准MQ产品之⼀，在AMQP协议没有出现之前，占据了消息中间件市场的绝⼤部分份额，后期因为AMQP系列产品的出现，迅速⾛弱，⽬前仅在⼀些线上运⾏的产品中出现，新产品开发较少采⽤。peer-2-peer，⽣产者会将消息发送到⼀个保存消息的容器中，通常使⽤队列模型，使⽤队列保存消息。AMQP的出现解决的是消息传递时使⽤的消息种类的问题，化繁为简，但是其并没有完全推翻JMS的操作API，所以说AMQP仅仅是⼀种协议，规范了数据传输的格式⽽已。
Spring boot 消息服务
文轩
05-29 274
消息服务 RabbitMQ 安装：【安装路径最好默认】 首先需要下载Erlang语言包 下载Rabbitmq服务 安装好之后，可能会访问【http://127.0.0.1:15672】失败 请参考：https://www.jianshu.com/p/e041f5ed10c7 添加配置【application.propertise】 # 配置 消息服务 Rabbitmq spring.rabbitmq.host=127.0.0.1 spring.rabbitmq.port=5672 spring.rabb
Spring Boot消息服务
weixin_67691477的博客
05-22 389
在Publish/Subscribe工作模式中，必须先配置一个fanout类型的交换器，不需要指定对应的路由键（Routing key），同时会将消息路由到每一个消息队列上，然后每个消息队列都可以对相同的消息进行接收存储，进而由各自消息队列关联的消费者进行消费。在这种模式下，多个消息消费者通过轮询的方式依次接收消息队列中存储的消息，一旦消息被某一个消费者接收，消息队列会将消息移除，而接收并处理消息的消费者必须在消费完一条消息后再准备接收下一条消息。单击fanout_exchange交换器进入查看。
Springboot与消息
码上人生的博客
05-26 584
消息的优点: 1.使用异步处理的方式,提高系统的通信能力 2. 应用解耦 3. 流量消峰 例如: 1.当我们用户注册时信息输入完成时,系统需要给用户发送一封邮件,然后发送注册短信.假如每一步需要50ms,如果是系统同步的情况下,那么整个过程需要150ms 2.使用多线程的方式,发送邮件和发送验证短信两个操作是并发执行的,这样总时长降低到了100ms 3.当用户把注册信息写入到数据库之后,只...
SpringBoot+消息1
ycd500756的博客
07-05 190
一：概述 通过消息服务中间件可以提升系统的异步通信，提高解耦。 主要概念 1.消息代理（message broker）：接管消息发送者发送的消息.由消息代理保证将系消息发送到指定的目的地。 2.JMS（Java Message Service）JAVA消息服务，基于JVM消息代理的规范。 3.AMQP（Advanced Message Queuing Protocol） 高级消息队列协议...
Springboot 消息
百般回首曾经的相遇，留下的只是一缕残忆
06-08 2277
概述 通过消息服务中间件来提升系统异步通信、扩展解耦能力 消息服务中两个重要概念： 消息代理（message broker） 目的地（destination） 当消息发送者发送消息以后，将由消息代理接管，消息代理保证消息传递到指定目的地。 消息队列主要有两种形式的目的地 队列（queue）：点对点消息通信（point-to-point） 主题（topic）：发布（publish）或 订阅（subs...
SpringBoot对消息的支持
菜鸡旭旭
03-20 331
Spring对消息系统提供了扩展支持，使用jmsTemplate简化jmsAPI，实现一个异步接收消息的底层实现。 SpringAMPQ高级消息队列协议特征集 SpringBoot为rabbittemplate提供了自动化配置 Springwebsocket提供了原生的stomp消息支持， SpringBoot提供了starter和自动化配置 回顾一下jms ConnectionF...
Spring Boot 与消息
weixin_30617737的博客
02-03 77
一、消息概述 在大多数应用中，可以通过消息服务中间件来提升系统的异步通信、扩展解耦和流量削峰等能力。 当消息发送者发送消息后，将由消息代理接管，消息代理保证消息传递到指定目的地。 消息队列主要有两种形式的目的地： 队列（queue）：点对点消息通信（point-to-point）：消息发送者发送消息，消息代理将其送入一个队列中，消息接收者从队列中获取消息，消息被读取后被移出...
Cannot convert column 14 from array<struct<chapter_id:bigint,chapter_name:string,video_id:bigint,is_free:string>> to array<struct<chapter_id:string,chapter_name:string,video_id:string,is_free:string>>.
最新发布
07-14
通过使用 `cast` 函数，你可以将列 14 的数据类型从 `array<struct<chapter_id:bigint, chapter_name:string, video_id:bigint, is_free:string>>` 转换为 `array<struct<chapter_id:string, chapter_name:string, ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值