springboot2.1以javabean整合rabbitmq及自动注入rabbitmqTemplate为空问题

springboot集成rabbitmq之前也写过，这次再来个总结，总体来讲比较简单

主要就是配置属性文件，将属性以javabean的形式注入，配置工厂，对象等原来以xml<bean>形式注入的对象。

代码如下properties属性

#rabbitMQ配置
rabbit.config.host=192.168.135.129
rabbit.config.port=5672
rabbit.config.userName=guest
rabbit.config.password=guest

 /**
  *
  */
 package com.sharp.forward.config;

 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.context.annotation.PropertySource;
 import org.springframework.stereotype.Component;

 /**
  * @author 醉逍遥
  *
  */
 @Component
 @ConfigurationProperties(prefix="rabbit.config")
 @PropertySource(value="classpath:config/rabbitmq.properties",encoding="utf-8")
 public class RabbitMQProperties {

     public String getHost() {
         return host;
     }

     public void setHost(String host) {
         this.host = host;
     }

     public int getPort() {
         return port;
     }

     public void setPort(int port) {
         this.port = port;
     }

     public String getUserName() {
         return userName;
     }

     public void setUserName(String userName) {
         this.userName = userName;
     }

     public String getPassword() {
         return password;
     }

     public void setPassword(String password) {
         this.password = password;
     }

     private  String host;

     private int port;

     private  String userName;

     private  String password;

 }

 /**
  *
  */
 package com.sharp.forward.config;

 import org.springframework.amqp.core.Binding;
 import org.springframework.amqp.core.BindingBuilder;
 import org.springframework.amqp.core.DirectExchange;
 import org.springframework.amqp.core.FanoutExchange;
 import org.springframework.amqp.core.Queue;
 import org.springframework.amqp.core.TopicExchange;
 import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
 import org.springframework.amqp.rabbit.connection.ConnectionFactory;
 import org.springframework.amqp.rabbit.core.RabbitAdmin;
 import org.springframework.amqp.rabbit.core.RabbitTemplate;
 import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
 import org.springframework.amqp.support.ConsumerTagStrategy;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.stereotype.Component;

 /**
  * @author 醉逍遥
  *
  */
 @Configuration
 public class RabbitMQConf{

     @Autowired
     private RabbitMQProperties rabbitMQProperties;

 //    获取连接工厂
     @Bean
     public ConnectionFactory factory() {
         CachingConnectionFactory factory = new CachingConnectionFactory();
         factory.setHost(rabbitMQProperties.getHost());
         factory.setPort(rabbitMQProperties.getPort());
         factory.setUsername(rabbitMQProperties.getUserName());
         factory.setPassword(rabbitMQProperties.getPassword());
         return factory;
     }
 //    获取rabbitmqAdmin
     @Bean
     public RabbitAdmin rabbitAdmin(ConnectionFactory factory) {
         RabbitAdmin admin = new RabbitAdmin(factory);
         admin.setAutoStartup(true);
         return admin;
     }

     @Bean
     public RabbitTemplate rabbitTemplate(ConnectionFactory factory) {
         RabbitTemplate template =new RabbitTemplate(factory);
         return template;
     }

     /**
      * 不配置这个容器，启动项目时候，rabbitmq的管控台看不到动作
      * @param factory
      * @return
      */
     @Bean
     public SimpleMessageListenerContainer container(ConnectionFactory factory) {
         SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(factory);
         container.setConsumerTagStrategy(new ConsumerTagStrategy() {

             @Override
             public String createConsumerTag(String queue) {
                 return null;
             }
         });
         return container;
     }

 //    定义交换器
     public static final String SHARP_EXANGE_TEST_001="sharpExchangeTest001";

     public static final String SHARP_EXANGE_TEST_002="sharpExchangeTest002";

     public static final String SHARP_EXANGE_TEST_003="sharpExchangeTest003";
 //    定义队列
     public static final String SHARP_QUEUE_TEST_001="sharpQueueTest001";

     public static final String SHARP_QUEUE_TEST_002="sharpQueueTest002";

     public static final String SHARP_QUEUE_TEST_003="sharpQueueTest003";
 //    定义路由键
     public static final String SHARP_ROUTINGKEY_TEST_001="sharp.test";

     public static final String SHARP_ROUTINGKEY_TEST_002="sharp.topic.#";

     @Bean(name="sharpExchangeTest001")
     public DirectExchange getExchage_001() {
         return new DirectExchange(SHARP_EXANGE_TEST_001, true, false, null);
     }
     @Bean(name="sharpExchangeTest002")
     public TopicExchange getExchange_002() {
         return new TopicExchange(SHARP_EXANGE_TEST_002, true, false, null);
     }
     @Bean(name="sharpExchangeTest003")
     public FanoutExchange getExchange_003() {
         return new FanoutExchange(SHARP_EXANGE_TEST_003, true, false, null);
     }
     @Bean(name="sharpQueueTest001")
     public Queue getQueue_001() {
         return new Queue(SHARP_QUEUE_TEST_001, true, false, false, null);
     }
     @Bean(name="sharpQueueTest002")
     public Queue getQueue_002() {
         return new Queue(SHARP_QUEUE_TEST_002, true, false, false, null);
     }
     @Bean(name="sharpQueueTest003")
     public Queue getQueue_003() {
         return new Queue(SHARP_QUEUE_TEST_003, true, false, false, null);
     }
 //    定义绑定
     @Bean
     public Binding getDirectBinding() {
         return BindingBuilder.bind(getQueue_001()).to(getExchage_001()).with(SHARP_ROUTINGKEY_TEST_001);
     }

     @Bean
     public Binding getTopicBinding() {
         return BindingBuilder.bind(getQueue_002()).to(getExchange_002()).with(SHARP_ROUTINGKEY_TEST_002);
     }

     @Bean
     public Binding getFauoutBinding() {
         return BindingBuilder.bind(getQueue_003()).to(getExchange_003());
     }
 }

rabbitUtil

 /**
  *
  */
 package com.sharp.forward.util;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.amqp.rabbit.core.RabbitTemplate;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

 import com.sharp.forward.config.RabbitMQConf;

 /**
  * @author 醉逍遥
  */
 @Component
 public class RabbitUtil {

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

     @Autowired
     private RabbitTemplate template;

     public void sendObjectMessage(Object obj) {
         template.convertAndSend("sharpExchangeTest001", "sharp.test", obj);
     }

     public void sendStringMessage(String message) {

     }

     public void sendMessage(String message) {
         logger.info("rabbitUtil发送消息前的信息：{}",message);
         logger.info("template是否为空：{}",(template==null));
         template.convertAndSend(RabbitMQConf.SHARP_EXANGE_TEST_001, RabbitMQConf.SHARP_ROUTINGKEY_TEST_001, message==null?"hello":message);
     }
 }

rabbitServiceImpl(service代码就不贴了)

 /**
  *
  */
 package com.sharp.forward.user.serviceImpl;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;

 import com.sharp.forward.user.service.RabbitService;
 import com.sharp.forward.util.RabbitUtil;

 /**
  * @author 醉逍遥
  *
  */
 @Service("rabbitService")
 @Transactional(readOnly=true)
 public class RabbitServiceImpl implements RabbitService{

     private static final Logger logger = LoggerFactory.getLogger(RabbitServiceImpl.class);
     @Autowired
     private RabbitUtil util;
     @Override
     public void sendObjectMessage(String message) {
         logger.info("要发送的参数是：------> {}",message);
         util.sendMessage(message);
     }
 }

之前运行一直在rabbitUtil中报rabbitTemplate注入始终为空，导致消息不能发送，是因为我之前在service层25行处用的RabbitUtil不是用的@Autowired注入，而是用了new RabbitUtil，尽管RabbitUtil中用的@Autowired注入了模板，找错时一直在rabbitUtil中找找不到错误，后来将RabbitUtil注解为@Companent，service层对应修改为spring注入，Ok

启动项

package com.sharp.forward;

import org.mybatis.spring.annotation.MapperScan;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.sharp.forward.config.RabbitMQProperties;

@SpringBootApplication
//@ImportResource("classpath:config/application-user-service-dubbo.xml")
@MapperScan(basePackages= {"com.sharp.forward.mapper"})
@EnableAutoConfiguration
public class Application implements CommandLineRunner{

    private static final Logger log = LoggerFactory.getLogger(Application.class);
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Autowired
    private RabbitMQProperties rabbitMQProperties;

    /**
     * @param args
     * @throws Exception
     */
    @Override
    public void run(String... args) throws Exception {
         String config = "host: " + rabbitMQProperties.getHost()
         + ", config.port:" + rabbitMQProperties.getPort()
         + ", config.userName:" + rabbitMQProperties.getUserName();

         log.info("SpringBoot2.0实现自定义properties配置文件与JavaBean映射: {}" , config);

    }

}

然后在消费服务中测试

代码如下

@PostMapping("/sendString")
public void sendString(@Param(value = "message") String message) {
logger.info("start send message test: {}",message);
rabbitService.sendObjectMessage(message);
}

测试后在管控台看到消息

主要结构