RabbitMQ learning-le deuxième démarrage rapide HelloWorld

1. Concepts associés

RabbitMQ est un courtier de messages, en fait, il reçoit les messages générés par les producteurs et transmet ensuite les messages aux consommateurs. Dans ce processus, il peut être routé, mis en mémoire tampon ou plus persistant selon les règles que vous définissez. RabbitMQ et la transmission de messages utilisent généralement certains termes:

• Producteur (Produire) : Cela
  ne signifie rien de plus que la fin qui envoie le message. Si un programme envoie un message, il sera appelé producteur, représenté par un grand P.

• File d'attente (queue) :
  équivalente au nom de la boîte aux lettres, elle est active sur le serveur RabbitMQ. Bien que le flux de messages passe par RabbitMQ et votre application, il ne sera stocké que dans la file d'attente. La file d'attente n'est soumise à aucune restriction, elle peut stocker autant de messages que vous le souhaitez (c'est essentiellement un tampon infini). Plusieurs producteurs peuvent envoyer des messages à la même file d'attente de messages, ou plusieurs consommateurs peuvent recevoir des messages d'une file d'attente de messages en même temps.

• Consommateur (Consommation) :
  Autrement dit, l'extrémité de réception, le consommateur est principalement un programme en attente de recevoir des messages.

  Remarque: Dans la plupart des scénarios d'application, les producteurs, les consommateurs et les services RabbitMQ ne s'exécuteront pas sur la même machine en même temps.

2. Package client Java

RabbitMQ est conforme au protocole AMQP, qui est un protocole de messagerie ouvert et universel. Concernant le client de protocole AMQP, il existe plusieurs versions d'implémentation de langue. Cet article utilise le client Java fourni par RabbitMQ.

Il peut être téléchargé depuis http://www.rabbitmq.com/java-client.html, puis copiez le package Jar correspondant dans votre répertoire de travail. Le client Java de RabbitMQ est également disponible dans la bibliothèque Maven, groupId est com.rabbitmq et artifactId est amqp-client.

3. Client

Nous avons nommé l'expéditeur du message Send et le destinataire du message Recv. L'expéditeur se connectera à RabbitMQ, enverra un message, puis quittera.

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;

public class Send {
  private final static String QUEUE_NAME = "hello";

  public static void main(String[] argv) throws java.io.IOException {
    /*连接可以抽象为socket连接，为我们维护协议版本信息和协议证书等。这里我们连接
    上了本机的消息服务器实体（localhost）。如果我们想连接其它主机上的RabbitMQ服务，只需要修改一下主机名或是IP就可以了*/
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();

    /*接下创建channel（信道），这是绝大多数API都能用到的。为了发送消息，你必须要声明一个消息消息队列，然后向该队列里推送消息*/
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    String message = "Hello World!";
    channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
    System.out.println(" [x] Sent '" + message + "'");
    
    /*声明一个幂等的队列（只有在该队列不存在时，才会被创建）。消息的上下文是一个
      字节数组，你可以指定它的编码。*/
    channel.close();
    connection.close();
  }
}

Remarque: Si l'espace disque est insuffisant dans le service RabbitMQ, l'opération sera une erreur. Le paramétrage est: disk_free_limit. Plus de configurations de paramètres peuvent être trouvées ici http://www.rabbitmq.com/configure.html#config-items

4. Récepteur

RabbitMQ poussera le message vers le destinataire, contrairement à l'expéditeur qui n'envoie qu'un message, ici nous écouterons le message et l'imprimerons.

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.QueueingConsumer;

public class Recv {

  private final static String QUEUE_NAME = "hello";

  public static void main(String[] argv) throws java.io.IOException, java.lang.InterruptedException {
    /*这里怎么打开连接和信道，以及声明用于接收消息的队列，这些步骤与发送端基本上是一样的*/
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();
    
    /*确保这里的队列是存在的*/
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
    
    /*这里用到了额外的类QueueingConsumer来缓存服务器将要推过来的消息。我们通知服务器向接收端推送消息，
　　　然后服务器将会向客户端异步推送消息，这里提供了一个可以回调的对象来缓存消息，直到我们做好准备来使用
　　  它，这个类就是QueueingConsumer*/
    QueueingConsumer consumer = new QueueingConsumer(channel);
    channel.basicConsume(QUEUE_NAME, true, consumer);

    while (true) {
      QueueingConsumer.Delivery delivery = consumer.nextDelivery();
      String message = new String(delivery.getBody());
      System.out.println(" [x] Received '" + message + "'");
    }
  }
}

Après avoir reçu le message, QueueingConsumer.nextDelivery () bloquera et suspendra l'opération jusqu'à ce que d'autres messages soient poussés.

Si vous devez vérifier et vérifier la file d'attente, vous devez utiliser rabbitmqctl list_queues.