The optimization and adjustment skills of the Rabbitmq framework in the Java library
Rabbitmq is a powerful message middleware. It provides an efficient message transmission mechanism and is widely used in distributed systems and asynchronous communication scenarios.However, when using the Rabbitmq framework, we also need to pay attention to its optimization and tuning skills to ensure its performance and stability.
This article will introduce some techniques to optimize and adjust the Rabbitmq framework in the Java library.
1. Reuse of Connection and Channel
In Rabbitmq, Connection is a connection with the message queue server, and Channel is a communication channel created in Connection.Creating Connection and Channel are relatively expensive operations, so they can be used as a optimization technique.You can avoid frequent creation and closure of connection by using Connection and Channel as class members and reuse when needed.
Example code:
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
public class RabbitMQUtils {
private static final String RABBITMQ_HOST = "localhost";
private static final int RABBITMQ_PORT = 5672;
private static final String RABBITMQ_USERNAME = "guest";
private static final String RABBITMQ_PASSWORD = "guest";
private static Connection connection;
private static Channel channel;
public static Connection getConnection() throws IOException, TimeoutException {
if (connection == null) {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost(RABBITMQ_HOST);
factory.setPort(RABBITMQ_PORT);
factory.setUsername(RABBITMQ_USERNAME);
factory.setPassword(RABBITMQ_PASSWORD);
connection = factory.newConnection();
}
return connection;
}
public static Channel getChannel() throws IOException, TimeoutException {
if (channel == null) {
channel = getConnection().createChannel();
}
return channel;
}
// Turn off the connection and channel
public static void close() throws IOException, TimeoutException {
if (channel != null) {
channel.close();
}
if (connection != null) {
connection.close();
}
}
}
Where you need to use Rabbitmq, you can obtain a reusable Channel object through the `RabbitMQUTILS.GetChannel ()` ``) and sending and receiving messages.
2. Set prepaid counting
The prefetch count in Rabbitmq is used to adjust the rate of consumer obtaining messages from the queue.By default, RabbitMQ will send as many messages as possible to consumers.However, if consumers are slow to process messages, the message queue accumulation may cause system performance.
You can set the pre -count count by calling the method by calling the `BASICQOS (int prefetchcount) method.The prepaid counting can control the number of messages taken from the message queue, reduce the load of consumers, and reduce the accumulation of the message queue.
Example code:
import com.rabbitmq.client.*;
public class RabbitMQConsumer {
private static final String QUEUE_NAME = "my_queue";
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory factory = new ConnectionFactory();
// Set Rabbitmq connection parameters
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
// Set the pre -collection count as 1, only one message is obtained for each time
channel.basicQos(1);
DefaultConsumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
String message = new String(body, "UTF-8");
// Treat the message ...
System.out.println("Received message: " + message);
// Manually confirm the message processing complete
channel.basicAck(envelope.getDeliveryTag(), false);
}
};
// Start consumption message
channel.basicConsume(QUEUE_NAME, false, consumer);
}
}
In the above example, set the pre -counting count of 1 through `Channel.basicqos (1)`, and only get one message each time for processing.
3. The news durable
By default, Rabbitmq stores the message in memory. If the server restarts or is abnormally closed, the message will be lost.In order to ensure the persistence of the message, the Delivery Mode of the message can be set to 2, and the queues and messages can be set to last.
Example code:
import com.rabbitmq.client.*;
public class RabbitMQProducer {
private static final String QUEUE_NAME = "my_queue";
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory factory = new ConnectionFactory();
// Set Rabbitmq connection parameters
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
// Declaration queue as durable
channel.queueDeclare(QUEUE_NAME, true, false, false, null);
String message = "Hello RabbitMQ!";
// Send the message and set the message to last
channel.basicPublish("", QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes("UTF-8"));
System.out.println("Sent message: " + message);
channel.close();
connection.close();
}
}
In the above example, through the `Channel.QueuedeClare (queue_name, true, false, false, null)` `set the queue to endure, through the` Channel.BasicPublish (", Queue_name, MessageProper ties.persistent_Text_plain, Message.getBytes ("UTF-8 "))` Set the message to persistent.
Through the above optimization and tuning skills, the performance and stability of the Rabbitmq framework in the Java class library can be improved, and the message processing scenarios such as high and large data volumes are better cope.
