敲详细的springframework-amqp-rabbit源码解析

已于 2024-07-19 20:39:55 修改
阅读量600 收藏 13
点赞数 19
分类专栏： 消息队列 文章标签： java rabbitmq 中间件
于 2024-07-19 20:28:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72397750/article/details/140558744
版权

看源码时将RabbitMQ的springframework-amqp-rabbit和spring-rabbit的一套区分开，springboot是基于RabbitMQ的Java客户端建立了简便易用的框架。

springboot的框架下相对更多地使用消费者Consumer和监听器Listener的概念，这两个概念不注意区分容易混淆。默认情况下，springboot中消费者为单线程串行消费的模型，体现了队列的特性。

在springboot的框架下使用rabbitmq的一般步骤

  1. 启动rabbitmq服务器，springboot项目引入依赖
  2. 配置信息，有两种方式
    1. 配置文件配置
    2. 配置类配置SimpleMessageListenerContainer
  3. 实现消息处理类ChannelAwareMessageListener处理业务逻辑，或用@RabbitListener注解

这两种方式其实异曲同工，@RabbitListener的方式在实际使用时创建MessagingMessageListenerAdapter，这个对象是ChannelAwareMessageListener接口的实现类，实现了onMessage()方法，这个方法利用了适配器模式，能够调用注解标注的方法，而实现ChannelAwareMessageListener的方式比较直白就是实现onMessage()方法

源码解析

关于SimpleMessageListenerContainer

SimpleMessageListenerContainer是在spring项目中使用RabbitMQ关键的类，用来接收并处理消息的。阅读源码可以从这个类入手。

  1. 首先关注构造器，需要传入ConnectionFactory用于获取连接，这跟原生rabbitmq是一致的，都从Connection连接开始。

  2. 关键属性

    concurrentConsumers：指定要创建的并发消费者的数量。默认值为1。建议增加并发使用者的数量，以便扩展从队列传入的消息的消耗。但是，请注意，一旦注册了多个消费者，将无法保证顺序。一般来说，对于低容量队列，坚持使用1个消费者。同时不能超过maxConcurrentConsumers(如果设置了)。

    maxConcurrentConsumers：设置消费者数量的上限。默认为concurrentConsumers。消费者可以根据需求增加，但不会小于concurrentConsumers。

    acknowledgeMode：消息确认模式

    // 自动确认消息
container.setAcknowledgeMode(AcknowledgeMode.NONE);
// 根据情况确认消息
container.setAcknowledgeMode(AcknowledgeMode.AUTO);
// 手动确认消息
container.setAcknowledgeMode(AcknowledgeMode.MANUAL);

  3. 绑定组件：

  4. 设置消费者的Consumer_tag和Arguments：container.setConsumerTagStrategy可以设置消费者的 Consumer_tag， container.setConsumerArguments可以设置消费者的 Arguments

    container.setConsumerTagStrategy(queue -> "order_queue_"+(++count));
//设置消费者的Arguments
Map<String, Object> args = new HashMap<>();
args.put("module","订单模块");
args.put("fun","发送消息");
container.setConsumerArguments(args);

    在这里插入图片描述

spring的亮点在于用注解简化了很多代码操作，其中最常用的当属@RabbitListener

@RabbitListener(queues = {BiMqConstant.BI_QUEUE_NAME}, ackMode = "MANUAL")
public void receiveMessage(String message, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag){
}

从@RabbitListener入手

1、从spring开启RabbitMQ的注解模式，@EnableRabbit导入RabbitBootstrapConfiguration配置类。

2、这个配置类定义了RabbitListenerAnnotationBeanPostProcessor和RabbitListenerEndpointRegistry两个bean。前者用来扫描加了@RabbitListener 的类，通过反射找到带注解的类，再找到对应的方法，存为handlerMethods。后者在注册终端后用于构建ListenerContainer（继承了RabbitListener注解内的信息，包括监听的队列和注解所在的类和方法）。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(RabbitBootstrapConfiguration.class)
public @interface EnableRabbit {
}

3、RabbitListenerEndpointRegistry通过创建MethodRabbitListenerEndpoint对象和SimpleRabbitListenerContainerFactory工厂bean，生成SimpleMessageListenerContainer对象。

（RabbitListenerAnnotationBeanPostProcessor中拥有注解信息，如队列名，以及被标注注解的方法，所以endpoint的注册还是在processor类中）

（processor中有注册员成员变量registrar的registerEndpoint()注册endpoint，registrar有注册处registry成员变量注册利用registerListenerContainer()的createListenerContainer()注册container）

public class RabbitListenerEndpointRegistry  implements SmartLifecycle{
 
	private final Map<String, MessageListenerContainer> listenerContainers =
			new ConcurrentHashMap<String, MessageListenerContainer>();
	//注册终端
	public void registerListenerContainer(RabbitListenerEndpoint endpoint, RabbitListenerContainerFactory<?> factory,
				boolean startImmediately) {
 
		String id = endpoint.getId();
		synchronized (this.listenerContainers) {
			//创建 listenerContainer
			MessageListenerContainer container = createListenerContainer(endpoint, factory);
			this.listenerContainers.put(id, container);
			……
 
			if (startImmediately) {
				startIfNecessary(container);
			}
		}
	}
 
	    protected MessageListenerContainer createListenerContainer(RabbitListenerEndpoint endpoint,
            RabbitListenerContainerFactory<?> factory) {
        //调用RabbitListener容器工厂的createListenerContainer方法获取RabbitListener容器
        MessageListenerContainer listenerContainer = factory.createListenerContainer(endpoint);
 
        return listenerContainer;
    }

4、SimpleMessageListenerContainer对象保存了要监听的队列名（可以是configuration时set的也可以是@RabbitListener中标注的），创建了用于处理消息的MessagingMessageListenerAdapter实例（实际上是一个listener）

public class MethodRabbitListenerEndpoint extends AbstractRabbitListenerEndpoint {
    ......
    @Override
    protected MessagingMessageListenerAdapter createMessageListener(MessageListenerContainer container) {
        Assert.state(this.messageHandlerMethodFactory != null,
                "Could not create message listener - MessageHandlerMethodFactory not set");
        MessagingMessageListenerAdapter messageListener = createMessageListenerInstance();
        messageListener.setHandlerMethod(configureListenerAdapter(messageListener));
        String replyToAddress = getDefaultReplyToAddress();
        if (replyToAddress != null) {
            messageListener.setResponseAddress(replyToAddress);
        }
        MessageConverter messageConverter = container.getMessageConverter();
        if (messageConverter != null) {
            messageListener.setMessageConverter(messageConverter);
        }
        if (getBeanResolver() != null) {
            messageListener.setBeanResolver(getBeanResolver());
        }
        return messageListener;
    }

    protected MessagingMessageListenerAdapter createMessageListenerInstance() {
        return new MessagingMessageListenerAdapter(this.bean, this.method);
    }
    
    ......
}

5、SimpleMessageListenerContainer的内部类AsyncMessageProcessingConsumer（区分，该类封装了BlockingQueueConsumer，由于该类实现了Runnable接口，可以视为一个线程任务放入线程池中执行）有一个run()方法，调用了receiveAndExecute()，这个方法会获取BlockingQueueConsumer，阻塞读取其消息（一次获取多条），完成消息读取。

6、接着调用listener进行消息处理，这里设置了代理，最终会执行actualInvokeListener所谓实际被执行的listener，溯源最终调用了listener.onMessage(message, channelToUse)。

SimpleMessageListenerContainer {
     //接受并执行
    private boolean receiveAndExecute(final BlockingQueueConsumer consumer) throws Throwable {
 
       //do接受并执行
        return doReceiveAndExecute(consumer);
    }
     //do接受并执行
    private boolean doReceiveAndExecute(BlockingQueueConsumer consumer) throws Throwable {
 
        Channel channel = consumer.getChannel();
        for (int i = 0; i < this.txSize; i++) {//txSize为一次事务接受的消息个数
            //读取消息，这里阻塞的，但是有一个超时时间。
            Message message = consumer.nextMessage(this.receiveTimeout);
            if (message == null) {//阻塞超时
				break;
			}
            try {
                executeListener(channel, message);//消息接收已完成，现在开始处理消息。
            }
            catch (Exception e) {}
        }
        return consumer.commitIfNecessary(isChannelLocallyTransacted());
    }
        
    
    //处理消息开始。该方法在其父类中
    protected void executeListener(Channel channel, Message messageIn) throws Exception {
        try {
            Message message = messageIn;
            if (……) {
                //批处理信息，这个不研究
            }else {
                invokeListener(channel, message);
            }
        }catch (Exception ex) {}
    }
    //在其父类中
    protected void invokeListener(Channel channel, Message message) throws Exception {
        //这里this.proxy.invokeListener最终会调用actualInvokeListener方法。
        this.proxy.invokeListener(channel, message);
    }
    //在其父类中
    protected void actualInvokeListener(Channel channel, Message message) throws Exception {
        Object listener = getMessageListener();
        if (listener instanceof ChannelAwareMessageListener) {
            doInvokeListener((ChannelAwareMessageListener) listener, channel, message);
        }
        else if (listener instanceof MessageListener) {
            //……
            doInvokeListener((MessageListener) listener, message)
        }else{
            //……
        }
        
    }    
 
    protected void doInvokeListener(ChannelAwareMessageListener listener, Channel channel, Message message)
            throws Exception {
            Channel channelToUse = channel;
            try {
                listener.onMessage(message, channelToUse);
            }
            catch (Exception e) {
                throw wrapToListenerExecutionFailedExceptionIfNeeded(e, message);
            }
 
    }
}

7、关于第6点，根据这个listener实例的不同，有两种处理方式：

如果是前面所说的实现ChannelAwareMessageListener，就直接调用实现类的onMessage()。

如果是@RabbitListener注解，不同在于MessagingMessageListenerAdapter（ChannelAwareMessageListener的实现类，也是listen），基于适配器模式持有@RabbitListener注解的对象和方法（adapter实例中有HandlerMethod属性加入到adapter类中，HandlerMethod调用invoke()就能执行注解标注的方法）。

public class HandlerAdapter {
  private final InvocableHandlerMethod invokerHandlerMethod;
  private final DelegatingInvocableHandler delegatingHandler;
 
  public Object invoke(Message<?> message, Object... providedArgs) throws Exception                
  {
      if (this.invokerHandlerMethod != null) {
          //InvocableHandlerMethod不为null,就调用invokerHandlerMethod.invoke方法。
          return this.invokerHandlerMethod.invoke(message, providedArgs);
 
      }else if (this.delegatingHandler.hasDefaultHandler()) {
            //……
      }else {
            //……
      }
   }
}
public class MessagingMessageListenerAdapter extends AbstractAdaptableMessageListener {
	private HandlerAdapter handlerMethod;
}

现在就能把整个过程串起来了

关于关于endpoint和register

Endpoint为终端，像电脑、手机都是终端，他们都可以接受外部信息并响应，如手机来短信了就有提示。这里也用了终端的概念，被@RabbitListener注解修饰方法也有终端的特点可以接受外部信息并响应，即接到消息就执行对应方法。

registry姑且成为注册处用Map保存endpoint的id和对应的listenerContainer，注册处registerListenerContainer()利用endpoint和factory实例创建container，实际上是用了containerfactory的createListenerContainer(RabbitListenerEndpoint endpoint)方法

public class RabbitListenerEndpointRegistry implements DisposableBean, SmartLifecycle, ApplicationContextAware,
        ApplicationListener<ContextRefreshedEvent> {
        // 检查是否被注册过，注册过就不能注册第二次
        // 调用createListenerContainer创建消息监听
        // 关于分组消费的，我们不关心
        // 是否立即启动，是的话，同步调用startIfNecessary方法
        public void registerListenerContainer(RabbitListenerEndpoint endpoint, RabbitListenerContainerFactory<?> factory,
                                          boolean startImmediately) {
        Assert.notNull(endpoint, "Endpoint must not be null");
        Assert.notNull(factory, "Factory must not be null");

        String id = endpoint.getId();
        Assert.hasText(id, "Endpoint id must not be empty");
        synchronized (this.listenerContainers) {
            Assert.state(!this.listenerContainers.containsKey(id),
                    "Another endpoint is already registered with id '" + id + "'");
            MessageListenerContainer container = createListenerContainer(endpoint, factory);
            this.listenerContainers.put(id, container);
            if (StringUtils.hasText(endpoint.getGroup()) && this.applicationContext != null) {
                List<MessageListenerContainer> containerGroup;
                if (this.applicationContext.containsBean(endpoint.getGroup())) {
                    containerGroup = this.applicationContext.getBean(endpoint.getGroup(), List.class);
                }
                else {
                    containerGroup = new ArrayList<MessageListenerContainer>();
                    this.applicationContext.getBeanFactory().registerSingleton(endpoint.getGroup(), containerGroup);
                }
                containerGroup.add(container);
            }
            if (startImmediately) {
                startIfNecessary(container);
            }
        }

    // 其实就是调用了RabbitListenerContainerFactory的createListenerContainer生成了一个MessageListenerContainer对象
    protected MessageListenerContainer createListenerContainer(RabbitListenerEndpoint endpoint,
            RabbitListenerContainerFactory<?> factory) {

        MessageListenerContainer listenerContainer = factory.createListenerContainer(endpoint);

        if (listenerContainer instanceof InitializingBean) {
            try {
                ((InitializingBean) listenerContainer).afterPropertiesSet();
            }
            catch (Exception ex) {
                throw new BeanInitializationException("Failed to initialize message listener container", ex);
            }
        }

        int containerPhase = listenerContainer.getPhase();
        if (containerPhase < Integer.MAX_VALUE) {  // a custom phase value
            if (this.phase < Integer.MAX_VALUE && this.phase != containerPhase) {
                throw new IllegalStateException("Encountered phase mismatch between container factory definitions: " +
                        this.phase + " vs " + containerPhase);
            }
            this.phase = listenerContainer.getPhase();
        }

        return listenerContainer;
    }
}

把endpoint内的信息全部注入到container里。

@Override
public C createListenerContainer(RabbitListenerEndpoint endpoint) {
    C instance = createContainerInstance();

    if (this.connectionFactory != null) {
        instance.setConnectionFactory(this.connectionFactory);
    }
    if (this.errorHandler != null) {
        instance.setErrorHandler(this.errorHandler);
    }
    if (this.messageConverter != null) {
        instance.setMessageConverter(this.messageConverter);
    }
    if (this.acknowledgeMode != null) {
        instance.setAcknowledgeMode(this.acknowledgeMode);
    }
    if (this.channelTransacted != null) {
        instance.setChannelTransacted(this.channelTransacted);
    }
    if (this.autoStartup != null) {
        instance.setAutoStartup(this.autoStartup);
    }
    if (this.phase != null) {
        instance.setPhase(this.phase);
    }
    instance.setListenerId(endpoint.getId());
    // 最重要的一行！！！
    endpoint.setupListenerContainer(instance);
    initializeContainer(instance);

    return instance;
}

关于container和containerFactory

containerFactory也能配置并发消费者等参数。

@Configuration
@EnableAsync
public class ThreadPoolConfig { 
    @Bean("customContainerFactory") 
    public SimpleRabbitListenerContainerFactory containerFactory(SimpleRabbitListenerContainerFactoryConfigurer configurer, ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConcurrentConsumers(10); //设置线程数
        factory.setMaxConcurrentConsumers(10); //最大线程数
        configurer.configure(factory, connectionFactory);
        return factory; 
    }
}

配置containerFactory能够创建container，但一般不在配置类中手动创建。一般是在注解中标记，然后让spring来生产container。

@RabbitListener(queues="demo.queue",containerFactory = "customContainerFactory")

直接配置container效果是相同的，同样可以设置队列，并发消费者等。

细说上面第5步container内的操作。

  1. container的启动入口是star()方法，然后进入doStart()，在该方法中会初始化consumer（BlockingQueueConsumer），每一个并发需要对应一个consumer，consumer的数量是根据前面所说的concurrentConsumers确定

    consumer = new BlockingQueueConsumer(getConnectionFactory(), getMessagePropertiesConverter(),
				this.cancellationLock, getAcknowledgeMode(), isChannelTransacted(), actualPrefetchCount,
				isDefaultRequeueRejected(), getConsumerArguments(), isNoLocal(), isExclusive(), queues);
// 带有连接信息，数据转换器，确认模式，预取值，consumerArgs，监听的队列（可多个）等信息传入

区分一下consumer和listener，consumer是接收消息的消费者，listener是实际处理业务的执行者，consumer接收的每个消息都需要调用listener内的onMessage()方法来处理实际业务。

int newConsumers = initializeConsumers();
  1. 然后将consumer封装成AsyncMessageProcessingConsumer线程任务类型，然后就可以放入线程池中执行。
AsyncMessageProcessingConsumer processor = new AsyncMessageProcessingConsumer(consumer);
processors.add(processor);
getTaskExecutor().execute(processor);

  1. 这里的线程池是SimpleAsyncTaskExecutor（也可以自定义传入），默认是不限制并发量的。每个container都有一个线程池，线程不足以支持consumer并发时就会超时报错。

    private Executor taskExecutor = new SimpleAsyncTaskExecutor();

  2. 进入AsyncMessageProcessingConsumer这个Runnable类的run()方法，如果consumer有监听的队列，就初始化initialize并开启mainloop()

    if (this.consumer.getQueueCount() < 1) {
    ...
}
try {
    initialize();
    while (isActive(this.consumer) || this.consumer.hasDelivery() || !this.consumer.cancelled()) {
        mainLoop();
    }
}

  3. initialize()会创建exchange、queue、bindings等实例，设置Qos，实现consumer与broker之间的对接，完成消息的订阅，并且会根据tag不同在每个BlockingQueueConsumer中再划分出internalConsumer，再放入BlockingQueueConsumer的queue中逐一处理。

    说明Qos流控指令包括prefetch-size、prefetch-count参数。

    //该参数是设置在channel上的
int prefetchCount = 1;
channel.basicQos(prefetchCount);

    broker的delivery指令在客户端会先打包成一个Envelope，所以consumertag是对应consumer一个，而deliveryTag是对应broker中的一条消息一个。

    Envelope envelope = new Envelope(m.getDeliveryTag(),
                                         m.getRedelivered(),
                                         m.getExchange(),
                                         m.getRoutingKey());

    当然在broker执行delivery指令将消息推送到客户端Consumer之前还有channel，一个BlockingQueueConsumer对应一个channel，对应一个线程的调用。内部的consumer共用channel，channel会根据tag在dispatcher将消息推送至对应的consumer。

    一个channel对应了多个consumer

    在这里插入图片描述

    多个AsyncMessageProcessingConsumer对应不同的线程来处理

    在这里插入图片描述

    一个container可能监听多个队列。

    在这里插入图片描述

  4. mainLoop()相较于如何利用consumer接收消息，更侧重于最终的listener来进行业务处理。前面已经知道客户端会将消息存到Consume的queue中，简单来说，mainloop就是只要客户端正常启动就会无限循环来处理业务的，它主要就是完成从queue中提取消息数据然后经过一系列操作最终传递给业务逻辑处理MessageListener中。

    mainLoop()方法中就会从queue中提取消息，根据**batchSize**确定每次提取消息数量，最后回调MessageListener，实现将消息传递到业务逻辑进行处理；

    多个AsyncMessageProcessingConsumer对应一个listener（一个container对应一个listener即是一套处理业务，共用一个线程池，因为它们只是对应不同的并发， 处理的业务逻辑应是相同的。

    在这里插入图片描述

增加RabbitMQ并发的方法

  1. 增加并发消费者数量。并保障能提供充足的线程资源，虽然默认的线程池不设线程并发上线。示例：Redis与RabbitMQ配合使用多线程（多消费者）处理消息_多线程 处理 rabbitmq消息-CSDN博客

  2. 在listener方法上加上@Async()，这样会在异步的子线程下执行，如果提供线程池，就能实现并发。示例：线程池解决RabbitMQ消息堆积_rabbitmq线程池-CSDN博客

  3. 增大prefetchCount，prefetchCount是BlockingQueueConsumer内部维护的一个阻塞队列LinkedBlockingQueue的大小，其作用就是如果某个消费者队列阻塞，就无法接收新的消息

  4. 配置container的自定义线程池，但这个方法不推荐，示例：【RabbitMQ-9】自定义配置线程池（线程池资源不足-MQ初始化队列&&MQ动态扩容影响） - 简书 (jianshu.com)

  5. 当并发量确实无法短时间内提高时，也应尽可能提高消息队列的容量，并开启持久化。如设置惰性队列。

    RabbitMQ 从 3.6.0 版本开始引入了惰性队列的概念。惰性队列会尽可能的将消息存入磁盘，而在消费者消费到相应的消息时才会被加载到内存中，它的一个重要的设计目标是能够支持更长的队列，即支持更多的消息存储。当消费者由于各种各样的原因(比如消费者下线、宕机亦或者是由于维护而关闭等)而致使长时间内不能消费消息造成消息堆积时，惰性队列就很有必要了。

    正常的队列会尽可能存储在内存中。

加糖苏打水
关注
  • 19
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-amqp,spring-retry,spring-rabbit
05-07
标题中的"spring-amqp"、"spring-retry"和"spring-rabbit"是Spring框架的三个关键组件，它们主要用于构建高效、可靠的分布式系统，尤其是在消息传递和错误处理方面。 1. **Spring AMQP**: Spring AMQP是Spring框架...
spring-cloud-config + spring-cloud-bus-amqp实现分布式集群配置动态更新
08-05
Spring Cloud Config 和 Spring Cloud Bus AMQP 的结合使用为解决这一问题提供了一种优雅的解决方案。让我们深入探讨这两个组件以及它们如何协同工作来实现配置的动态更新。 Spring Cloud Config 是一个用于微服务...
Spring Boot异步消息之AMQP讲解及实战（附源码）
showswoller的博客
10-29 2394
Spring Boot异步消息之AMQP讲解及实战（附源码） 通过一个发布者订阅者实例讲解
【转】Spring AMQP 源码分析 01 - Impatient
AnY11的专栏
10-03 263
转自首夜盲毒预言家的文章 Spring AMQP 源码分析 01 - Impatient ### 准备   ## 目标 了解 Spring AMQP 核心代码   ## 前置知识 RabbitMQ 入门   ## 相关资源   Quick Tour for the impatient：&lt;http://docs.spring.io/spring-amqp/docs/1....
Spring AMQP 源码分析 - MessageListener
weixin_39713838的博客
12-28 494
Spring AMQP 源码分析 04 - MessageListener 引用地址 源码版本：Spring AMQP 1.7.3.RELEASE 测试代码 分析 MessageListener org.springframework.amqp.core.MessageListener 是 Spring AMQP 异步消息投递的监听器接口，它只有一个方法 onMessage，用于处理消息队列推送...
已解决org.springframework.amqp.AmqpException: No method found: AMQP异常的正确解决方法，亲测有效！！！
小明的Java问道之路
03-26 1237
已解决org.springframework.amqp.AmqpException: No method found: AMQP异常的正确解决方法，亲测有效！！！
Spring Boot文档阅读笔记-对Messaging with RabbitMQ解析
IT1995的博客
11-26 667
此篇教程以Rabbitmq作为消息队列服务端，使用Spring Boot产生和发布消息。 使用Spring AMQP的RabbitTemplate发布消息，使用MessageListenerAdapter订阅消息。 其中对应的Maven如下： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3...
【转】Spring AMQP 源码分析 03 - MessageConverter
AnY11的专栏
10-03 545
转自首夜盲毒预言家 ### 准备 ## 目标 了解 Spring AMQP 消息转化实现   ## 相关资源 Quick Tour for the impatient：&lt;http://docs.spring.io/spring-amqp/docs/1.7.3.RELEASE/reference/html/_reference.html#message-converters&gt;...
已解决org.springframework.amqp.AmqpResourceNotAvailableException: The channelMax limit is reached异常的正确解
小明的Java问道之路
03-28 993
已解决org.springframework.amqp.AmqpResourceNotAvailableException: The channelMax limit is reached异常的正确解决方法，亲测有效！！！
Spring AMQP 源码分析 03 - MessageConverter
denggouda2767的博客
06-22 207
### 准备 ## 目标 了解 Spring AMQP 消息转化实现 ## 相关资源 Quick Tour for the impatient：<http://docs.spring.io/spring-amqp/docs/1.7.3.RELEASE/reference/html/_reference.html#message-converte...
Spring AMQP 源码详解 （部分） 转载 学习
waitzkj的博客
12-28 638
### 准备 ## 目标 了解 Spring AMQP 如何实现异步消息投递（推模式） ## 前置知识 《RabbitMQ入门_05_多线程消费同一队列》 ## 相关资源 Quick Tour for the impatient：&lt;http://docs.spring.io/spring-amqp/docs/1.7.3.RELEASE/reference/html/_refere...
spring-framework-4.3.30.RELEASE-dist.zip
01-07
在提供的压缩包`spring-framework-4.3.30.RELEASE-dist.zip`中，包含了以下几个关键部分： 1. **docs文件夹**：这是Spring框架的文档资料，包括API参考、用户指南、开发者指南等。对于学习和理解Spring框架的用法、...
spring-framework-5.3.21.zip源码
06-22
这个"spring-framework-5.3.21.zip"源码压缩包包含了Spring框架的最新稳定版本5.3.21的全部源代码，让我们有机会深入理解其内部机制。 Spring的核心特性包括依赖注入（Dependency Injection，DI）、面向切面编程...
spring-amqp-2.0.3.RELEASE.jar
12-12
spring-amqp-2.0.3.RELEASE.jar
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 829
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 901
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1022
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
最新发布
m0_69266818的博客
07-15 829
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
spring-amqp对应springboot版本
01-13
根据提供的引用内容，没有直接提到spring-amqp对应springboot版本的信息。但是可以通过查阅官方文档或者其他资源来获取相关信息。以下是一种获取spring-amqp对应springboot版本的方法： 1. 查阅Spring官方文档：可以在Spring官方文档中找到关于spring-amqp的详细信息，包括与Spring Boot的集成和对应的版本。你可以访问Spring官网并查找与你使用的Spring Boot版本相对应的spring-amqp版本。 2. 查阅Spring Boot官方文档：Spring Boot官方文档中也提供了关于与spring-amqp集成的信息。你可以查找与你使用的Spring Boot版本相对应的spring-amqp版本。 3. 在Maven仓库中查找：你可以在Maven仓库中搜索spring-amqp，然后查看与你使用的Spring Boot版本相对应的spring-amqp版本。 请注意，具体的spring-amqp版本与Spring Boot版本之间的对应关系可能会因时间而变化，因此建议查阅最新的官方文档或资源来获取准确的信息。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值