@ConfigurationpublicclassRabbitConfig {
@BeanpublicFanoutExchangeexchange(){
returnnewFanoutExchange("TEST");
    }
}

packagecom.zy.rabbitmq.controller;
importorg.springframework.amqp.rabbit.core.RabbitTemplate;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.web.bind.annotation.GetMapping;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.bind.annotation.RestController;
/*** @Author: Zy* @Date: 2022/3/14 15:04*/@RestController@RequestMapping("test")
publicclassTestController {
@AutowiredRabbitTemplaterabbitTemplate;
@GetMappingpublicvoidtest(){
rabbitTemplate.convertAndSend("TEST","","HHHH");
    }
}

/*** Declares all the exchanges, queues and bindings in the enclosing application context, if any. It should be safe* (but unnecessary) to call this method more than once.*/@Override// NOSONAR complexitypublicvoidinitialize() {
if (this.applicationContext==null) {
this.logger.debug("no ApplicationContext has been set, cannot auto-declare Exchanges, Queues, and Bindings");
return;
    }
// 获取spring注册的beanthis.logger.debug("Initializing declarations");
Collection<Exchange>contextExchanges=newLinkedList<Exchange>(
this.applicationContext.getBeansOfType(Exchange.class).values());
Collection<Queue>contextQueues=newLinkedList<Queue>(
this.applicationContext.getBeansOfType(Queue.class).values());
Collection<Binding>contextBindings=newLinkedList<Binding>(
this.applicationContext.getBeansOfType(Binding.class).values());
Collection<DeclarableCustomizer>customizers=this.applicationContext.getBeansOfType(DeclarableCustomizer.class).values();
processDeclarables(contextExchanges, contextQueues, contextBindings);
finalCollection<Exchange>exchanges=filterDeclarables(contextExchanges, customizers);
finalCollection<Queue>queues=filterDeclarables(contextQueues, customizers);
finalCollection<Binding>bindings=filterDeclarables(contextBindings, customizers);
for (Exchangeexchange : exchanges) {
if ((!exchange.isDurable() ||exchange.isAutoDelete())  &&this.logger.isInfoEnabled()) {
this.logger.info("Auto-declaring a non-durable or auto-delete Exchange ("+exchange.getName()
+") durable:"+exchange.isDurable() +", auto-delete:"+exchange.isAutoDelete() +". "+"It will be deleted by the broker if it shuts down, and can be redeclared by closing and "+"reopening the connection.");
   }
    }
for (Queuequeue : queues) {
if ((!queue.isDurable() ||queue.isAutoDelete() ||queue.isExclusive()) &&this.logger.isInfoEnabled()) {
this.logger.info("Auto-declaring a non-durable, auto-delete, or exclusive Queue ("+queue.getName()
+") durable:"+queue.isDurable() +", auto-delete:"+queue.isAutoDelete() +", exclusive:"+queue.isExclusive() +". "+"It will be redeclared if the broker stops and is restarted while the connection factory is "+"alive, but all messages will be lost.");
   }
    }
if (exchanges.size() ==0&&queues.size() ==0&&bindings.size() ==0&&this.manualDeclarables.size() ==0) {
this.logger.debug("Nothing to declare");
return;
    }
this.rabbitTemplate.execute(channel-> {
declareExchanges(channel, exchanges.toArray(newExchange[exchanges.size()]));
declareQueues(channel, queues.toArray(newQueue[queues.size()]));
declareBindings(channel, bindings.toArray(newBinding[bindings.size()]));
returnnull;
    });
if (this.manualDeclarables.size() >0) {
synchronized (this.manualDeclarables) {
this.logger.debug("Redeclaring manually declared Declarables");
for (Declarabledec : this.manualDeclarables.values()) {
if (decinstanceofQueue) {
declareQueue((Queue) dec);
     }
elseif (decinstanceofExchange) {
declareExchange((Exchange) dec);
     }
else {
declareBinding((Binding) dec);
     }
    }
   }
    }
this.logger.debug("Declarations finished");
 }

/*** If {@link #setAutoStartup(boolean) autoStartup} is set to true, registers a callback on the* {@link ConnectionFactory} to declare all exchanges and queues in the enclosing application context. If the* callback fails then it may cause other clients of the connection factory to fail, but since only exchanges,* queues and bindings are declared failure is not expected.** @see InitializingBean#afterPropertiesSet()* @see #initialize()*/@OverridepublicvoidafterPropertiesSet() {
synchronized (this.lifecycleMonitor) {
if (this.running||!this.autoStartup) {
return;
   }
if (this.retryTemplate==null&&!this.retryDisabled) {
this.retryTemplate=newRetryTemplate();
this.retryTemplate.setRetryPolicy(newSimpleRetryPolicy(DECLARE_MAX_ATTEMPTS));
ExponentialBackOffPolicybackOffPolicy=newExponentialBackOffPolicy();
backOffPolicy.setInitialInterval(DECLARE_INITIAL_RETRY_INTERVAL);
backOffPolicy.setMultiplier(DECLARE_RETRY_MULTIPLIER);
backOffPolicy.setMaxInterval(DECLARE_MAX_RETRY_INTERVAL);
this.retryTemplate.setBackOffPolicy(backOffPolicy);
   }
if (this.connectionFactoryinstanceofCachingConnectionFactory&&     ((CachingConnectionFactory) this.connectionFactory).getCacheMode() ==CacheMode.CONNECTION) {
this.logger.warn("RabbitAdmin auto declaration is not supported with CacheMode.CONNECTION");
return;
   }
// Prevent stack overflow...finalAtomicBooleaninitializing=newAtomicBoolean(false);
this.connectionFactory.addConnectionListener(connection-> {
if (!initializing.compareAndSet(false, true)) {
// If we are already initializing, we don't need to do it again...return;
    }
// 调用初始化方法try {
/** ...but it is possible for this to happen twice in the same ConnectionFactory (if more than* one concurrent Connection is allowed). It's idempotent, so no big deal (a bit of network* chatter). In fact it might even be a good thing: exclusive queues only make sense if they are* declared for every connection. If anyone has a problem with it: use auto-startup="false".*/if (this.retryTemplate!=null) {
this.retryTemplate.execute(c-> {
initialize();
returnnull;
        });
     }
else {
initialize();
     }
    }
finally {
initializing.compareAndSet(true, false);
    }
   });
this.running=true;
    }
 }

@Bean@ConditionalOnSingleCandidate(ConnectionFactory.class)
@ConditionalOnProperty(prefix="spring.rabbitmq", name="dynamic", matchIfMissing=true)
@ConditionalOnMissingBeanpublicAmqpAdminamqpAdmin(ConnectionFactoryconnectionFactory) {
returnnewRabbitAdmin(connectionFactory);
}

this.connectionFactory.addConnectionListener(connection-> {
if (!initializing.compareAndSet(false, true)) {
// If we are already initializing, we don't need to do it again...return;
    }
try {
/** ...but it is possible for this to happen twice in the same ConnectionFactory (if more than* one concurrent Connection is allowed). It's idempotent, so no big deal (a bit of network* chatter). In fact it might even be a good thing: exclusive queues only make sense if they are* declared for every connection. If anyone has a problem with it: use auto-startup="false".*/if (this.retryTemplate!=null) {
this.retryTemplate.execute(c-> {
initialize();
returnnull;
            });
        }
else {
initialize();
        }
    }
finally {
initializing.compareAndSet(true, false);
    }
});