eyb：RabbitMQ学习1

最新推荐文章于 2024-07-18 20:13:39 发布
最新推荐文章于 2024-07-18 20:13:39 发布
阅读量521 收藏
点赞数
分类专栏： EYB后端项目 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dengfengling999/article/details/126323166
版权

目录：

（1）MQ介绍

（2）RabbitMQ介绍

（3）RabbitMQ的安装

（4）管理界面介绍

（5）简单队列

（6）工作队列-轮询

（7）工作队列-公平

（8）发布-订阅队列

消息的中间件： 

 （1）MQ介绍

 

（2）RabbitMQ介绍

目前市面上主流的MQ：

ActiveMQ是Apache下的项目，是一个比较老的MQ了，前几年比较流行，现在不行了，因为它的性能没那么高，在小型的项目中使用，要求性能没那么高，但是在高并发的情况下，很容易出现消息的阻塞啊，错误啊，或者其他类型阻塞的情况，它的性能没那么好，我们发现现在啊大数据高并发这种情况到处可见，它就没办法在高并发大数据的情况下发挥好的性能所以现在不怎么用

Kafka：刚开始是用来做日志收集的，现在用来做消息的中间件，优点是性能比较高，缺点是对消息的可靠性没那么高，消息错误、重发、漏发等

RocketMQ：是阿里巴巴开元的消息中间件，在设计方面借鉴了Kafka，又做了改进，它具有Kafka的高性能，改进了Kafka消息错误啊可靠性的问题,虽然说开元了，但是有些功能还是不完整的

RabbitMQ:它的性能也比较不错，它也能保证消息的可靠性，它对高可用是非常厉害的，我们现在达到高可用都是搭建集群，主从，只要有任意一个节点有数据，它都能给你恢复过来，比如现在有三主三从，有一个节点磁盘里面有数据，能把整个集群的数据给你恢复过来，高可用非常高

（3）RabbitMQ的安装

以Linux环境安装

RabbitMQ是以Erlag语言编写的，要想安装需要先Erlang的环境，它两之间的版本要对应 

下载安装包：

上传到Linux：

先安装Erlang：输入命令安转：

 

输入erl：出现这个就说明Erlang就安装成功了 

 在安装rabbitMQ：输入命令：

 

安装完毕之后启动：

查看启动状态：

 

向MySql安装完之后，它有Navcat可视化工具，RabbitMQ,也有可视化的： 

可以准备一个RabbitMQ的可视化工具，是一个网页版，属于RabbitMQ的插件，插件怎么安装呢？

 安装插件：

如果不能通过IP地址访问：可能是防火墙的问题:在linux暂时关闭防火墙。

 

 

 然后就可以访问它可视化的页面

默认登录姓名密码：guest

 访问出现错误，我们现在是跨域登录，默认只能本地登录

 需要更改：配置

 

 新建一个配置：

 输入内容：

改完之后重启RubbitMQ：

 

 重新登录：就可以登录成功了

 （4）管理界面介绍

第一行是刷新

第二行是：虚拟路由，优点向Redis的虚拟的数据库 

第三行是：集群默认的是单节点

第四行：用户

这里写图片描述

这里写图片描述

Connection：连接 Channels：信道  Exchange：交换机 Queues：队列  Consumer：消费者 

 

Admin：用户 

可以在添加有个用户：

点创建的用户，添加虚拟路由： 

添加的用户没有虚拟路由

 

设置完之后，就有了 

Virtual Host：虚拟路由 

 可以在添加一个虚拟路由：

再点击添加的路由，可以添加用户：



学习五种队列 ：这里写图片描述

（5）简单队列

 

P：消息的生产者
C：消息的消费者
红色：队列

生产者将消息发送到队列，消费者从队列中获取消息。

发送消息：

 

 接收消息：

  

 生产者只要是用来发送消息，其他不进行处理，消费者去监听对应的队列，同时接收消息处理消息，消费之绑定的队列必须是同一个

创建Maven项目：选择模板：

加入依赖：

 

创建消息的生产者：

 Send：

package com.xxxx.simple.send;

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

import java.nio.charset.StandardCharsets;

/*
* 简单队列：消息生产者
*
* */
public class Send {
    //定义队列名称
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //相关配置
        factory.setHost("192.168.23.133");
        factory.setUsername("yeb");
        factory.setVirtualHost("/yeb");
        factory.setPassword("123456");
        factory.setPort(5672);


        try(
                //连接工厂创建连接
                Connection connection=factory.newConnection();
                //创建信道
                Channel channel = connection.createChannel()){

            // 绑定队列 参数第一个：队列名称 第二个：持久化 第三个:排他队列 第四个：自动删除 第五个：额外携带的参数
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            // 消息内容
            String message = "Hello World!";
            //发送消息 第一个参数是交换机，第三个：对应的参数  第四个：消息的实体
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

 消息的消费之Recv：

package com.xxxx.simple.recv;

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

import java.nio.charset.StandardCharsets;
/*
* 简单队列：消息的消费者
*
* */
public class Recv {
    //定义队列名称
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //相关配置
        factory.setHost("192.168.23.133");
        factory.setUsername("yeb");
        factory.setVirtualHost("/yeb");
        factory.setPassword("123456");
        factory.setPort(5672);

        //连接工厂创建连接
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //绑定队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println("[*] Waitint for message .To exit press CTRL+C");

        DeliverCallback deliverCallback=(consumerTag,delivery)->{
            String message=new String(delivery.getBody(),"UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };
        //监听队列消费消息
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,consumerTag ->{

        });

    }
}

启动消息的生产者：

发现队列里出现了hello消息：

启动消费者消费消息：

 启动了消费者，消费者，一直处于连接的状态，它要一直去监听这个队列，并不会去关闭，而生产者不一样，是可以关闭的

 信道是根基Connection创建的：

（6）工作队列-轮询

轮询：解决了消费能力跟不上生产能力的问题 

现在有个问题，如果生产者每秒能生产100条消息，消费之能力有限，每秒只能收50条，每秒有50条消息在这里堆积，理论上消息队列是无限大的，但是它是基于你的内存和磁盘，当经过时间非常久之后，也会把你的磁盘撑破的RubbitMQ就没办法用了，这是它的一个缺点我们消费者的消费能力有高有低，不能匹配生产者的能力，这时候该怎么办呢？  加消费者，这就讲到工作队列

工作队列分为两种模式：一种是轮询 一种是公平

轮询：你一条我一条

公平：这个公平版不是所说的你一个我一个的公平

消息发送者：Send：

package com.xxxx.work.rr.send;

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

import java.nio.charset.StandardCharsets;

/*
* 工作队列（轮询）：消息的生产者
*
* */
public class Send {
    //定义队列名称
    private final static String QUEUE_NAME = "work_rr";

    public static void main(String[] argv) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //相关配置
        factory.setHost("192.168.23.133");
        factory.setUsername("yeb");
        factory.setVirtualHost("/yeb");
        factory.setPassword("123456");
        factory.setPort(5672);


        try(
                //连接工厂创建连接
                Connection connection=factory.newConnection();
                //创建信道
                Channel channel = connection.createChannel()){

            // 绑定队列 参数第一个：队列名称 第二个：持久化 第三个:排他队列 第四个：自动删除 第五个：额外携带的参数
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);

            //模拟生产者能生产很多消息
            for (int i=0; i<20;i++){
                // 消息内容
                String message = "Hello World!"+i;
                //发送消息 第一个参数是交换机，第三个：对应的参数  第四个：消息的实体
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
                System.out.println(" [x] Sent '" + message + "'"+i);
            }


        }
    }
}

创建两个消费者：

 Recv01：

package com.xxxx.work.rr.recv;

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


/*
* 工作队列（轮询）：消息的消费者
*
* */
public class Recv01 {
    //定义队列名称
    private final static String QUEUE_NAME = "work_rr";

    public static void main(String[] argv) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //相关配置
        factory.setHost("192.168.23.129");
        factory.setUsername("yeb");
        factory.setVirtualHost("/yeb");
        factory.setPassword("123456");
        factory.setPort(5672);

        //连接工厂创建连接
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //绑定队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        System.out.println("[*] Waitint for message .To exit press CTRL+C");

        DeliverCallback deliverCallback=(consumerTag, delivery) -> {
            //睡2秒 模拟消费耗时
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String message=new String(delivery.getBody(),"UTF-8");
            System.out.println(" [x] Received '" + message + "'");
            //手动确认 第二个参数：是否确认多条
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        };
        //监听队列消费消息  第二个参数：消息自动回值告诉生产者收到消息
        channel.basicConsume(QUEUE_NAME,false,deliverCallback,consumerTag -> {
        });

    }
}

 Recv02:

package com.xxxx.work.rr.recv;

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


/*
* 工作队列（轮询）：消息的消费者
*
* */
public class Recv02 {
    //定义队列名称
    private final static String QUEUE_NAME = "work_rr";

    public static void main(String[] argv) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //相关配置
        factory.setHost("192.168.23.129");
        factory.setUsername("yeb");
        factory.setVirtualHost("/yeb");
        factory.setPassword("123456");
        factory.setPort(5672);

        //连接工厂创建连接
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //绑定队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        System.out.println("[*] Waitint for message .To exit press CTRL+C");

        DeliverCallback deliverCallback=(consumerTag, delivery) -> {
            //睡2秒 模拟消费耗时
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String message=new String(delivery.getBody(),"UTF-8");
            System.out.println(" [x] Received '" + message + "'");
            //手动确认 第二个参数：是否确认多条
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        };
        //监听队列消费消息  第二个参数：消息自动回值告诉生产者收到消息
        channel.basicConsume(QUEUE_NAME,false,deliverCallback,consumerTag -> {
        });

    }
}

启动消费之Recv01、Recv02:

因为两个消费者，创建了2个工厂，所有有两个连接

每个连接创建一个信道： 2个信道

 队列：

启动消息发送者发送消息：

 

消费者01：接收偶数

 

消费者02：接收基数

 

 通过轮询，主要为了解决生产者的生产能力远远大于消费者的能力的时候，我们给它加多几个消费者，这就是轮询模式

（7）工作队列-公平

公平：解决了消费能力高低的问题： 

 

工作队列轮询的优点，解决了简单队列的缺点，当我们的生产者生产能力远远大于消费者消费能力的时候，我给你加消费者，然后让消费者的消费能力能够大于等于生产者的生产能力，这样可以减少多余的消息堆积在消息队列里面，它也有缺点

 

比如说发送20条消息，如果使用轮询的话，没人消费一条分配，每个消费者消费10条，他们的消费能力不同 C1 1秒消费一条，C2 2秒消费一条  消费完10条，这样C1用10秒，C2用20秒

有2个缺点：C1消费完10条之后要等C2，C1消费完之后要在这里等，资源就空到这里了，造成浪费，整体的消费时间也是比较长的，那么C1消费的快能不能帮助C2消费呢，C1帮C2没消费完的也进行消费，那么就用到公平模式，那么就用到公平模式，公平并不是生活中的一个一半，更意味更大的是能力越强，责任越大，

加啥上下面代码：

 发送者：

package com.xxxx.work.fair.send;

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

import java.nio.charset.StandardCharsets;

/*
* 工作队列（公平）：消息的生产者
*
* */
public class Send {
    //定义队列名称
    private final static String QUEUE_NAME = "work_fair";

    public static void main(String[] argv) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //相关配置
        factory.setHost("192.168.23.129");
        factory.setUsername("yeb");
        factory.setVirtualHost("/yeb");
        factory.setPassword("123456");
        factory.setPort(5672);


        try(
                //连接工厂创建连接
                Connection connection=factory.newConnection();
                //创建信道
                Channel channel = connection.createChannel()){

            // 绑定队列 参数第一个：队列名称 第二个：持久化 第三个:排他队列 第四个：自动删除 第五个：额外携带的参数
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);

            //模拟生产者能生产很多消息
            for (int i=0; i<20;i++){
                // 消息内容
                String message = "Hello World!"+i;
                //发送消息 第一个参数是交换机，第三个：对应的参数  第四个：消息的实体
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
                System.out.println(" [x] Sent '" + message + "'"+i);
            }


        }
    }
}

消费者上面加入：

 

 消费者1设置1秒消费一条消息：

package com.xxxx.work.fair.recv;

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


/*
* 工作队列（公平）：消息的消费者
*
* */
public class Recv01 {
    //定义队列名称
    private final static String QUEUE_NAME = "work_fair";

    public static void main(String[] argv) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //相关配置
        factory.setHost("192.168.23.129");
        factory.setUsername("yeb");
        factory.setVirtualHost("/yeb");
        factory.setPassword("123456");
        factory.setPort(5672);

        //连接工厂创建连接
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //绑定队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        System.out.println("[*] Waitint for message .To exit press CTRL+C");

        int prefetchCount=1;
        //限制消费者每次只能接收一条消息，处理完才能接收下一条消息
        channel.basicQos(prefetchCount);

        DeliverCallback deliverCallback=(consumerTag, delivery) -> {
            //睡2秒 模拟消费耗时
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String message=new String(delivery.getBody(),"UTF-8");
            System.out.println(" [x] Received '" + message + "'");
            //手动确认 第二个参数：是否确认多条
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        };
        //监听队列消费消息  第二个参数：消息自动回值告诉生产者收到消息
        channel.basicConsume(QUEUE_NAME,false,deliverCallback,consumerTag -> {
        });

    }
}

 消费者1设置2秒消费一条消息 

package com.xxxx.work.fair.recv;

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


/*
* 工作队列（公平）：消息的消费者
*
* */
public class Recv02 {
    //定义队列名称
    private final static String QUEUE_NAME = "work_fair";

    public static void main(String[] argv) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //相关配置
        factory.setHost("192.168.23.129");
        factory.setUsername("yeb");
        factory.setVirtualHost("/yeb");
        factory.setPassword("123456");
        factory.setPort(5672);

        //连接工厂创建连接
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //绑定队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        System.out.println("[*] Waitint for message .To exit press CTRL+C");

        int prefetchCount=1;
        //限制消费者每次只能接收一条消息，处理完才能接收下一条消息
        channel.basicQos(prefetchCount);

        DeliverCallback deliverCallback=(consumerTag, delivery) -> {
            //睡2秒 模拟消费耗时
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String message=new String(delivery.getBody(),"UTF-8");
            System.out.println(" [x] Received '" + message + "'");
            //手动确认 第二个参数：是否确认多条
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        };
        //监听队列消费消息  第二个参数：消息自动回值告诉生产者收到消息
        channel.basicConsume(QUEUE_NAME,false,deliverCallback,consumerTag -> {
        });

    }
}

启动2个消费者：

 

启动消息发送者：

 

消费者1：消费快，多消费了消息

 

消费者2：消费慢，少消费消息

 

 公平模式，解决了不同消费者，不同的消费能力的差别的问题，做到能者多劳，能力强的多消费消息，能力落的少消费消息，没有资源浪费了解决了上面轮询消费者能力不同的问题，C1不会空在哪里，造成资源的浪费，让它一直干活，不会资源的浪费，第二整体的消费时间会变短。

（8）发布-订阅队列

公平队列，不能满足我们的需求，公平模式消费者接收的消息不能重复，如果我们有一个需求，我现在想要发送一条消息，然后被所有的消费者都能接收到，用我们上面所学的那两队列种模式无法实现，他们不能接收重复的消息，下面就用到第三种模式：

多了一个东西叫：交换机 

交换机：交换机对每一个不同的虚拟路由，默认给了7个交换机

之前消息发送者直接把消息发送给队列，现在是生产者把消息，发送给交换机，交换机绑定不同的队列，然后把消息发送给队列，每个队列后面对应着一个消费者，他们去监听不同的队列，然后达到不同的消费者接收同一条消息的目的

 

 消息订阅：广播类型：

 消息创建者：

package com.xxxx.exchanges.send;

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

import java.nio.charset.StandardCharsets;

/*
* 发布/订阅队列：消息的生产者
*
* */
public class Send {
    //定义交换机名称
    private final static String EXCHANGE_NAME = "work_fanout";

    public static void main(String[] argv) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //相关配置
        factory.setHost("192.168.23.129");
        factory.setUsername("yeb");
        factory.setVirtualHost("/yeb");
        factory.setPassword("123456");
        factory.setPort(5672);


        try(
                //连接工厂创建连接
                Connection connection=factory.newConnection();
                //创建信道
                Channel channel = connection.createChannel()){

            //绑定交换机
            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);

                // 消息内容
                String message = "Hello World!";
                //发送消息 第一个参数是交换机，第三个：对应的参数  第四个：消息的实体
                channel.basicPublish(EXCHANGE_NAME,"", null, message.getBytes(StandardCharsets.UTF_8));
                System.out.println(" [x] Sent '" + message + "'");


        }
    }
}

消费者：

package com.xxxx.exchanges.recv;

import com.rabbitmq.client.*;


/*
* 发布/订阅队列：消息的消费者
*
* */
public class Recv01 {
    //定义队列名称
    private final static String EXCHANGE_NAME = "work_fanout";

    public static void main(String[] argv) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //相关配置
        factory.setHost("192.168.23.129");
        factory.setUsername("yeb");
        factory.setVirtualHost("/yeb");
        factory.setPassword("123456");
        factory.setPort(5672);

        //连接工厂创建连接
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //绑定交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        //获取队列（排他队列）
        String queueName=channel.queueDeclare().getQueue();
        //绑定队列和交换机、
        channel.queueBind(queueName,EXCHANGE_NAME,"");

        System.out.println("[*] Waitint for message .To exit press CTRL+C");

        DeliverCallback deliverCallback=(consumerTag, delivery) -> {

            String message=new String(delivery.getBody(),"UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };
        //监听队列消费消息  第二个参数：消息自动回值告诉生产者收到消息
        channel.basicConsume(queueName,true,deliverCallback,consumerTag -> {
        });

    }
}


package com.xxxx.exchanges.recv;

import com.rabbitmq.client.*;


/*
* 发布/订阅队列：消息的消费者
*
* */
public class Recv02 {
    //定义队列名称
    private final static String EXCHANGE_NAME = "work_fanout";

    public static void main(String[] argv) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //相关配置
        factory.setHost("192.168.23.129");
        factory.setUsername("yeb");
        factory.setVirtualHost("/yeb");
        factory.setPassword("123456");
        factory.setPort(5672);

        //连接工厂创建连接
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //绑定交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        //获取队列（排他队列）
        String queueName=channel.queueDeclare().getQueue();
        //绑定队列和交换机
        channel.queueBind(queueName,EXCHANGE_NAME,"");

        System.out.println("[*] Waitint for message .To exit press CTRL+C");

        DeliverCallback deliverCallback=(consumerTag, delivery) -> {

            String message=new String(delivery.getBody(),"UTF-8");
            System.out.println(" [x] Received '" + message + "'");

        };
        //监听队列消费消息  第二个参数：消息自动回值告诉生产者收到消息
        channel.basicConsume(queueName,true,deliverCallback,consumerTag -> {
        });

    }
}

运行消费01、02：

发现多了一个交换机：最下面

 

 点进去：多了2个队列，对应的就是消费者。

队列：多了2个队队列，排他队列Excl

 

 启动消费者：发送一个HelloWord

消费者01：接收到消息

消费者02：也接收到消息

 

 

喵俺第一专栏
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
EYB:EatYourBooks.com - 从本网站分析烹饪网络的食谱
06-28
安永EatYourBooks.com - 从本网站分析烹饪网络的食谱此代码库包含使用模板化爬虫抓取 EatYouBooks.com 的代码，将食谱、食谱和美食相关信息转储到 mongodb 数据库中。 它还使用 NLTK 和 NetworkX 使用 NLP 技术处理...
EvolutionActa.zl6kjznugr.gaA3EyB
03-18
【标题】"EvolutionActa.zl6kjznugr.gaA3EyB"看起来像是一个文件或压缩包的名字，但没有提供足够的上下文来直接解释它的具体含义。通常，这种格式可能是某种加密或混淆的...对于深入学习，建议查看具体的代码内容。
eyb：Vue学习1
dengfengling999的博客
08-21 304
比如说百度搜索引擎，每一个节日都有一个对应节日的css样式，这个需要重复去编写的东西，就增加了工作量，为了解决这个问题，衍生出了css预处理器。VueModel可以做数据双向绑定，当data里面有数据变化的时候呢，视图页面可以立刻变更数据，并且没有感知到DOM操作。vue-cli：是vue官方的脚手架，帮助我们快速创建项目，附带着一些常用的依赖，像Maven一样。静态资源放在静态资源服务器上面，数据请求，通过ajax请求，从后台拿取数据然后再在前端页面展示。new Vue{}：相当于：ViewModel。
eyb：Vue学习3
dengfengling999的博客
08-24 351
之前有嵌套组件，叫子组件，大组件套小组件，组件不能一直嵌套下去，可能会遇到一些页面跳转的需求，就引出来了路由，除了页面跳转的需求以外，还有就是一个大页面，里面是路由的内容，通过点一下某个超链接，路由里面的内容发生变化，但是大页面还是一样的。先做一个功能，判断是否登录，登录完之后，再次到登录页，它会自动跳到首页，当退出之后，不存在登录的状态，去任何页面，都会跳到登录页面，在Java中是使用拦截器，那么在Vue里面没有拦截器，需要使用路由钩子函数。加一点表单验证 ：首先加：rules=“rules”
eyb：Vue学习2
dengfengling999的博客
08-23 222
通过vue-cli创建的项目，只有一个index.html，剩下的只是组件（Webpack里面的模块），没有办法去做页面的跳转，比如说经常做的功能登录成功，跳转到个人中心，涉及到页面跳转。App.vue组件可以嵌套组件，这只是组件的嵌套，并没有办法页面的跳转，也不能一直无限的嵌套下去，一定有页面跳转的需求，这时候vue-router是去实现页面跳转的功能。集成打包上线：vue前端用的是原生的js ES6，ES6有许多浏览器不支持，需要打包成ES5，vue-cli集成了打包上线，把webpack集成上去了。
eyb：Redis学习（4）
dengfengling999的博客
08-09 348
存入的数据：发现存入的数据看不懂。删除没用的目录：看起来简洁一点。创建RedisConfig。：需要另外引入连接池依赖。使用自定义序列化模板。
eyb：Redis学习（3）
dengfengling999的博客
08-09 275
读写分离相对于单独的服务器而言，有它的优点，它分散了读的压力，提高了可用性，当一个从服务器挂机的时候呢，主服务器和其他从服务器依赖存在，依赖可以提供服务，但是它只是提供了一定的可用性，刚才我们只是说的是从服务器挂机，但是我们主服务器挂机怎么办呢？比如说有3个哨兵，他们去监控主从复用的环境，发现主服务器挂掉之后呢，他们从新选取下面的从服务器一个变成一个新的主服务器，让这个新的主服务器去提供读写能力，当你之前的主服务器，重新启动后它会变成从服务器。修改目录：dir /opt//redis/data。...
eyb：Redis学习（2）
dengfengling999的博客
08-08 151
通过Java代码操作Redis，通过客户端使用命令比较少创建springbooot项目，选择依赖：redis依赖默认继承的是Lettuce客户端，我们先学习Jedis客户端区别：Jedis是直连连接的，直接连接到Redis服务器，在多个线程上是共享一个Jedis实例的，所以这个时候线程是不安全的，所以你想在多线程场景下使用Jedis需要使用连接池，每个线程都会使用自己的Jedis实例， 当你的连接数增多的时候呢，会消耗比较多的物理资源 Jedis并发不安全。...
eyb：FastDFS的学习
dengfengling999的博客
08-20 326
base_path:是Fdfs的Tracker启动之后，使用的根目录，它要去存储一些信息，它存的信息是卷里面storage 的存储节点 包括卷1，卷2，卷3 每个卷下面有哪些storage 每个storage的IP和对口，它都要存储一下，因为它作为中转掉读的操作，客户端发起写操作的时候，tracker就会调度找到哪一个节点给我们去写操作，然后返回IP和端口，所以它需要把卷下面的存储节点存储一下。
eyb：Redis的学习（1）
dengfengling999的博客
08-07 174
有了Redis可以把验证码放到redis里面，登录的时候输入验证码，和我们redis中取的验证码进行比较，成功了让你删掉，失败了去做其他操作，redis自带失效时间，设置的时候设置3分钟失效，不用像原来写定时任务，判断验证码是否失效，到时见自动失效，来减少代码的编写量，失效时间是一个重要的功能。：key是student 获取0-2的数据，2是不存在的只能获取到0-1的数据。redis-cli -h :表示连接远程的IP地址-指定访问的IP地址。存入的数据是乱排序的，获取的数据不是我们存储的顺序。...
eyb：RubbitMQ学习2
dengfengling999的博客
08-18 147
生产者发送消息给交换机，然后由交换机发给绑定他的一个队列，然后被不同的队列后面的消费者所接收，这样我们发送一条消息，消费者接收到的都是一条消息，那么现在又有一个需求，比如会员制，比如说：微信公众号，只有开通会员的才能看的文章，可以推给会员用户，没开会员的职能看一些普通文章。发消息，这边等确认，确认的同时也可以发消息，这个队列确认了之后返回，生产者有一个回调的方法，能够收到你返回的确认消息，进行响应的处理，所以你在等确认的同时，也可以发消息，这就叫异步。确认模式最大的好处是异步的，事务是同步的会降低性能。..
创业素质评估1.pptx
10-13
该课程包括四部分：GYB（产生你的企业想法）、SYB（创办你的企业）、IYB（改善你的企业）和EYB（扩大你的企业）。本篇主要关注SYB部分，这是整个课程的基础。 在创业过程中，首要的一步是自我评估，确定你是否适合...
angular-debounce-input:用StackBlitz创建:high_voltage:
03-10
1. **Angular Directives**：Angular提供了自定义指令的能力，我们可以创建一个自定义指令来实现防抖功能，监听用户的输入事件，并确保只有在用户停止输入一段时间后才执行相应的操作。 2. **RxJS**：Angular通常与...
1.3 ArmcoreEVB(硬件) ArmCore-AX0核心板引脚定义1118.pdf-电路图
04-27
全志方案在消费类电子占有很大的市场，随着产品的不断升级优化，全志方案不仅仅在安卓平板，视频监控、广告应用等领域崭露头角，本人收集些有关全志方案的开发资料，希望对正在使用全志方案的网友有所帮助。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 807
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 874
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 999
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 814
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
接口防刷！利用redisson快速实现自定义限流注解
最新发布
架构师小吴的博客
07-18 803
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

喵俺第一专栏

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值