RabbitMQ and PHP (1) - RabbitMQ principles and operation examples

RabbitMQ is a popular open source message queuing system developed in erlang language and fully implements AMQP (Advanced Message Queuing Protocol). The website is: http://www.rabbitmq.com/ There are tutorials and example codes (Python and Java).
7af40ad162d9f2d36b6bf89fa8ec8a136327cc4c
The AMPQ protocol is conceptually complex in order to meet various message queue requirements. First of all, rabbitMQ starts without any configuration by default. It requires the client to connect, set up the switch, etc. to work. If these basic concepts are not clarified, problems will easily arise in subsequent programming design.
1.vhosts: Virtual host.
A RabbitMQ entity can have multiple vhosts, and user and permission settings are dependent on vhosts. For general PHP applications, no user permission settings are required. Just use the "/" that exists by default. Users can use the "guest" that exists by default. A simple configuration example:
$conn_args = array(
'host' => '127.0.0.1',
'port' => '5672',
'login' => 'guest',
'password ' => 'guest',
'vhost'=>'/'
);
2. connection and channel: Connection and channel
connection refers to the physical connection, there is a connection between a client and a server; Multiple channels can be established on a connection, which can be understood as logical connections. In general applications, one channel is enough, and there is no need to create more channels. Sample code:
//Create connection and channel
$conn = new AMQPConnection($conn_args);
if (!$conn->connect()) {
die("Cannot connect to the broker!n");
}
$channel = new AMQPChannel($conn);
3.exchange and routingkey: switch and routing key
In order to distinguish different types of messages, two concepts of switch and routing are set up. For example, send a message of type A to the switch named 'C1', and send a message of type B to the switch named 'C2'. When the client connects to C1 to process queue messages, it only gets type A messages. Furthermore, if there are a lot of type A messages, further refinement of the distinction is required. For example, if a client only processes messages of type A messages for K users, routingkey is used for this purpose.
$e_name = 'e_linvo'; //Switch name
$k_route = array(0=> 'key_1', 1=> 'key_2'); //Routing key
//Create switch
$ex = new AMQPExchange ($channel);
$ex->setName($e_name);
$ex->setType(AMQP_EX_TYPE_DIRECT); //direct type
$ex->setFlags(AMQP_DURABLE); //persistence
echo " Exchange Status:".$ex->declare()."n";
for($i=0; $i  echo "Send Message:".$ex-> publish($message . date('H:i:s'), $k_route[i%2])."n";
}
As you can see from the above code, when sending a message, as long as there is a "switch", it is enough . As for whether there is a corresponding processing queue behind the switch, the sender does not need to worry about it. routingkey can be an empty string. In the example, I use two keys to send messages alternately to make it easier to understand the role of routing key below.
For switches, there are two important concepts:
A, type. There are three types: Fanout type is the simplest, this model ignores the routing key; Direct type is the most used, using a certain routing key. Under this model, if you bind 'key_1' when receiving a message, you will only receive the message of key_1; the last one is Topic, which is similar to Direct, but supports wildcard matching, such as: 'key_*', it will accept key_1 and key_2. Topic looks nice, but it may lead to imprecision, so it is recommended to use Direct.
B, persistence. Switches that are specified for persistence can only be rebuilt upon restarting, otherwise the client needs to re-declare the generation.
A particularly clear concept is needed: the persistence of the switch does not equal the persistence of the message. Only messages in the persistence queue can be persisted; if there is no queue, the message has no place to store; the message itself also has a persistence flag when it is delivered. In PHP, the default message delivered to the persistence switch is a persistent message, no need ad hoc.
4.queue: Queue
Having talked so much, let’s talk about queue. In fact, the queue is only for the receiver (consumer) and is created by the receiver based on demand. Only when the queue is created, the switch will send newly received messages to the queue. The switch will not put messages before the queue is created. In other words, all messages sent before the queue is established are discarded. The picture below is clearer than the official RabbitMQ picture - Queue is part of ReceiveMessage.
024f78f0f736afc37053e415b219ebc4b7451266
Let’s look at an example of creating a queue and receiving messages:
$e_name = 'e_linvo'; //Switch name
$q_name = 'q_linvo'; //Queue name
$k_route = ''; //Routing key
//Create connection and channel
$conn = new AMQPConnection($conn_args);
if (!$conn->connect()) {
die("Cannot connect to the broker!n");
}
$channel = new AMQPChannel($conn);
//Create a switch
$ex = new AMQPExchange($channel);
$ex->setName($e_name);
$ex->setType(AMQP_EX_TYPE_DIRECT); / /direct type
$ex->setFlags(AMQP_DURABLE); //Persistence
echo "Exchange Status:".$ex->declare()."n";
//Create queue
$q = new AMQPQueue ($channel);
$q->setName($q_name);
$q->setFlags(AMQP_DURABLE); //Persistence
//Bind the switch and queue, and specify the routing key
echo 'Queue Bind : '.$q->bind($e_name, $k_route)."n";
//Receive messages in blocking mode
echo "Message:n";
$q->consume('processMessage', AMQP_AUTOACK) ; //Automatic ACK response
$conn->disconnect();
/**
* Consumption callback function
* Processing messages
*/
function processMessage($envelope, $queue) {
var_dump($envelope->getRoutingKey);
$msg = $envelope->getBody();
echo $msg."n"; //Processing messages
}
As you can see from the above example, the switch can be created by the message sender or the message consumer .
After creating a queue (line:20), the queue needs to be bound to the switch (line:25) for the queue to work. The routingkey is also specified here. Some information says "bindingkey", which is actually the same thing. Using two nouns is easy to confuse.
There are two ways to process messages:
A, one-time. Using $q->get([...]), it will return immediately regardless of whether the message is obtained or not. Generally, this method is used to process the message queue using polling;
B, blocking. Using $q->consum( callback, [...] ) the program will enter a continuous listening state. Each time a message is received, the function specified by the callback will be called once. It will not end until a certain callback function returns FALSE.
Regarding callback, here are a few more words: PHP's call_back supports the use of arrays, for example: $c = new MyClass(); $c->counter = 100; $q->consume( array($c, 'myfunc') ) This way you can call the processing class you wrote. The parameter definition of myfunc in MyClass is the same as that of processMessage in the above example.
In the above example, using $routingkey = '' means receiving all messages. We can change it to $routingkey = 'key_1', and you can see that the only content in the result is setting routingkey to key_1.
Note: routingkey = 'key_1' and routingkey = 'key_2' are two different queues. Assumption: client1 and client2 are both connected to the queue of key_1. After a message is processed by client1, it will not be processed by client2. Routingkey = '' is another alternative. client_all is bound to ''. After all the messages are processed, there will be no messages on client1 and client2.
In terms of program design, you need to plan the name of the exchange, how to use keys to distinguish different types of tags, and insert the message sending code where the message is generated. Back-end processing can start one or more clients for each key to improve the real-time nature of message processing. How to use PHP for multi-threaded message processing will be described in the next section.
For more message models, please refer to: http://www.rabbitmq.com/tutorials/tutorial-two-python.html
b03533fa828ba61e15fc0e5f4034970a304e59b4
http://nonfu.me/p/8833.html

The above introduces RabbitMQ and PHP (1) - the principles and operation examples of RabbitMQ, including relevant content. I hope it will be helpful to friends who are interested in PHP tutorials.