rabbitMQ在spring boot中的简单应用

• 在项目中引入amqp依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
    <version>2.7.3</version>
</dependency>

• 在yml中配置rabbitmq

spring:
  rabbitmq:
    host: 192.168.160.128
    port: 5672
    username: guest
    password: guest

• rabbitmq基本类型中Direct消息模型，利用routingKey将交换机与队列绑定在一起，由消息生产者发送消息给交换机，再通过routingKey找到对应的队列，最后将消息发送给消息消费者

• 话不多说上干货，我们这里将两种方式，一种是在项目启动时，如果没有你设置的交换机和队列时通过@Bean创建交换机与队列，另一种是在发送消息时，如果发现没有交换机和队列时，会自动创建交换机与队列（个人推荐第二种，非要说为什么的话就是我懒，这么写简单）

//第一种方式
@Configuration
public class RabbitConfig {
    //队列名称
    public static final String Queue_A = "testQueue";
    //交换机名称
    public static final String Exchange_A = "testExchange";
    //RoutingKey
    public static final String Routing_A = "testRouting";
    //队列名称
    public static final String Queue_B = "testQueue2";
    //交换机名称
    public static final String Exchange_B = "testExchange2";
    //RoutingKey
    public static final String Routing_B = "testRouting2";
    @Bean
    public Queue getQueue(){
        return new Queue(Queue_A,true);
    }
    @Bean
    public Exchange getExchange(){
        return new DirectExchange(Exchange_A,true,false);
    }
    @Bean
    public Binding getBinding(){
        return BindingBuilder.bind(getQueue()).to(getExchange()).with(Routing_A).noargs();
    }
}

//第一种方式的消息消费者
@Component
public class RabbitListenerService {
    @RabbitListener(queues = RabbitConfig.Queue_A)
    public void test(String message, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag, Channel channel) throws IOException {
        System.out.println("接收的消息为：" + message);
    }
}

//第二种方式
@Component
public class RabbitListenerService {
    @RabbitListener(bindings = @QueueBinding(
            exchange = @Exchange(value = RabbitConfig.Exchange_B),
            value = @Queue(value = RabbitConfig.Queue_B),
            key = {RabbitConfig.Routing_B}
    ))
    public void test(String message, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag, Channel channel) throws IOException {
        System.out.println("接收的消息为：" + message);
    }
}

• 发送消息（我这里是自己用aop形式发送的消息,可以直接发送）

//可以直接写成这样
//
@GetMapping("login")
public Result save(){
    String text = "泰罗奥特曼";
    //发送消息（生产者）
    rabbitTemplate.convertAndSend(RabbitConfig.Exchange_B,RabbitConfig.Routing_B,text);
    return Result.ok(text,"生产成功");
}

//注解形式
//下面的供大家参考，在代码复用的时候用处还是蛮大的
@Message(exchange = RabbitConfig.Exchange_B,
        routingKey = RabbitConfig.Routing_B)
@GetMapping("login")
public Result save(){
    String text = "泰罗奥特曼";
    return Result.ok(text,"生产成功");
}

//注解内容
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Message {
    String exchange();
    String routingKey();
}

//切面工具类
@Component
@Aspect
public class AopUtils {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Pointcut("@annotation(com.example.bootone.utils.aop.annotation.Message)")
    public void sysLog() {}

    @Around("sysLog()")//ProceedingJoinPoint
    public Object logAspect(ProceedingJoinPoint joinPoint) throws Throwable {
        // 第二种
        //String paths = ((MethodSignature) joinPoint.getSignature()).getMethod().getAnnotation(Message.class).dataSource();
        Message annotation = null;
        Result proceed = null;
        try {
            Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
            annotation = method.getAnnotation(Message.class);
            String exchange = annotation.exchange();//交换机
            String routingKey = annotation.routingKey();//路由
            // 得到被代理的方法
            proceed = (Result)(joinPoint).proceed();
            //拿到的消息
            Object data = proceed.getData();
            System.out.println("proceed = " + data);
            //发送消息（生产者）
            rabbitTemplate.convertAndSend(exchange,routingKey,data);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }finally {
            return proceed;
        }
    }
}

• 测试结果