【2023】RabbitMQ wird mithilfe von Code mit Springboot implementiert

Nutzen Sie die Implementierung

YML-Konfigurationsdatei

#  设置端口号
server:
  port: 8089  
	#rabbitQM配置
spring:	
  rabbitmq:
		virtual-host: /      #角色
    addresses: 192.168.204.129
    port: 5672
    username: root
    password: root

1. Direktmodus

Verwenden Sie den Direktmodus, um Ihr Haar zu glätten

Direkt ist der Standard-Switch-Modus von RabbitMQ und auch der einfachste Modus. Das heißt, wenn Sie eine Nachrichtenwarteschlange erstellen, geben Sie einen BindingKey an. Wenn der Absender eine Nachricht sendet, geben Sie den entsprechenden Schlüssel an. Wenn der Schlüssel mit dem BindingKey des übereinstimmt Nachrichtenwarteschlange, die Nachricht wird an die Nachrichtenwarteschlange gesendet.

Eins zu eins

config: Konfigurationsklasse

Fügen Sie die Warteschlange in den Container ein und erstellen Sie sie während der Initialisierung: Die Klasse muss mit einer Konfigurationsklassenanmerkung hinzugefügt werden –@Configuration

Der abhängige Paketname der Warteschlange:import org.springframework.amqp.core.Queue;
```
/**
 *@Description//TODO把队列注入到容器中，让初始化时创建这个队列
*@Date2022/8/9 15:07
 *@return:org.springframework.amqp.core.Queue
 **/
@Bean
public Queue paymentNotifyQueue(){
          
          
    return new Queue("notify.payment");
}
```

Absender: Produzent

Eine Nachricht schicken:AmqpTemplate

/**
 *@program:RabbitMQ
 *@description:生产者-队列发送消息
*@author:zheng
 *@create:2022/08/09 14:32
 */
@Component
public class PaymentNotifySender {
          
          

    @Autowired
    private AmqpTemplate amqpTemplate;

    public void sender(String msg){
          
          
        System.err.println("notify.payment 发送消息："+msg);
//          发送消息到队列：队列名，发送的参数
        amqpTemplate.convertAndSend("notify.payment",msg);
    }

recive: Verbraucher

Der Parametertyp der empfangenden Nachrichtenmethode muss mit dem gesendeten Typ übereinstimmen

/**
 *@program:RabbitMQ
 *@description:消费者-接收队列消息
*@author:zheng
 *@create:2022/08/09 14:43
 *@RabbitListener监听的队列
*/
@Component
public class PaymentNotifyRecive {
          
          
/**
*@Description//TODO消费者消息处理的方法
*@param:msg从队列中接收的消息
* RabbitHandler表示该方法为接收消息的方法
**/
@RabbitListener(queues = "notify.payment")
    @RabbitHandler
    public void receive(String msg){
          
          
        System.out.println("接收来自notify.payment的消息："+msg);
    }

Eins zu viele:

Bei One-to-Many verwenden mehrere Empfänger Polling zum Empfang.

2. Themenmodus

Verwenden des Themenmodus des Schalters

Informationen zur Themenweiterleitung basieren hauptsächlich auf Platzhaltern, Warteschlangen und Switch-Bindungen. Es basiert hauptsächlich auf einem Muster (Platzhalter + Zeichenfolge). Beim Senden einer Nachricht wird die Nachricht nur dann an die Nachrichtenwarteschlange gesendet, wenn der angegebene Schlüssel mit dem Muster übereinstimmt.

Konfigurationsklasse: config

Um einen Schalter zu verwenden, müssen Sie drei Bean-Objekte einfügen: ein Warteschlangenobjekt (Queue), ein Schalterobjekt (TopicExchange) und ein Bindungsobjekt (Binding).
Ein Switch kann mehrere Warteschlangen binden
Der Name der Parameterwarteschlange im Bindungsobjekt muss mit dem Methodennamen der in die Warteschlange eingefügten Bean übereinstimmen.

/**
 * @program: RabbitMQ
 * @description: 注入交换机
 * @author: zheng
 * @create: 2022/08/09 15:53
 */
@Configuration
public class ToipcConfig {
        
        

/**
 *@Description//TODO注入队列
*@return:org.springframework.amqp.core.Queue
 **/
@Bean
public Queue coreQueue(){
        
        
    return new Queue("api.core");
}
/**
 *@Description//TODO注入交换机
*@return:org.springframework.amqp.core.TopicExchange
 **/
@Bean
public TopicExchange coreExchange(){
        
        
    return new TopicExchange("coreExchange");
}

/**
 *@Description//TODO绑定交换机和队列加路由键
*@param:coreQueue绑定的队列
*@param:coreExchange绑定的交换机
*@return:org.springframework.amqp.core.Binding返回绑定对象
**/
@Bean
public Binding bindingCore(Queue coreQueue , TopicExchange coreExchange){
        
        
    return BindingBuilder.bind(coreQueue).to(coreExchange).with("api.core.*");
}
}

Hersteller:
- RabbitTemplateAmqpTemplateImplementierungsklasse für die Schnittstelle
- Nur Warteschlangen, deren Routing-Schlüssel die Bedingungen erfüllen, werden empfangen

/**
 *@program:RabbitMQ
 *@description:用户管理
*@author:zheng
 *@create:2022/08/09 15:52
 */
@Component
public class ApiCoreSender {
        
        
    @Autowired
    private RabbitTemplate rabbitTemplate;
/**
*用户管理方法
*@parammsg
*/
public void user(String msg){
        
        
        System.out.println("api.core.user send message: "+msg);
        /*
         *发送消息：交换机、路由键、消息内容
         */
        rabbitTemplate.convertAndSend("coreExchange","api.core.user",msg);
    }

/**
     *查询用户方法
*@parammsg
*/
public void userQuery(String msg){
        
        
        System.out.println("api.core.user.query send message: "+msg);
        rabbitTemplate.convertAndSend("coreExchange","api.core.user.query");
    }
}

Verbraucher

/**
 *@program:RabbitMQ
 *@description:交换机模式=接收者
*/
@Component
public class ApiCoreRecive {
        
        
/**
     *接收用户发送到交换机的消息
* RabbitListener：监听的队列
* RabbitHandler：表示监听消息
*@parammsg
*/
@RabbitListener(queues = "api.core")
    @RabbitHandler
    public void getUser(String msg){
        
        
        System.out.println("api.core.user 接收到的消息:"+msg);
    }
}

3. Fanout-Modus

Verwendung des Fanout-Modus des Switches

Binden Sie mehrere Warteschlangen an einen Switch

Konfigurationsklasse: config


/**
 *@program:RabbitMQ
 *@description:fanout注入对象
*@author:zheng
 *@create:2022/08/09 17:22
 */
@Configuration
public class FanoutConfig {
        
        
//队列
    @Bean
    public Queue reportPaymentQueue(){
        
        
        return new Queue("api.report.payment");
    }
    @Bean
    public Queue reportRefundQueue(){
        
        
        return new Queue("api.report.refund");
    }
//交换机
    @Bean
    public FanoutExchange reportExchange(){
        
        
        return new FanoutExchange("reportExchange");
    }

/**
     *@Description//TODO绑定对象-Fanout广播模式
*@param:paymentQueue
     *@param:paymentExchange
     *@return:org.springframework.amqp.core.Binding
     **/
@Bean   
    public Binding bindingReportPaymentExchange(Queue reportPaymentQueue, FanoutExchange reportExchange){
        
        
        return BindingBuilder.bind(reportPaymentQueue).to(reportExchange);
    }
    @Bean
    public Binding bindingReportRefundExchange(Queue reportRefundQueue, FanoutExchange reportExchange){
        
        
        return BindingBuilder.bind(reportRefundQueue).to(reportExchange);
    }
}

Produzent: Absender

/**
 *@program:RabbitMQ
 *@description:发送报表
*@author:zheng
 *@create:2022/08/09 17:20
 */
@Component
public class ApiReportSender {
        
        
    @Autowired
    private AmqpTemplate amqpTemplate;

    public void generateReports(String msg){
        
        
        System.out.println("api.generate.reports 发送消息: "+msg);
        amqpTemplate.convertAndSend("reportExchange","",msg);
    }
}

Verbraucher: empfangen


/**
 *@program:RabbitMQ
 *@description:接收报表
*@author:zheng
 *@create:2022/08/09 17:26
 */
@Component
public class ApiReportRecive {
        
        
    @RabbitListener(queues = "api.report.payment")
    @RabbitHandler
    public void payment(String msg){
        
        
        System.out.println("接收用户报表："+msg);
    }

    @RabbitListener(queues = "api.report.refund")
    @RabbitHandler
    public void refund(String msg){
        
        
        System.out.println("接收市场报表："+msg);
    }
}