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);
}

测试后在管控台看到消息

主要结构