RabbitMQ（1）

最新推荐文章于 2024-06-27 22:54:54 发布

qq_37211608

最新推荐文章于 2024-06-27 22:54:54 发布

阅读量143

点赞数

分类专栏： RabbitMQ

RabbitMQ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

下载安装rabbitMQ配置环境变量

先安装：Erlang下载地址：http://www.erlang.org/downloads

再安装：RabbitMQ下载地址：http://www.rabbitmq.com/install-windows.html

配置系统环境变量

最后进行path的配置如下图（;%ERLANG_HOME%\bin;%RABBITMQ_SERVER%\sbin;注意是追加）

找到安装rabbitMQ的路径，然后切换到sbin的文件夹

输入rabbitmq-plugins enable rabbitmq_management命令来启动监控管理器

然后在浏览器输入http:localhost:15672 用户名和密码默认都为guest。

RabbitMQ常用的命令

启动监控管理器：rabbitmq-plugins enable rabbitmq_management

关闭监控管理器：rabbitmq-plugins disable rabbitmq_management

启动rabbitmq：rabbitmq-service start

关闭rabbitmq：rabbitmq-service stop

查看所有的队列：rabbitmqctl list_queues

清除所有的队列：rabbitmqctl reset

关闭应用：rabbitmqctl stop_app

启动应用：rabbitmqctl start_app

用户和权限设置（后面用处）

添加用户：rabbitmqctl add_user username password

分配角色：rabbitmqctl set_user_tags username administrator

新增虚拟主机：rabbitmqctl add_vhost vhost_name

将新虚拟主机授权给新用户：rabbitmqctl set_permissions -p vhost_name username '.*' '.*' '.*'

角色说明

none 最小权限角色

management 管理员角色

policymaker 决策者

monitoring 监控

administrator 超级管理员

简单的实例：

<dependency>

    <groupId>com.rabbitmq</groupId>

    <artifactId>amqp-client</artifactId>

    <version>3.6.5</version>

</dependency>

package common.rabbitMQ;

import java.io.IOException;

import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

/**

 * 消息生产者

 */

public class Producer {

    public final static String QUEUE_NAME="rabbitMQ.test";

    public static void main(String[] args) throws IOException, TimeoutException {

        //创建连接工厂

        ConnectionFactory factory = new ConnectionFactory();

        //设置RabbitMQ相关信息

        factory.setHost("localhost");

      //factory.setUsername("lp");

      //factory.setPassword("");

     // factory.setPort(2088);

        //创建一个新的连接

        Connection connection = factory.newConnection();

        //创建一个通道

        Channel channel = connection.createChannel();

        //  声明一个队列        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        String message = "Hello RabbitMQ";

        //发送消息到队列中

        channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));

        System.out.println("Producer Send +'" + message + "'");

        //关闭通道和连接

        channel.close();

        connection.close();

    }

}

package common.rabbitMQ;



import java.io.IOException;

import java.util.concurrent.TimeoutException;



import com.rabbitmq.client.AMQP;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

import com.rabbitmq.client.Consumer;

import com.rabbitmq.client.DefaultConsumer;

import com.rabbitmq.client.Envelope;

/**

 * 消息消费者

 */

public class Customer {

    private final static String QUEUE_NAME = "rabbitMQ.test";



    public static void main(String[] args) throws IOException, TimeoutException {

        // 创建连接工厂

        ConnectionFactory factory = new ConnectionFactory();

        // 设置RabbitMQ地址

        factory.setHost("localhost");

        // 创建一个新的连接

        Connection connection = factory.newConnection();

        // 创建一个通道

        Channel channel = connection.createChannel();

        // 声明要关注的队列

        channel.queueDeclare(QUEUE_NAME, false, false, true, null);

        System.out.println("消费者等待接收'messages'");

        // DefaultConsumer类实现了Consumer接口，通过传入一个频道，

        // 告诉服务器我们需要那个频道的消息，如果频道中有消息，就会执行回调函数handleDelivery

        Consumer 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");

                System.out.println("Customer Received '" + message + "'");

            }

        };

        // 自动回复队列应答 -- RabbitMQ中的消息确认机制

        channel.basicConsume(QUEUE_NAME, true, consumer);

    }
}

实现任务分发：

package common.rabbitMQ;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

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

public class NewTask {
    private static final String TASK_QUEUE_NAME="task_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection=factory.newConnection();
        Channel channel=connection.createChannel();
   channel.queueDeclare(TASK_QUEUE_NAME,true,false,false,null);
        //分发信息
        for (int i=9;i<10;i++){
            String message="Hello RabbitMQ"+i;
            channel.basicPublish("",TASK_QUEUE_NAME,
                    MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());
            System.out.println("NewTask send '"+message+"'");
        }
        channel.close();
        connection.close();
    }
}

package common.rabbitMQ;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

public class Work1 {
    private static final String TASK_QUEUE_NAME = "task_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        final ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        final Channel channel = connection.createChannel();

        channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
        System.out.println("Worker1  Waiting for messages");

        //每次从队列获取的数量
        channel.basicQos(1);

        final Consumer 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");
                System.out.println("Worker1  Received '" + message + "'");
                try {
                    //throw  new Exception();
                    doWork(message);
                }catch (Exception e){
                    channel.abort();
                }finally {
                    System.out.println("Worker1 Done");
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck=false;
        //消息消费完成确认
        channel.basicConsume(TASK_QUEUE_NAME, autoAck, consumer);
    }
    private static void doWork(String task) {
        try {
            Thread.sleep(1000); // 暂停1秒钟
        } catch (InterruptedException _ignored) {
            Thread.currentThread().interrupt();
        }
    }
}

package common.rabbitMQ;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

public class Work2 {
    private static final String TASK_QUEUE_NAME = "task_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        final ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        final Channel channel = connection.createChannel();

        channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
        System.out.println("Worker2  Waiting for messages");

        //每次从队列获取的数量
        channel.basicQos(1);

        final Consumer 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");
                System.out.println("Worker2  Received '" + message + "'");
                try {
                    //throw  new Exception();
                    doWork(message);
                }catch (Exception e){
                    channel.abort();
                }finally {
                    System.out.println("Worker2 Done");
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck=false;
        //消息消费完成确认
        channel.basicConsume(TASK_QUEUE_NAME, autoAck, consumer);
    }
    private static void doWork(String task) {
        try {
            Thread.sleep(1000); // 暂停1秒钟
        } catch (InterruptedException _ignored) {
            Thread.currentThread().interrupt();
        }
    }
}

输出结果：

NewTask send 'Hello RabbitMQ0'
NewTask send 'Hello RabbitMQ1'
NewTask send 'Hello RabbitMQ2'
NewTask send 'Hello RabbitMQ3'
NewTask send 'Hello RabbitMQ4'
NewTask send 'Hello RabbitMQ5'
NewTask send 'Hello RabbitMQ6'
NewTask send 'Hello RabbitMQ7'
NewTask send 'Hello RabbitMQ8'
NewTask send 'Hello RabbitMQ9'

Worker1  Waiting for messages
Worker1  Received 'Hello RabbitMQ1'
Worker1 Done
Worker1  Received 'Hello RabbitMQ3'
Worker1 Done
Worker1  Received 'Hello RabbitMQ4'
Worker1 Done
Worker1  Received 'Hello RabbitMQ7'
Worker1 Done
Worker1  Received 'Hello RabbitMQ8'
Worker1 Done

Worker2  Waiting for messages
Worker2  Received 'Hello RabbitMQ0'
Worker2 Done
Worker2  Received 'Hello RabbitMQ2'
Worker2 Done
Worker2  Received 'Hello RabbitMQ5'
Worker2 Done
Worker2  Received 'Hello RabbitMQ6'
Worker2 Done
Worker2  Received 'Hello RabbitMQ9'
Worker2 Done