RabbitMQ Java搭建实战——简单模式

首先添加maven依赖

<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.6.0</version>
</dependency>

编写消息生产者
编写消息生产者ProducerHelloWord

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

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

public class ProducerHelloWord {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置参数
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("wujian");
        connectionFactory.setPassword("wujian");
        connectionFactory.setVirtualHost("/itcast");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建Channel
        Channel channel = connection.createChannel();
        /** public com.rabbitmq.client.AMQP.Queue.DeclareOk queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
         queue  队列的名称
         durable 是否持久化，当mq重启之后还在
         exclusive 是否独占，只有一个消费者监听这个队列
         当connection 关闭的时候删除这个队列
         autoDelete  是否自动删除，没有消费者的时候删除
         arguments   参数
         }*/
        //创建队列
        channel.queueDeclare("hello_word",true,false,false,null);
        // 发送消息
        String messages="我是发送的啊";
        /**public void basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body) throws IOException {
         exchange 交换机名称，简单模式下的交换机会默认使用 ""
         routingKey  路由名称
         props  配置信息
         body   消息体
         */
        channel.basicPublish("","hello_word",null,messages.getBytes());

        channel.close();
        connection.close();
    }
}

在执行上述的消息发送之后；可以登录rabbitMQ的管理控制台，可以发现队列和其消息：


编写消费者

import com.rabbitmq.client.*;

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

public class MyConsumerMain {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 设置参数 虚拟机，用户名，密码....
        // 家里
        factory.setHost("127.0.0.1");
        // 公司
        factory.setVirtualHost("/itcast");
        factory.setUsername("wujian");
        factory.setPassword("wujian");
        factory.setPort(5672);
        //设置连接
        Connection connection = factory.newConnection();
        //创建Channel
        /** public com.rabbitmq.client.AMQP.Queue.DeclareOk queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
         queue  队列的名称
         durable 是否持久化，当mq重启之后还在
         exclusive 是否独占，只有一个消费者监听这个队列
         当connection 关闭的时候删除这个队列
         autoDelete  是否自动删除，没有消费者的时候删除
         arguments   参数
         }*/
        Channel channel =connection.createChannel();
        channel.queueDeclare("hello_word",true,false,false,null);
        /** String basicConsume(String queue, boolean autoAck, Consumer callback)
         * queue 队列名称
         * autoAck 是否自动确认 消费者收到消息之后自动给生产者说一声收到了
         * callback 回调函数
         * */
        DefaultConsumer consumer = new DefaultConsumer(channel){
            // 这个是一个回调方法，当收到消息之后会自动执行该方法
            /****
             * consumerTag 标识 编号
             * envelope 获取一些信息例如交换机 key，路由
             * properties 配置信息
             * body 数据
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                System.out.println("标识:"+consumerTag);
                System.out.println("一些信息"+envelope.getExchange()+",这个是路由，其实是队列名称"+envelope.getRoutingKey()+",消息序号"+envelope.getDeliveryTag());
                System.out.println("配置信息:"+properties);
                System.out.println("消息"+new String(body));
            }
        };
        channel.basicConsume("hello_word",true,consumer);
//        channel.close();
//        connection.close();
    }
}

上述的入门案例中中其实使用的是如下的简单模式：

在上图的模型中，有以下概念：

P：生产者，也就是要发送消息的程序
C：消费者：消息的接受者，会一直等待消息到来。
queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。