七仔 ^ v ^

RabbitMQ 学习笔记

RabbitMQ (狂神说学习笔记)

1、消息队列预科（了解一下）

消息队列协议

所谓协议是指

计算机底层操作系统和应用程序通讯时共同遵守的一组约定，只有遵循共同的约定和规范，系统和底层操作系统之间才能相互交流
和一般的网络应用程序的不同它主要负责数据的接受和传递，所以性能比较的高
协议对数据格式和计算机之间交换数据都必须严格遵守规范

网络协议的三要素

语法：语法是用户数据与控制信息的结构与格式，以及数据出现的顺序
语义：语义是解释控制信息每个部分的意义，它规定了需要发出何种控制信息，以及完成的动作与做出什么样的响应
时序：时序是对事件发生顺序的详细说明

面试题: 为什么消息中间件不直接使用 http协议（先过个眼熟）

为什么，因为不合适，没有最好的，最有最合适的。

因为 http请求报文头和响应报文头是比较复杂的，包含了Cookie，数据的加密解密，窗台吗，响应码等附加的功能，但是对于一个消息而言，我们并不需要这么复杂，也没有这个必要性，它其实就是负责数据传递，存储，分发就行，一定要追求的是高性能。尽量简洁，快速
大部分情况下 http大部分都是短链接，在实际的交互过程中，一个请求到响应都很有可能会中断，中断以后就不会执行持久化，就会造成请求的丢失。这样就不利于消息中间件的业务场景，因为消息中间件可能是一个长期的获取信息的过程，出现问题和故障要对数据或消息执行持久化等，目的是为了保证消息和数据的高可靠和稳健的运行

总结来说：http协议不是专业做消息中间件的，有很多东西不符合消息中间件所需要的。消息中间件进行的是消息和数据的传输，而http协议则是进行一些网络请求，里面包含着一些消息中间件不需要的东西，比如Cookie，请求响应等。

常用的一些协议

1、AMQP协议

AMQP：（全称：Advanced Message Queuing Protocol）是高级消息队列协议。由摩根大通集团联合其他公司共同设计。是一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。Erlang中的实现由 RabbitMQ等

特性：

分布式事务支持
消息的持久化支持
高性能和高可靠的消息处理优势

2、MQTT协议

MQTT协议（Message Queueing Telemetry Transport）消息队列是 IBM开放的及时通讯协议，物联网系统架构中的重要组成部分

特点：

轻量，主要特点

传输快，不支持事务
没有持久化设计

3、OpenMessage协议

是近几年由阿里、雅虎和滴滴出行、Stremalio等公司共同参与创立的分布式信息中间件、流处理等领域的应用开发标准

特点：

结构简单
解析速度快
支持事务和持久化设计

4、Kafka协议

Kafka协议是基于 TCP/IP的二进制协议。消息内部是通过长度来分割，由一些基本数据类型组成

特点：

结构简单
解析速度快
无事务支持
有持久化设计

另外就是扯一嘴关于持久化这个概念，一般我们通常在数据库方面听这个词比较多，大概是个什么意思呢?

就是将数据存入磁盘中，数据能够长久保存，不会断电即失。

2、消息分发策略

发布订阅
- 很经典的一种方式，一旦消息消费者订阅了消息发布者的信息，只要消息发布者发送了消息，消费者就会接收到发布者发送过来的信息。
轮询分发和公平分发（其实公不公平按照自己的标准来评判）
- 公平分发，就是你的服务器性能越好，接收数据速度越快，接收到的消息就越多
- 轮询分发，就是无论你的服务器性能是怎么样的，快也好，慢也好，接收到的消息条数都是一样的
- 再提一嘴，这在之后的work模式中就是这两种消息分发策略

3、消息的高可用和高可靠

这个就不聊了，有兴趣的小伙伴可以查看这篇文章https://www.kuangstudy.com/zl/rabbitmq#1366029180994654209 （飞哥的原稿博客）

4、RabbitMQ的入门和安装

这里在linux下使用rpm安装包解压缩安装为例

首先RabbitMQ是使用Erlang语言开发的，我们需要安装Erlang 和 RabbitMQ
然后我们需要对应Erlang和RabbitMQ版本，详情见 https://www.rabbitmq.com/which-erlang.html

下载Erlang
- 下载地址 https://github.com/rabbitmq/erlang-rpm
- centos8 使用Erlang24 + el8
- centos7 使用Erlang23 + el7
- 其余操作系统看上面那个网址的readme部分
下载RabbitMQ
- 下载地址 https://github.com/rabbitmq/rabbitmq-server/releases
- 注意对应你的Erlange版本选择对应的RabbitMQ版本，版本对印表在上面有贴图显示
剩下的就是在linux下解压缩rpm包了

在看视频的时候，发现许多学习的小伙伴说卡在这里了，原因是没有找准好版本。这里给大家一个建议，在安装一个应用的时候，可以先百度搜索一下会出现什么坑，大致了解一下后再去安装会顺很多。

另外建议观看视频，狂神说里面搜索rabbitmq，是飞哥讲的，还不错，关于微服务的部分还没有看完，有时间继续。

5、RabbitMQ 的 web管理界面以及授权操作

类似于记单词中人对图片的记忆会比单纯的文字强很多。我们很有必要先使用web可视化界面的方式先熟悉一下，然后再使用代码实现，学习起来会容易理解一些。

RabbitMQ 管理界面

1、默认情况下，rabbitmq是没有安装web端的客户端插件，需要安装才可以生效

在linux系统上输入该条命令

rabbitmq-plugins enable rabbitmq_management

2、安装完成之后，启动服务即可

systemctl restart rabbitmq-server

3、浏览器访问，你的公网ip地址：15672，出现如下画面）切记，要在安全组和防火墙开放对应端口

4、授权创建新用户

# 创建新用户
rabbitmqctl add_user admin admin
# 授权
rabbitmqctl set_user_tags admin administrator

6、RabbitMQ角色分类（了解一下）

下面角色的权限是层层递进的, 这些大概了解一下就好了。

none

被设置成为这个角色的用户无法登陆这个Web页面

management （相当于个人中心）

被设置成为这个角色的用户只能访问跟自己相关的一些信息，你无法访问其他用户的一些信息

列出自己可以通过AMQP登入的虚拟机
查看自己的虚拟机节点 virtual hosts的queues,exchanges和bindings信息
查看和关闭自己的channels和connections
查看有关自己的虚拟机节点virtual hosts的统计信息。包括其他用户在这个节点virtual hosts中的活动信息。

Policymaker

包含management所有权限
查看和创建和删除自己的virtual hosts所属的policies和parameters信息。

Monitoring

包含management所有权限
罗列出所有的virtual hosts，包括不能登录的virtual hosts。
查看其他用户的connections和channels信息
查看节点级别的数据如clustering和memory使用情况
查看所有的virtual hosts的全局统计信息。

Administrator

最高权限
可以创建和删除virtual hosts
可以查看，创建和删除users
查看创建permisssions
关闭所有用户的connections

7、RabbitMQ快速入门案例

消息通信机制

前5种要掌握

在work模式中有两种（在Part2 消息的分发策略中有提及）

轮询
公平分发

入门案例

入门案例给学者一个快速上手的案例，建议多加理解

这小节讲述最简单的模式（Hello World），原理图如下

创建maven项目，导入依赖

编写生产者

package com.company.service.helloworld;

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

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

public class Producer {

    public static void main(String[] args) {

        // 这个是自动注入的,在rabbitAutoConfiguration中可以查看到
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 配置连接工厂信息, 就是以账号amdin,密码admin去访问RabbitMQ服务
        connectionFactory.setHost("xxx");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");


        Connection connection = null;
        Channel channel = null;

        try {
           // 创建连接对象
           connection =  connectionFactory.newConnection("生产者");
           // RabbitMQ是基于channel, 说明大部分功能都是channel创建对象来实现的
           channel = connection.createChannel();
           // 通过通道, 你可以创建交换机，声明队列，使用路由key绑定交换机和队列
           String queueName = "队列1";
           // 准备消息
           String message = "Hello,world";

           /**
            * 第一个参数 : 队列的名字
            * 第二个参数 : 可持久性
            * 第三个参数 : 排他性
            * 第四个参数 : 是否自动删除
            * 第五个参数 : 创建对象携带参数
            * */
           channel.queueDeclare(queueName,false,false,true,null);


           // 发送消息
           /**
            * 第一个参数 : 交换机的名字, 简单模式使用的是默认的交换机, 直接填空字符串即可. 注意！！！ 消息都会经过交换机然后再发送给队列, 没有写队列名就选择了默认队列
            * 第二个参数 : 队列的名字 / 路由key, 现在的东西都是陌生的, 不要着急，学到后面就会慢慢理解里面的含义
            * 第三个参数 : 基本属性
            * 第四个参数 : 消息的内容
            * */
           channel.basicPublish("",queueName,null,message.getBytes(StandardCharsets.UTF_8));
           System.out.println("消息发送成功");

        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            // 通常在finally中进行资源的释放
            if(channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }

            if(connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

结果演示：

查看web页面

编写消费者

package com.company.service.helloworld;

import com.rabbitmq.client.*;

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

public class Consumer {
    public static void main(String[] args) {
        // 所有的中间件技术都是基于tcp/ip协议基础之上构建的新型的协议规范，只不过rabbitmq遵循的是amqp协议, 是因为基本的tcp/ip协议无法满足这些需求了
        // 基于tcp/ip 你就需要两个东西 ip 端口
        
        // 1、创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 配置连接工厂信息, 就是以账号amdin,密码admin去访问RabbitMQ服务
        connectionFactory.setHost("xxx");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");


        Connection connection = null;
        Channel channel = null;

        try {
            // 可能会有人问,这不是消费者吗? 为什么是生产者呢? 这只是给连接对象的一个名字代号而已，你变更成为消费者也是可以的，
            // 况且生产者发送了消息过后，通道和连接都释放了。
            connection = connectionFactory.newConnection("生产者");
            channel = connection.createChannel();

            // 消费者获取消息, 如何获取, 绑定队列,
            // 第一个参数: 队列名 / 路由key 总之能绑定到队列就好了, 到后面会发现其实队列名也是路由key的一种表现形式
            // 第二个参数: 数据接收成功回调
            // 第三个参数: 数据接收失败回调
            channel.basicConsume("队列1", new DeliverCallback() {
                @Override
                public void handle(String consumerTag, Delivery message) throws IOException {
                    System.out.println("接收到的消息是" + new String(message.getBody(), "UTF-8"));
                }
            }, new CancelCallback() {
                @Override
                public void handle(String consumerTag) throws IOException {
                    System.out.println("接收失败了...");
                }
            });
            System.out.println("数据接收成功");
            // 卡着看运行结果
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            if(channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }

            if(connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

结果演示：

结束程序运行（因为使用了System.in.read()），查看web页面结果

显示没有队列了，为什么？？？

在创建队列的时候我们设置了自动删除，当队列中没有消息的时候就会自动删除队列了。

// 第一个参数 队列的名称
// 第二个参数 持久化 服务器重启时,消息还在,设置了在web页面会有D标签, 非持久化队列也会存盘,但重启服务器的话就会丢失。
// 第三个参数 排他性 是否是一个独占队列, 一般设置为false
// 第四个参数 自动删除 随着消费者消费完消息后, 消息队列是否被删除,
// 第五个参数 参数传递 设置了在web页面中会有args标签,否则没有。
channel.queueDeclare(queueName,false,false,true,null);

理一下思路

生产者：创建连接（ConnectionFactory —> connection —> channel), 创建交换机【这里使用的默认交换机，所以没有创建了】，创建队列【queueDeclare】（因为我们的rabbitmq是空的），使用交换机往队列中发送消息【basicPublish】

消费者：创建连接（ConnectionFactory —> connection —> channel) 【代码一致】，绑定队列接收消息【basicConsume】

小节总结（一定要认真了解第一个代码，里面包含了这个技术运行的基本套路）

首先，RabbitMQ是基于channel去处理请求的，而不是connect，所有重要操作都是channel去实现的，为什么要这么做？？？
- 连接要经过三次握手，四次挥手，每次开启关闭的开销都很大，我们要想办法减少连接的次数，就是将短连接转换为长连接（池化技术就是一种）。
然后，学习RabbitMQ你要熟知的，讲解视频的老师也会经常重复的，非常重要的点，生产者创建的所有消息都是经过交换机转发给队列的，每个队列必定会绑定一个交换机。就算如同上述简单模式没有显式的绑定交换机那样，rabbitmq会自动给这种队列绑定上一个默认的交换机。（下面给出web页面上关于默认交换机的介绍：这个交换机隐式的绑定了每个队列，路由key就是队列的名字，没有必要显式的给队列绑定默认交换机或者解绑默认交换机，同时这个交换机是不可以被删除的）

8、RabbitMQ的核心组成成分

（图片摘自学相伴）

里面很详细的讲述了关于消息队列进行消息通信的各个流程。

首先用户通过创立连接跟rabbitmq打交道，中间那个borker就是代理的意思，就是我们启动的rabbitmq服务。再次重复一遍，所有的消息都是通过交换机转发到队列的，每个队列必定会绑定一个交换机，交换机如何查找到不同的队列呢？通过路由key，我们已经见识了一种很普通的路由key，队列的名字。消费者也是通过创立连接跟我们的rabbitmq打交道，通过绑定队列来获取消息。这个跟第一个程序流程一致，跟后面的几种模式也是流程一致的，只是在交换机和队列的绑定路由key上面下了功夫，以满足不同场景需求。

你要知道的有

不会存在没有交换机的队列，没有指定交换机的队列绑定到了默认交换机上
- 就是生产者生产消息，首先会经过交换机，然后在进入到队列中去。
Routing key：是一个路由规则，虚拟机可以用它来确定如何路由一个特定消息。（有些场景下我们不希望所有的消费者都收到消息，这个时候我们可以使用路由key）
binding : Exchange和Queue之间的虚拟连接 , 我感觉就像路由表的样子这个binding
多个borker（RabbitMQ服务）就是一个消息队列集群。
虚拟主机
- 用于集群中的隔离，就好比计算机盘符中的c盘，d盘，e盘，f盘等……

分析

通过之前的代码和这幅图，可以得出RabbitMQ消费者订阅的本质，绑定了队列。所以不同模式下的消费者代码是没有变化的。

上面的术语解释：
Server：又称Broker ,接受客户端的连接，实现AMQP实体服务。安装rabbitmq-server
Connection：连接，应用程序与Broker的网络连接 TCP/IP/ 三次握手和四次挥手
Channel：网络信道，几乎所有的操作都在Channel中进行，Channel是进行消息读写的通道，客户端可以建立对各Channel，每个Channel代表一个会话任务。
Message :消息：服务与应用程序之间传送的数据，由Properties和body组成，Properties可是对消息进行修饰，比如消息的优先级，延迟等高级特性，Body则就是消息体的内容。
Virtual Host 虚拟地址，用于进行逻辑隔离，最上层的消息路由，一个虚拟主机理由可以有若干个Exhange和Queueu，同一个虚拟主机里面不能有相同名字的Exchange
Exchange：交换机，接受消息，根据路由键发送消息到绑定的队列。(不具备消息存储的能力)
Bindings：Exchange和Queue之间的虚拟连接，binding中可以保护多个routing key.
Routing key：是一个路由规则，虚拟机可以用它来确定如何路由一个特定消息。
Queue：队列：也成为Message Queue,消息队列，保存消息并将它们转发给消费者。

9、简单模式理解（建议下面几种模式，先看可视化界面怎么弄，然后回过来再看代码实现）

首先贴上官网的原理图

我们的入门案例就是这个，是用代码实现的。

使用web开发简单模式

开发简单模式，要明白的几个点
- 原理图上也没有画交换机，使用的是默认的交换机，即队列无需显式绑定交换机，
- 我们要弄的是
  - 创建队列
  - 从默认交换机中将消息发送出去（相当于生产者创建了消息）
  - 消费者从队列里面消费消息
- 实现
  - 创建队列（看下图创建队列的参数是不是和我们代码实现的基本差不多），如下设置好后(设置了队列名)，add queue
    - 结果演示
  - 从默认交换机中将消息发送出去
    - 找到默认交换机，
    - 点击进入交换机页面，找到发送消息的地儿
    - 发送消息
      - 简单模式下只需要填写Routing key 和 payload即可
        
        Routing key 是什么，怎么写？在之前，我们有说过，每个队列都会绑定一个交换机，没有显式绑定声明交换机的绑定默认交换机，并且路由key 是队列名，所以我们这里填入的是我们刚创建好的队列名
        
        payload : 负荷，就是你想要发送的消息，随便你填。
        
        然后点击publish message
    - 消费消息
      - 看下我们刚创建的队列，Ready为1，total为1，说明我们的消息发送到了这个队列中
      - 如何消费，消费者通过绑定队列消费，是不是可以这么理解呢？我们直接使用队列进行消息的消费，是不是模拟实现了消费者消费消息？基于上面理论，点击队列名进入队列面板
      - 队列如何消费消息（Get Message）
      - 讲解一下两种ack Mode
        
        Nack message ，就相当于预览消息，消息消费后队列中的消息数不会减少
        
        ACK, 消费消息，消息消费后，消息消费后队列中的消息数会减少，消费几条，减少几条
        
        设置消息消费的条数
      - 预览消息
      - 消费消息
        
        查看队列（要过5s才会刷新），消息被消费，没有了。

代码实现简单模式

就是我们之前快速入门中填写的

10、发布订阅者模式

这个用的比较多，在之前了解MQTT的时候，很多专栏都是描述这个发布订阅者模式，大同小异。

分析原理图

P —> 生产者

X —> 交换机

红色的块 —> 队列

C1,C2 —> 消费者

web 实现

首先对比简单模式，多了一个交换机，我们这里要创建交换机，简单模式使用的是默认交换机。

创建一个交换机切记：使用发布订阅模式，交换机类型要选择fanout
- exchange列表中有我们创建的交换机了
创建队列，创建队列和你使用哪个模式是没有关系的，所以创建队列一样的创建
绑定队列和交换机
- 填写队列名，点击bind，把三个队列都绑定上
- 查看绑定信息，要在绑定信息中点击队列名能够跳转到队列界面才算绑定好了
交换机发送消息
队列中查看消息
- 随便找个队列，查看一下消息

代码实现

生产者代码：

package com.company.service.fanout;

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

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

public class Producer {
    public static void main(String[] args) {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 这里填入你的主机ip
        connectionFactory.setHost("xxx");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;

        try {
            connection =  connectionFactory.newConnection("生产者");
            channel = connection.createChannel();

            String exchange = "fanout_exchange";
            String routingKey = "";
            String message = "代码实现发布订阅模式";
            // 这里要绑定交换机
            channel.basicPublish(exchange,routingKey,null,message.getBytes(StandardCharsets.UTF_8));
            System.out.println("消息发送成功");
        } catch (IOException e) {
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            if(channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }

            if(connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

结果演示：

web端查看

消费者代码

package com.company.service.fanout;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;


public class Consumer {
    private static Runnable runnable = new Runnable() {
        @Override
        public void run() {

            // 消费者基本逻辑不变
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("xxx");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("admin");
            connectionFactory.setPassword("admin");
            connectionFactory.setVirtualHost("/");

            final String queueName = Thread.currentThread().getName();

            Connection connection = null;
            Channel channel = null;

            try {
                connection = connectionFactory.newConnection("消费者");
                channel = connection.createChannel();
                // autoAck 为 true 相当于ack
                // autoAck 为 false 相当于nack
                channel.basicConsume(queueName,true, new DeliverCallback() {
                    @Override
                    public void handle(String consumerTag, Delivery message) throws IOException {
                        System.out.println(queueName + "接收到的消息是" + new String(message.getBody(), StandardCharsets.UTF_8));
                    }
                }, new CancelCallback() {
                    @Override
                    public void handle(String consumerTag) throws IOException {
                        System.out.println(queueName + "接收消息失败");
                    }
                });
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            } finally {
                if (channel != null && channel.isOpen()) {
                    try {
                        channel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (TimeoutException e) {
                        e.printStackTrace();
                    }
                }

                if (connection != null && connection.isOpen()) {
                    try {
                        connection.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    };


    public static void main(String[] args) {
        // 这里的ThreadName 一定要绑定自己的队列名,里面的代码使用的ThreadName绑定的队列名
        new Thread(runnable, "fanout_queue1").start();
        new Thread(runnable, "fanout_queue2").start();
        new Thread(runnable, "fanout_queue3").start();
    }
}

结果演示：

web查看

11、Routing模式 / 路由模式

首先看官方原理图

对比发布订阅模式

多了些什么，

是不是x (交换机上写着type=direct)，说明Routing模式下的交换机类型是direct类型的。
交换机和队列之间多了一些绑定关系（rabbitmq称这些绑定关系为路由key）

web实现

再次理一下操作流程，

首先讲消费者

消费者之前有说过，几种模式下的变动跟消费者无关，消费者代码无需变动

然后再讲生产者

首先，生产者肯定有变化的，具体变化在哪里，上面已经总结了，对比发布订阅者模式来说，
- 创建交换机时类型要选择direct，巩固复习一下（发布订阅者模式下的交换机要选择哪种类型，不清楚的小伙伴可以翻看之前的笔记，就在上一节）
- 然后就是交换机和队列之间的绑定关系（发布订阅者模式下没有使用路由key，而路由模式需要设置路由key）

上图：

创建交换机，注意，类型选择direct类型
创建队列
- 创建队列没有变动
设置路由key进行交换机和队列的绑定
- 三个队列都绑定后
发送消息
消息查看

测试：

1、使用发布订阅模式（交换机类型为fanout）去绑定多个有路由key的队列，并发送有绑定路由的消息，结果发现还是所有的队列都收到了消息

2、使用Routing模式（交换机类型为direct）去发送没有路由key的消息，页面显示消息发送，但是没有绑定路由，查看队列，所有队列都没有收到消息。

使用代码实现Routing模式

生产者代码，

package com.company.service.routing;

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

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

public class Producer {
    public static void main(String[] args) {

        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 这里绑定自己的主机ip
        connectionFactory.setHost("xxx");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;

        try {
            connection = connectionFactory.newConnection("生产者");
            channel = connection.createChannel();
            // 现在先知道每种模式的区别, 该如何发送消息, 到之后后面有一个具体的示例讲述如何创建不同类型的交换机以及交换机和队列之间的绑定
            // 区别在这里绑定了routing key
            channel.basicPublish("direct_exchange","email",null,"使用代码实现Routing模式".getBytes(StandardCharsets.UTF_8));
            System.out.println("消息发送成功");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            if(channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }

            if(connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

消费者代码

package com.company.service.routing;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;


public class Consumer {
    private static Runnable runnable = new Runnable() {
        @Override
        public void run() {

            // 消费者基本逻辑不变
            ConnectionFactory connectionFactory = new ConnectionFactory();
            // 这里绑定自己的主机ip
            connectionFactory.setHost("xxx");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("admin");
            connectionFactory.setPassword("admin");
            connectionFactory.setVirtualHost("/");

            final String queueName = Thread.currentThread().getName();

            Connection connection = null;
            Channel channel = null;

            try {
                connection = connectionFactory.newConnection("消费者");
                channel = connection.createChannel();
                // autoAck 为 true 相当于ack
                // autoAck 为 false 相当于nack
                channel.basicConsume(queueName,true, new DeliverCallback() {
                    @Override
                    public void handle(String consumerTag, Delivery message) throws IOException {
                        System.out.println(queueName + "接收到的消息是" + new String(message.getBody(), StandardCharsets.UTF_8));
                    }
                }, new CancelCallback() {
                    @Override
                    public void handle(String consumerTag) throws IOException {
                        System.out.println(queueName + "接收消息失败");
                    }
                });
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            } finally {
                if (channel != null && channel.isOpen()) {
                    try {
                        channel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (TimeoutException e) {
                        e.printStackTrace();
                    }
                }

                if (connection != null && connection.isOpen()) {
                    try {
                        connection.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    };


    public static void main(String[] args) {
        // 这里的ThreadName 一定要绑定自己的队列名,里面的代码使用的ThreadName绑定的队列名
        new Thread(runnable, "direct_queue1").start();
        new Thread(runnable, "direct_queue2").start();
        new Thread(runnable, "direct_queue3").start();
    }
}

结果演示：

结果分析：

因为我们首先使用了web进行routing实现的，消费者使用的nack模式，仅仅是预览，并没有删除消息。所以在代码中会全部接收。

12、Topics 模式

还是一样，看官网给出的原理图

这次对比Routing模式

有什么区别：

首先交换机类型不同，topics的交换机类型是topic类型的，路由模式的交换机是direct类型的
路由key不同
- topics模式下的路由key有通配符
- 而routing模式下的路由key没有通配符
- 所以，你可以理解为routing 模式是进行精准匹配的，topics模式是进行模糊匹配的，了解数据库的同学就可以很快理解其中的区别。

web 实现

创建交换机
创建队列

绑定队列和交换机

两种通配符

* , 仅能代表一个字符
#，能代表0个或者多个字符

# 举例
给出如下三个路由key
（1） #.order.#
（2） *.user.#
（3） *.course.*

com.company.order   ---  匹配1  理由: #代表0个或者多个, order前面是两个前缀，order后面是0个后缀
order.user 			---  匹配12 理由: 1能匹配如上解释，2能匹配是因为前面*代表一个前缀，后面#代表0个后缀
.user.				---  匹配2  理由:  .号用来分割个数,可以理解为user前后都有一个空字符串
user				---  都不匹配 理由: *仅能代表1个,不能代表0个
order.user.course   ---  匹配12 理由: 3号后面还要1个后缀
order.user.course.   --- 匹配12 理由: 3号后缀满足，但是3号前缀只能有1个前缀，*仅能代表一个

# 总结
* 只能代表1个， # 能代表0个或者多个

# 建议
使用web页面多多练习

发送消息
接收消息

测试

使用Topics 模式实现 Routing模式是可行的。就是使用Topic 类型的交换机发送精确路由给队列。队列收到了消息

代码实现

生产者：

package com.company.service.topic;

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

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

public class Producer {
    public static void main(String[] args) {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("xxx");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;

        try {
            connection = connectionFactory.newConnection("生产者");
            channel = connection.createChannel();
			// 这里切换路由key
            channel.basicPublish("topic_exchange","com.company.order",null,"代码实现topic模式".getBytes(StandardCharsets.UTF_8));
            System.out.println("消息发送成功");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            if(channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }

            if(connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

消费者：

package com.company.service.topic;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;


public class Consumer {
    private static Runnable runnable = new Runnable() {
        @Override
        public void run() {

            // 消费者基本逻辑不变
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("xxx");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("admin");
            connectionFactory.setPassword("admin");
            connectionFactory.setVirtualHost("/");

            final String queueName = Thread.currentThread().getName();

            Connection connection = null;
            Channel channel = null;

            try {
                connection = connectionFactory.newConnection("消费者");
                channel = connection.createChannel();
                // autoAck 为 true 相当于ack
                // autoAck 为 false 相当于nack
                channel.basicConsume(queueName,true, new DeliverCallback() {
                    @Override
                    public void handle(String consumerTag, Delivery message) throws IOException {
                        System.out.println(queueName + "接收到的消息是" + new String(message.getBody(), StandardCharsets.UTF_8));
                    }
                }, new CancelCallback() {
                    @Override
                    public void handle(String consumerTag) throws IOException {
                        System.out.println(queueName + "接收消息失败");
                    }
                });
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            } finally {
                if (channel != null && channel.isOpen()) {
                    try {
                        channel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (TimeoutException e) {
                        e.printStackTrace();
                    }
                }

                if (connection != null && connection.isOpen()) {
                    try {
                        connection.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    };


    public static void main(String[] args) {
        // 这里的ThreadName 一定要绑定自己的队列名,里面的代码使用的ThreadName绑定的队列名
        new Thread(runnable, "topic_queue1").start();
        new Thread(runnable, "topic_queue2").start();
        new Thread(runnable, "topic_queue3").start();
    }
}

结果演示：

13、Headers模式

headers模式官网上面没有，其实也是切换了一种绑定交换机和路由的方式，使用header进行绑定。

web演示

创建交换机（类型选择headers）
创建队列
绑定队列和交换机（使用参数的形式绑定）
发送消息
接收消息

14、完整的示例

在这小节之前已经讲述了RabbitMQ各种模式的区别，已经代码实现发送消息该如何编写，所以小伙伴们这小节的侧重点可以是如何使用代码创建不同类型的交换机以及交换机和队列之间的绑定问题。这里给出一个案例，剩下的靠小伙伴们自己进行融汇贯通了。

生产者代码

package com.company.service.all;

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

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

public class Producer {
    public static void main(String[] args) {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("xxx");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;


        try {
            connection =  connectionFactory.newConnection("生产者");
            channel = connection.createChannel();

            // 主要都是操作channel, 然后我们敲出对应的api就好了. 比如创建交换机,敲exchange; 创建队列, 敲queue; 绑定, 敲bind. 你熟悉了web界面的话就很容易看懂里面的参数是干什么用的

            // 创建交换机 这里我们创建一个Routing模式的交换机吧
            /**
             * 参数1: 交换机的名字
             * 参数2: 交换机的类型
             * 参数3: 是否可持久化
             * 参数4: 是否自动删除
             * 参数5: 参数
             * */
            channel.exchangeDeclare("routing_exchange","direct",true,false,null);

            // 创建队列
            channel.queueDeclare("routing_queue1",true,false,false,null);
            channel.queueDeclare("routing_queue2",true,false,false,null);
            channel.queueDeclare("routing_queue3",true,false,false,null);

            // 绑定交换机和队列
            channel.queueBind("routing_queue1","routing_exchange","email");
            channel.queueBind("routing_queue2","routing_exchange","sms");
            channel.queueBind("routing_queue3","routing_exchange","email");

            // 发送消息
            channel.basicPublish("routing_exchange","email",null,"完整的例子讲解".getBytes(StandardCharsets.UTF_8));
            System.out.println("消息发送成功");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            if(channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }

            if(connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

结果演示：

交换机创建以及绑定

队列创建以及消息的接收

消费者代码

package com.company.service.all;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;


public class Consumer {
    private static Runnable runnable = new Runnable() {
        @Override
        public void run() {

            // 消费者基本逻辑不变
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("xxx");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("admin");
            connectionFactory.setPassword("admin");
            connectionFactory.setVirtualHost("/");

            final String queueName = Thread.currentThread().getName();

            Connection connection = null;
            Channel channel = null;

            try {
                connection = connectionFactory.newConnection("消费者");
                channel = connection.createChannel();
                // autoAck 为 true 相当于ack
                // autoAck 为 false 相当于nack
                channel.basicConsume(queueName,true, new DeliverCallback() {
                    @Override
                    public void handle(String consumerTag, Delivery message) throws IOException {
                        System.out.println(queueName + "接收到的消息是" + new String(message.getBody(), StandardCharsets.UTF_8));
                    }
                }, new CancelCallback() {
                    @Override
                    public void handle(String consumerTag) throws IOException {
                        System.out.println(queueName + "接收消息失败");
                    }
                });
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            } finally {
                if (channel != null && channel.isOpen()) {
                    try {
                        channel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (TimeoutException e) {
                        e.printStackTrace();
                    }
                }

                if (connection != null && connection.isOpen()) {
                    try {
                        connection.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    };


    public static void main(String[] args) {
        // 这里的ThreadName 一定要绑定自己的队列名,里面的代码使用的ThreadName绑定的队列名
        new Thread(runnable, "routing_queue1").start();
        new Thread(runnable, "routing_queue2").start();
        new Thread(runnable, "routing_queue3").start();
    }
}

结果演示：

使用的ack自动应答，被消费者消费后消息剔除，web页面显示

15、work 模式

首先看官方原理图

跟简单模式进行比较，

看区别，然后总结一句话就是，work模式就是多个消费者的简单模式。

但是work模式下面有两种分配方式，之前提过的，（在第二小节，消息分发策略中提及）

轮询分配
公平分配

轮询分配

一个消费者一条消息，按均分配；

多个消费者的简单模式，简单模式下使用的是默认交换机，无需创建，无需显式绑定，路由key就是队列名

创建队列：

生产者代码：

package com.company.service.work.polling;

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

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

public class Producer {
    public static void main(String[] args) {
        // 1: 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2: 设置连接属性
        connectionFactory.setHost("xxx");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");

        Connection connection = null;
        Channel channel = null;

        try {
            connection = connectionFactory.newConnection("生产者");
            channel = connection.createChannel();


            for (int i = 0; i < 20; i++) {
                String message = "你好,我的朋友" + i;
                // 简单模式默认交换机设置为空字符即可
                // 队列名对应web创建的队列名
                channel.basicPublish("","polling_queue",null,message.getBytes(StandardCharsets.UTF_8));
            }

            System.out.println("消息发送成功");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            if(channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }

            if(connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

结果演示：

web查看：

消费者1代码：

package com.company.service.work.polling;

import com.rabbitmq.client.*;

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

public class Consumer1 {
    public static void main(String[] args) {
        // 1、创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 配置连接工厂信息, 就是以账号amdin,密码admin去访问RabbitMQ服务
        connectionFactory.setHost("xxx");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");


        Connection connection = null;
        Channel channel = null;

        try {
            connection = connectionFactory.newConnection("生产者");
            channel = connection.createChannel();

            // 消费者获取消息, 如何获取, 绑定队列,
            // 第一个参数: 队列名 / 路由key 总之能绑定到队列就好了, 到后面会发现其实队列名也是路由key的一种表现形式
            // 第二个参数: 数据接收成功回调
            // 第三个参数: 数据接收失败回调

            // 轮询模式就是设置为自动应答即可
            channel.basicConsume("polling_queue", true, new DeliverCallback() {
                @Override
                public void handle(String consumerTag, Delivery message) throws IOException {
                    // 模拟不同机器的速度, 我们使用sleep()
                    try {
                        System.out.println("接收到的消息是" + new String(message.getBody(), "UTF-8"));
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, new CancelCallback() {
                @Override
                public void handle(String consumerTag) throws IOException {
                    System.out.println("接收失败了...");
                }
            });
            System.out.println("consumer1正在接收消息");
            // 卡着看运行结果
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            if(channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }

            if(connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

消费者2代码

package com.company.service.work.polling;

import com.rabbitmq.client.*;

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

public class Consumer2 {
    public static void main(String[] args) {
        // 1、创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 配置连接工厂信息, 就是以账号amdin,密码admin去访问RabbitMQ服务
        connectionFactory.setHost("xxx");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");


        Connection connection = null;
        Channel channel = null;

        try {
            connection = connectionFactory.newConnection("生产者");
            channel = connection.createChannel();

            // 消费者获取消息, 如何获取, 绑定队列,
            // 第一个参数: 队列名 / 路由key 总之能绑定到队列就好了, 到后面会发现其实队列名也是路由key的一种表现形式
            // 第二个参数: 数据接收成功回调
            // 第三个参数: 数据接收失败回调

            // 轮询模式就是设置为自动应答即可,自动应答后会将消息剔除
            channel.basicConsume("polling_queue", true, new DeliverCallback() {
                @Override
                public void handle(String consumerTag, Delivery message) throws IOException {
                    // 模拟不同机器的速度, 我们使用sleep()
                    try {
                        System.out.println("接收到的消息是" + new String(message.getBody(), "UTF-8"));
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, new CancelCallback() {
                @Override
                public void handle(String consumerTag) throws IOException {
                    System.out.println("接收失败了...");
                }
            });
            System.out.println("consumer2正在接收消息");
            // 卡着看运行结果
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            if(channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }

            if(connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行方式：先运行消费者，再运行生产者，否则，就不是轮询了，然后先运行的消费者将消息全部消费了，后运行的消费者没有消息消费。

结果演示：

设置了不同延时的两个消费者，但是结果还是轮询

公平分配

根据消费者的消费能力进行公平分发，处理快的处理的多，处理慢的处理的少；按劳分配；

生产者代码

package com.company.service.work.fair;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

public class Producer {
    public static void main(String[] args) {
        // 1: 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2: 设置连接属性
        connectionFactory.setHost("xxx");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");

        Connection connection = null;
        Channel channel = null;

        try {
            connection = connectionFactory.newConnection("生产者");
            channel = connection.createChannel();


            for (int i = 0; i < 20; i++) {
                String message = "你好,我的朋友" + i;
                // 简单模式默认交换机设置为空字符即可
                // 队列名对应web创建的队列名
                channel.basicPublish("","polling_queue",null,message.getBytes(StandardCharsets.UTF_8));
            }

            System.out.println("消息发送成功");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            if(channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }

            if(connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

消费者1代码

package com.company.service.work.fair;

import com.rabbitmq.client.*;

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

public class Consumer1 {
    public static void main(String[] args) {
        // 1、创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 配置连接工厂信息, 就是以账号amdin,密码admin去访问RabbitMQ服务
        connectionFactory.setHost("xxx");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");


        Connection connection = null;
        Channel channel = null;

        try {
            connection = connectionFactory.newConnection("生产者");
            channel = connection.createChannel();

            // 消费者获取消息, 如何获取, 绑定队列,
            // 第一个参数: 队列名 / 路由key 总之能绑定到队列就好了, 到后面会发现其实队列名也是路由key的一种表现形式
            // 第二个参数: 数据接收成功回调
            // 第三个参数: 数据接收失败回调

            // 公平分发要用到 指标要定义出来, qos = 1 就是从服务器中一次拉取多少条消息过来。想要设置公平分发就要设置这个
            // 在非自动确认消息的前提下, 如果一定数目的消息未被确认前,不进行消费新的消息
            Channel finalChannel = channel;

            finalChannel.basicQos(1);
            // 公平分配设置autoAck为false
            finalChannel.basicConsume("polling_queue", false, new DeliverCallback() {
                @Override
                public void handle(String consumerTag, Delivery delivery) throws IOException {
                    // 模拟不同机器的速度, 我们使用sleep()
                    try {
                        System.out.println("接收到的消息是" + new String(delivery.getBody(), "UTF-8"));
                        Thread.sleep(2000);
                        // 设置好手动应答后
                        finalChannel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, new CancelCallback() {
                @Override
                public void handle(String consumerTag) throws IOException {
                    System.out.println("接收失败了...");
                }
            });
            System.out.println("consumer1正在接收消息");
            // 卡着看运行结果
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            if(channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }

            if(connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

消费者2代码

package com.company.service.work.fair;

import com.rabbitmq.client.*;

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

public class Consumer2 {
    public static void main(String[] args) {
        // 1、创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 配置连接工厂信息, 就是以账号amdin,密码admin去访问RabbitMQ服务
        connectionFactory.setHost("xxx");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");


        Connection connection = null;
        Channel channel = null;

        try {
            connection = connectionFactory.newConnection("生产者");
            channel = connection.createChannel();

            // 消费者获取消息, 如何获取, 绑定队列,
            // 第一个参数: 队列名 / 路由key 总之能绑定到队列就好了, 到后面会发现其实队列名也是路由key的一种表现形式
            // 第二个参数: 数据接收成功回调
            // 第三个参数: 数据接收失败回调
            Channel finalChannel = channel;


            finalChannel.basicQos(1);
            // 公平模式设置autoAck为false
            finalChannel.basicConsume("polling_queue", false, new DeliverCallback() {
                @Override
                public void handle(String consumerTag, Delivery delivery) throws IOException {
                    // 模拟不同机器的速度, 我们使用sleep()
                    try {
                        System.out.println("接收到的消息是" + new String(delivery.getBody(), "UTF-8"));
                        Thread.sleep(200);
                        finalChannel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, new CancelCallback() {
                @Override
                public void handle(String consumerTag) throws IOException {
                    System.out.println("接收失败了...");
                }
            });
            System.out.println("consumer2正在接收消息");
            // 卡着看运行结果
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            if(channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }

            if(connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

结果演示：

延时低的能接受更多的消息

16、RabbitMQ几种模式的总结

总结一下几种工作模式

1、简单模式

生产者：使用默认交换机向队列输入信息

消费者：所有工作模式的消费者都是一样的，指定队列进行消费就好了（下面就是说了）

2、工作模式

轮询模式：按均分配，多个消费者的简单模式，设置自动应答为true

公平分发：能者多劳，修改自动应答为false和Qos和设置手动应答

3、发布订阅模式

使用fanout交换机向队列输入信息

4、路由模式

使用direct交换机并按照路由key向指定队列输入信息

5、Topics模式

使用topic交换机并按照模糊路由key向指定队列输入信息，可以实现路由模式（路由模式就是精确的路由key相较于topics模式）

6、header模式

使用header交换机并设置header参数向指定队列输入信息。

17、springboot集成rabbitmq

1、创建一个springboot项目，勾选rabbitmq的服务

(当然你也要勾选web场景，这幅贴图是为了演示效果)

或者导入依赖


<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-amqpartifactId>
dependency>

<dependency>
    <groupId>org.springframework.amqpgroupId>
    <artifactId>spring-rabbit-testartifactId>
    <scope>testscope>
dependency>

2、查看自动注入的对象是什么，有什么需要配置的

在spring-boot-autoconfigure目录下的META-INF目录下寻找RabbitMQ的对应的自动配置类

点进去，一查看有哪些被@Bean修饰的对象，二查看绑定了xxxxproperties没有

看下RabbitProperties 为我们配置了哪些属性？哪些默认属性需要修改的，然后得出下述配置

# 配置我们的服务启动的端口 
# 使用的yml格式
server:
  port: 8081

# 配置rabbitmq服务
spring:
  rabbitmq:
    # xxxx--->你的主机ip
    host: xxxx
    username: admin
    password: admin
    virtual-host: /
    port: 5672

3、配置交换机，队列，绑定

package com.company.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyRabbitConfig {

    //1、声明fanout模式交换机注册
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanout_order_exchange",true,false);
    }

    //2、声明队列
    @Bean
    public Queue smsQueue() {
        return new Queue("sms.fanout.queue",true);
    }

    //2、声明队列
    @Bean
    public Queue emailQueue() {
        return new Queue("email.fanout.queue",true);
    }

    //2、声明队列
    @Bean
    public Queue duanxinQueue() {
        return new Queue("duanxin.fanout.queue",true);
    }

    //3、 声明绑定消息
    @Bean
    public Binding smsBinding() {
        return BindingBuilder.bind(smsQueue()).to(fanoutExchange());
    }

    @Bean
    public Binding emailBinding() {
        return BindingBuilder.bind(emailQueue()).to(fanoutExchange());
    }

    @Bean
    public Binding duanxinBinding() {
        return BindingBuilder.bind(duanxinQueue()).to(fanoutExchange());
    }
}

4、编写业务

@Service
public class OrderService {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 模拟用户下单
     * @param userid
     * @param productid
     * @param num
     */
    public void makeOrder(String userid,String productid,int num) {
        //1、根据商品id查询库存是否充足

        //2、保存订单
        String orderId = UUID.randomUUID().toString();
        System.out.println("订单生成成功:" + orderId);
        //3、通过MQl来完成消息的分发, 就相当于channel.basicPublish
        // 参数1: 交换机 参数2: 路由key/队列名 参数3:消息内容
        String exchangeName = "fanout_order_exchange";
        String routingKey = "";
        // 这句话实现消息发送
        rabbitTemplate.convertAndSend(exchangeName,routingKey,orderId);

    }
}

18、消费者编写

使用注解绑定监听队列

package com.company.service.fanout;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;

// 使用注解绑定消息队列
@RabbitListener(queues = {"sms.fanout.queue"})
// 这样项目一启动,就会开启rabbitmq的消费者功能了
@Service
public class SmsConsumer {
    // 收到信息后的成功回调
    @RabbitHandler
    public void receiveMessage(String message) {
        System.out.println("sms fanout--->接收到了订单信息是:->" + message);
    }
}

19、整合direct模式

配置类编写

   // ============== direct模式 ============================
    //1、声明fanout模式交换机注册
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange("direct_order_exchange",true,false);
    }

    //2、声明队列
    @Bean
    public Queue smsDirectQueue() {
        return new Queue("sms.Direct.queue",true);
    }

    //2、声明队列
    @Bean
    public Queue emailDirectQueue() {
        return new Queue("email.Direct.queue",true);
    }

    //2、声明队列
    @Bean
    public Queue duanxinDirectQueue() {
        return new Queue("duanxin.Direct.queue",true);
    }

    //3、 声明绑定消息 使用with绑定路由key
    @Bean
    public Binding smsBindingDirect() {
        return BindingBuilder.bind(smsDirectQueue()).to(directExchange()).with("sms");
    }

    @Bean
    public Binding emailBindingDirect() {
        return BindingBuilder.bind(emailDirectQueue()).to(directExchange()).with("email");
    }

    @Bean
    public Binding duanxinBindingDirect() {
        return BindingBuilder.bind(duanxinDirectQueue()).to(directExchange()).with("sms");
    }

业务代码编写

相比发布订阅模式设置了一个路由

public void makeOrderDirect(String userId,String productId,int num) {
    //1、 根据商品id查询库存是否充足

    //2、 保存订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("订单生成成功" + orderId);

    //3、 发送消息
    String exchange = "direct_order_exchange";
    String routingKey = "email";

    rabbitTemplate.convertAndSend(exchange,routingKey,orderId);
}

消费者

代码基本不变，就是绑定的队列名进行了更换

package com.company.service.direct;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;

@RabbitListener(queues = {"email.Direct.queue"})
@Service
public class EmailConsumer {
    @RabbitHandler
    public void receiveMessage(String message) {
        System.out.println("接收到了消息" + message);
    }
}

20、整合topic模式

使用注解的方式进行交换机的创建，队列的创建，

package com.company.service.topic;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Service;

// 使用注解绑定消息队列
// 使用@QueueBinding注解进行绑定，使用@Queue进行队列的创建,使用@Exchange进行交换机的创建
// 交换机可以重复创建，它默认不执行, 但是要保障消费者绑定的队列存在
@RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "duanxin.topic.queue",durable = "true",autoDelete = "false"),
        exchange = @Exchange(value = "topic_order_exchange",type = ExchangeTypes.TOPIC),
        key = "*.duanxin.*"
))
@Service
public class DuanxinTopicConsumer {

    // 收到信息后的成功回调
    @RabbitHandler
    public void receiveMessage(String message) {
        System.out.println("duanxin Topic--->接收到了订单信息是:->" + message);
    }
}

小事故

先插个眼，我猜测着应该与springboot的发送的convertandsend有关，发送的数据要设置具体格式，

使用web界面发送的数据，使用springboot去接收的时候出现了错误。

下面使用web获取的两条数据（上面一条是使用web发送的，下面一条是使用springboot集成发送的），springboot消息发送的时候设置了properties

21、过期时间TTL

过期时间TTL表示可以对消息设置预期的时间，在这个时间内都可以被消费者接收获取；过了之后消息将自动被删除。RabbitMQ可以对消息和队列设置TTL。目前有两种方法可以设置。

如果有死信队列中，我们过期的消息就会放到死信队列中。

有两种设置过期时间的方式

第一种方法是通过队列属性设置，队列中所有消息都有相同的过期时间。可以设置死信队列。
第二种方法是对消息进行单独设置，每条消息TTL可以不同。过期的消息无法恢复。

注意如果上述两种方法同时使用，则消息的过期时间以两者之间TTL较小的那个数值为准。消息在队列的生存时间一旦超过设置的TTL值，就称为dead message被投递到死信队列，消费者将无法再收到该消息。

1、第一种，设置队列属性

就是设置队列的属性，我们之前在创建队列的时候设置的最后一个队列可携带参数为null，这个地方可以进行对队列的属性设置

首先通过web了解一下设置ttl的key值，创建队列的最后一个参数的类型是map类型

代码实现

// ================== TTL相关配置 ===============
@Bean
public DirectExchange ttlDirectExchange() {
    return new DirectExchange("ttl_direct_exchange",true,false);
}

@Bean
public Queue ttlDirectQueue() {
    Map<String,Object> args = new HashMap<>();
    // 进行配置  第二个参数一定要是一个int类型，单位毫秒, 即过5s后消息自动过期
    args.put("x-message-ttl",5000);
    return new Queue("ttl.direct.queue",true,false,false,args);
}

// 声明绑定关系
@Bean
public Binding binding() {
    return BindingBuilder.bind(ttlDirectQueue()).to(ttlDirectExchange()).with("ttl");
}

结果演示

创建的队列有TTL标签

查看队列详细信息

查看队列中的消息（5s后消息过期了）

2、设置消息属性

设置消息属性，也是之前有个消息属性我们设置的为null

public void makeOrderTTLMessage(String userId,String productId,int num) {
    //1、 根据商品id查询库存是否充足

    //2、 保存订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("订单生成成功" + orderId);

    //3、 发送消息
    String exchange = "ttl_direct_exchange";
    String routingKey = "ttlmessage";

    // 给消息设置过期时间
    MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            //  这里是字符串类型, 单位也是毫秒
            message.getMessageProperties().setExpiration("5000");
            message.getMessageProperties().setContentEncoding("UTF-8");
            return message;
        }
    };

    rabbitTemplate.convertAndSend(exchange,routingKey,orderId,messagePostProcessor);
}

结果演示

队列没有设置为ttl过期队列，但是消息还是过期了，说明消息设置了过期时间

22、死信队列

DLX，全称为Dead-Letter-Exchange , 可以称之为死信交换机，也有人称之为死信邮箱。当消息在一个队列中变成死信(dead message)之后，它能被重新发送到另一个交换机中，这个交换机就是DLX ，绑定DLX的队列就称之为死信队列。
消息变成死信，可能是由于以下的原因：

消息被拒绝
消息过期
队列达到最大长度

就是一个普通队列，当其他队列消息过期后，指定发送到一个队列中去，然后这个队列就被称之为死信队列。但是你要记住，消息是通过交换机发送给队列的，所以我们要配置消息过期后发送指定的交换机，然后通过绑定队列实现发送消息到死信队列中去。

在队列设置过期时间后设置死信队列。

情况2演示：消息过期

代码演示：

// =================== 死信队列配置  ========================

// 创建一个交换机，用于传送消息给死信队列
@Bean
public DirectExchange deadDirectExchange() {
    return new DirectExchange("dead_direct_exchange",true,false);
}

// 创建死信队列, 本质上就是一个普通的队列, 只不过过期的消息指定往这个队列中存储, 所以这个队列就被称之为死信队列
@Bean
public Queue deadDirectQueue() {
    return new Queue("dead_direct_queue",true,false,false,null);
}

@Bean
public Binding deadBinding() {
    return BindingBuilder.bind(deadDirectQueue()).to(deadDirectExchange()).with("dead");
}

// 创建一个交换机，用来绑定ttl队列
@Bean
public DirectExchange ttlDirectExchange() {
    return new DirectExchange("ttl_direct_exchange",true,false);
}

// 另外就是只有设置ttl的队列消息过期后才会进入到死信队列中, 而设置消息过期属性是不可以进入到死信队列中的
@Bean
public Queue ttlDirectQueue() {
    Map<String,Object> args = new HashMap<>();
    // 进行配置  第二个参数一定要是一个int类型，单位毫秒, 即过5s后消息自动过期
    // 1、进入死信队列的第一种情况，消息过期
    args.put("x-message-ttl",5000);
    // 设置死信队列，消息是通过交换机发送到队列中的，这点要切记
    args.put("x-dead-letter-exchange","dead_direct_exchange");
    // 我们的交换机是direct类型的，要绑定路由key
    args.put("x-dead-letter-routing-key","dead");

    return new Queue("ttl.direct.queue",true,false,false,args);
}

// 声明绑定关系
@Bean
public Binding binding() {
    return BindingBuilder.bind(ttlDirectQueue()).to(ttlDirectExchange()).with("ttl");
}

演示结果：

ttl中的数据存入到了死信队列中

消息获取详情

情况3演示：队列达到最大长度

代码演示：

// =================== 死信队列配置  ========================

// 创建一个交换机，用于传送消息给死信队列
@Bean
public DirectExchange deadDirectExchange() {
    return new DirectExchange("dead_direct_exchange",true,false);
}

// 创建死信队列, 本质上就是一个普通的队列, 只不过过期的消息指定往这个队列中存储, 所以这个队列就被称之为死信队列
@Bean
public Queue deadDirectQueue() {
    return new Queue("dead_direct_queue",true,false,false,null);
}

@Bean
public Binding deadBinding() {
    return BindingBuilder.bind(deadDirectQueue()).to(deadDirectExchange()).with("dead");
}

// 创建一个交换机，用来绑定ttl队列
@Bean
public DirectExchange ttlDirectExchange() {
    return new DirectExchange("ttl_direct_exchange",true,false);
}

// 另外就是只有设置ttl的队列消息过期后才会进入到死信队列中, 而设置消息过期属性是不可以进入到死信队列中的
@Bean
public Queue ttlDirectQueue() {
    Map args = new HashMap<>();
    // 进行配置  第二个参数一定要是一个int类型，单位毫秒, 即过5s后消息自动过期
    // 进入死信队列中的第二种情况:超出队列长度
    args.put("x-max-length",5);

    // 设置死信队列，消息是通过交换机发送到队列中的，这点要切记
    args.put("x-dead-letter-exchange","dead_direct_exchange");
    // 我们的交换机是direct类型的，要绑定路由key
    args.put("x-dead-letter-routing-key","dead");

    return new Queue("ttl.direct.queue",true,false,false,args);
}

// 声明绑定关系
@Bean
public Binding binding() {
    return BindingBuilder.bind(ttlDirectQueue()).to(ttlDirectExchange()).with("ttl");
}

数据发送

 public void makeOrderDeadMaxLength(String userId,String productId,int num) {
     //1、 根据商品id查询库存是否充足

     //2、 保存订单
     String orderId = UUID.randomUUID().toString();
     System.out.println("订单生成成功" + orderId);

     //3、 发送消息
     String exchange = "ttl_direct_exchange";
     String routingKey = "ttl";

     for (int i = 0; i < 10; i++) {
         // 设置后缀, 让输出到死信队列中的数据更加明显
         char suffix = 'a';
         suffix += i;
         rabbitTemplate.convertAndSend(exchange,routingKey,orderId + suffix);
     }
 }

结果演示：（小伙伴们可以猜一下是哪几条数据进入了死信队列）

答案揭晓：是前5条，可以看下面的结论，也可以根据队列先进先出的结构特性进行猜测。

进入死信队列的数据（下面的交换机可以证明是发送给的死信队列）

23、内存磁盘监控

参考帮助文档：https://www.rabbitmq.com/configure.html

web界面数据查看

1、内存监控

当内存使用超过配置的阈值或者磁盘空间剩余空间对于配置的阈值时，RabbitMQ会暂时阻塞客户端的连接，并且停止接收从客户端发来的消息，以此避免服务器的崩溃，客户端与服务端的心态检测机制也会失效。

命令行的方式（2者选其一）

第一种是选择使用比率进行（默认0.4）

第二种是选择设置具体的内存大小

rabbitmqctl set_vm_memory_high_watermark
rabbitmqctl set_vm_memory_high_watermark absolute 50MB

直接修改配置文件

当前配置文件：/etc/rabbitmq/rabbitmq.conf

#默认
#vm_memory_high_watermark.relative = 0.4
# 使用relative相对值进行设置fraction,建议取值在04~0.7之间，不建议超过0.7.
vm_memory_high_watermark.relative = 0.6
# 使用absolute的绝对值的方式，但是是KB,MB,GB对应的命令如下
vm_memory_high_watermark.absolute = 2GB

2、内存换页

在某个Broker节点及内存阻塞生产者之前，它会尝试将队列中的消息换页到磁盘以释放内存空间，持久化和非持久化的消息都会写入磁盘中，其中持久化的消息本身就在磁盘中有一个副本，所以在转移的过程中持久化的消息会先从内存中清除掉。

默认情况下，内存到达的阈值是50%时就会换页处理。
也就是说，在默认情况下该内存的阈值是0.4的情况下，当内存超过0.4*0.5=0.2时，会进行换页动作。

比如有1000MB内存，当内存的使用率达到了400MB,已经达到了极限，但是因为配置的换页内存0.5，这个时候会在达到极限400mb之前，会把内存中的200MB进行转移到磁盘中。从而达到稳健的运行。

可以通过设置 vm_memory_high_watermark_paging_ratio 来进行调整

vm_memory_high_watermark.relative = 0.4vm_memory_high_watermark_paging_ratio = 0.7（设置小于1的值,最好小于等于0.7）

为什么设置小于1，以为你如果你设置为1的阈值。内存都已经达到了极限了。你在去换页意义不是很大了。

3、磁盘监控

当磁盘的剩余空间低于确定的阈值时，RabbitMQ同样会阻塞生产者，这样可以避免因非持久化的消息持续换页而耗尽磁盘空间导致服务器崩溃。

默认情况下：磁盘预警为50MB的时候会进行预警。表示当前磁盘空间低于50MB的时候会阻塞生产者并且停止内存消息换页到磁盘的过程。
这个阈值可以减小，但是不能完全的消除因磁盘耗尽而导致崩溃的可能性。比如在两次磁盘空间的检查空隙内，第一次检查是：60MB ，第二检查可能就是1MB,就会出现警告。

命令行模式修改

rabbitmqctl set_disk_free_limit  <disk_limit>
rabbitmqctl set_disk_free_limit memory_limit  <fraction>
disk_limit：固定单位 KB MB GB
fraction ：是相对阈值，建议范围在:1.0~2.0之间。（相对于内存）

修改配置文件

disk_free_limit.relative = 3.0
disk_free_limit.absolute = 50mb

集群部分

剩下再补充

你可能感兴趣的:(RabbitMQ,rabbitmq,学习)

情绪觉察日记第37天露露_e800
今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
铭刻于星（四十二）随风至
69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
UI学习——cell的复用和自定义cell Magnetic_h ui 学习
目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
学点心理知识，呵护孩子健康静候花开_7090
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
消息中间件有哪些常见类型 xmh-sxh-1314 java
消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）研学随笔 arcgis 经验分享
我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
2019-12-22-22:30 涓涓1016
今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
GitHub上克隆项目 bigbig猩猩 github
从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
阶段总结反思轻争
马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
ARM驱动学习之基础小知识 JT灬新一 ARM 嵌入式 arm开发学习
ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
ARM驱动学习之5 LEDS驱动 JT灬新一嵌入式 C 底层 arm开发学习单片机
ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
ARM驱动学习之4小结 JT灬新一嵌入式 C++arm开发学习 linux
ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
展现思维导图魅力，不断挖掘人生宝藏思维导图讲师Mandy
第13期最强思维导图训练营已经结束一周了，但是我依旧是感觉所有学员还在努力的学习，这些学员中有教师、学生、白领、公务员、宝妈等等，只要你努力，只要你想改变自己，任何行业，任何岗位都可以参与进来，28天足以让你见成效，在这28天中，我们的学员不仅仅是收获了一枚毕业证，最重要的是让自己的思维方式得到升级，今天的你为自己投资，明天的你就会感谢你今天的付出，我们来听一听来自13期最强思维导图训练营优秀学员
2019-3-23晨间日记红红火火小耳朵
今天是什么日子起床：7点40就寝：23点半天气：有太阳，不过一会儿出来一会儿进去特别清爽的凉意，还蛮舒服的心情：小激动要给女朋友过生日啦纪念日：田田女士过生日任务清单昨日完成的任务，最重要的三件事：1.英语一对一2.运动计划3.认真护肤习惯养成：调整状态周目标·完成进度英语七天打卡（5/7）轻课阅读（87/180）音标课（25/30）读书（福尔摩斯一章）学习·信息·阅读#英语课#Cookingte
【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面一个射手座的程序媛程序员华为od 面试职场和发展
最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
教育用心灵温暖心灵
@陈春丽长期学习班冯倩。今天一早就听到说高职合并，取消中专教育的教育信息。感觉是虽然知道，再听还是吓一跳。国家重视职业教育为何还要取消中专技术学校的教育？再听高中就要进行技术教育了，一部分人学习好继续努力学习考大学，一部分人在高中就可以进行职业教育接受职业教育了还要中专技术教育学校干什么呢！a有些职业教育学校转型升级快，不是孩子上完给找工作，而是学校帮孩子创业，我觉得是不错的方向！新闻新你得实时更
数字里的世界17期：2021年全球10大顶级数据中心，中国移动榜首张三叨
你知道吗？2016年，全球的数据中心共计用电4160亿千瓦时，比整个英国的发电量还多40％！前言每天，我们都会创造超过250万TB的数据。并且随着物联网（IOT）的不断普及，这一数据将持续增长。如此庞大的数据被存储在被称为“数据中心”的专用设施中。虽然最早的数据中心建于20世纪40年代，但直到1997-2000年的互联网泡沫期间才逐渐成为主流。当前人类的技术，比如人工智能和机器学习，已经将我们推向
学习“论语”-第59天春峰轩
12.14子张问政。子曰：“居之无倦，行之以忠。”子张问为政之道。孔子说：“在位尽职不懈怠，执行政令要忠诚。”12.15子曰：“博学于文，约之以礼，亦可以弗畔矣夫！”孔子说：“君子广泛地学习文献，并且用礼节约束自己，也就不会离经叛道了。”12.16子曰：“君子成人之美，不成人之恶。小人反是。”孔子说：“君子成全别人的好事，而不助长别人的坏处。小人则与此相反行事。”知识点:“成人之美，不成人之恶”贯
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
《Python数据分析实战终极指南》 xjt921122 python 数据分析开发语言
对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
遍历dom 并且存储（将每一层的DOM元素存在数组中）换个号韩国红果果 JavaScript html
数组从0开始！！ var a=[],i=0; for(var j=0;j<30;j++){ a[j]=[];//数组里套数组，且第i层存储在第a[i]中 } function walkDOM(n){ do{ if(n.nodeType!==3)//筛选去除#text类型 a[i].push(n); //con
Android+Jquery Mobile学习系列(9)-总结和代码分享白糖_ JQuery Mobile
目录导航经过一个多月的边学习边练手，学会了Android基于Web开发的毛皮，其实开发过程中用Android原生API不是很多，更多的是HTML/Javascript/Css。个人觉得基于WebView的Jquery Mobile开发有以下优点： 1、对于刚从Java Web转型过来的同学非常适合，只要懂得HTML开发就可以上手做事。 2、jquerym
impala参考资料 dayutianfei impala
记录一些有用的Impala资料 1. 入门资料 >>官网翻译： http://my.oschina.net/weiqingbin/blog?catalog=423691 2. 实用进阶 >>代码&架构分析： Impala/Hive现状分析与前景展望：http
JAVA 静态变量与非静态变量初始化顺序之新解周凡杨 java 静态非静态顺序
今天和同事争论一问题，关于静态变量与非静态变量的初始化顺序，谁先谁后，最终想整理出来！测试代码： import java.util.Map; public class T { public static T t = new T(); private Map map = new HashMap(); public T(){ System.out.println(&quo
跳出iframe返回外层页面 g21121 iframe
在web开发过程中难免要用到iframe，但当连接超时或跳转到公共页面时就会出现超时页面显示在iframe中，这时我们就需要跳出这个iframe到达一个公共页面去。首先跳转到一个中间页，这个页面用于判断是否在iframe中，在页面加载的过程中调用如下代码： <script type="text/javascript"> //<!-- function
JAVA多线程监听JMS、MQ队列 510888780 java多线程
背景：消息队列中有非常多的消息需要处理，并且监听器onMessage（）方法中的业务逻辑也相对比较复杂，为了加快队列消息的读取、处理速度。可以通过加快读取速度和加快处理速度来考虑。因此从这两个方面都使用多线程来处理。对于消息处理的业务处理逻辑用线程池来做。对于加快消息监听读取速度可以使用1.使用多个监听器监听一个队列；2.使用一个监听器开启多线程监听。对于上面提到的方法2使用一个监听器开启多线
第一个SpringMvc例子布衣凌宇 spring mvc
第一步：导入需要的包；第二步：配置web.xml文件 <?xml version="1.0" encoding="UTF-8"?> <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi=
我的spring学习笔记15-容器扩展点之PropertyOverrideConfigurer aijuans Spring3
PropertyOverrideConfigurer类似于PropertyPlaceholderConfigurer，但是与后者相比，前者对于bean属性可以有缺省值或者根本没有值。也就是说如果properties文件中没有某个bean属性的内容，那么将使用上下文（配置的xml文件）中相应定义的值。如果properties文件中有bean属性的内容，那么就用properties文件中的值来代替上下
通过XSD验证XML antlove xml schema xsd validation SchemaFactory
1. XmlValidation.java package xml.validation; import java.io.InputStream; import javax.xml.XMLConstants; import javax.xml.transform.stream.StreamSource; import javax.xml.validation.Schem
文本流与字符集百合不是茶 PrintWrite()的使用字符集名字别名获取
文本数据的输入输出; 输入;数据流,缓冲流输出;介绍向文本打印格式化的输出PrintWrite(); package 文本流; import java.io.FileNotFound
ibatis模糊查询sqlmap-mapping-**.xml配置 bijian1013 ibatis
正常我们写ibatis的sqlmap-mapping-*.xml文件时，传入的参数都用##标识，如下所示： <resultMap id="personInfo" class="com.bijian.study.dto.PersonDTO"> <res
java jvm常用命令工具——jdb命令(The Java Debugger) bijian1013 java jvm jdb
用来对core文件和正在运行的Java进程进行实时地调试，里面包含了丰富的命令帮助您进行调试，它的功能和Sun studio里面所带的dbx非常相似，但 jdb是专门用来针对Java应用程序的。现在应该说日常的开发中很少用到JDB了，因为现在的IDE已经帮我们封装好了，如使用ECLI
【Spring框架二】Spring常用注解之Component、Repository、Service和Controller注解 bit1129 controller
在Spring常用注解第一步部分【Spring框架一】Spring常用注解之Autowired和Resource注解（http://bit1129.iteye.com/blog/2114084）中介绍了Autowired和Resource两个注解的功能，它们用于将依赖根据名称或者类型进行自动的注入，这简化了在XML中，依赖注入部分的XML的编写，但是UserDao和UserService两个bea
cxf wsdl2java生成代码super出错,构造函数不匹配 bitray super
由于过去对于soap协议的cxf接触的不是很多,所以遇到了也是迷糊了一会.后来经过查找资料才得以解决. 初始原因一般是由于jaxws2.2规范和jdk6及以上不兼容导致的.所以要强制降为jaxws2.1进行编译生成.我们需要少量的修改: 我们原来的代码 wsdl2java com.test.xxx -client http://..... 修改后的代
动态页面正文部分中文乱码排障一例 ronin47
公司网站一部分动态页面，早先使用apache+resin的架构运行，考虑到高并发访问下的响应性能问题，在前不久逐步开始用nginx替换掉了apache。不过随后发现了一个问题，随意进入某一有分页的网页，第一页是正常的（因为静态化过了）；点“下一页”，出来的页面两边正常，中间部分的标题、关键字等也正常，唯独每个标题下的正文无法正常显示。因为有做过系统调整，所以第一反应就是新上
java-54- 调整数组顺序使奇数位于偶数前面 bylijinnan java
import java.util.Arrays; import java.util.Random; import ljn.help.Helper; public class OddBeforeEven { /** * Q 54 调整数组顺序使奇数位于偶数前面 * 输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半
从100PV到1亿级PV网站架构演变 cfyme 网站架构
一个网站就像一个人，存在一个从小到大的过程。养一个网站和养一个人一样，不同时期需要不同的方法，不同的方法下有共同的原则。本文结合我自已14年网站人的经历记录一些架构演变中的体会。 1：积累是必不可少的架构师不是一天练成的。 1999年，我作了一个个人主页，在学校内的虚拟空间，参加了一次主页大赛，几个DREAMWEAVER的页面，几个TABLE作布局，一个DB连接，几行PHP的代码嵌入在HTM
[宇宙时代]宇宙时代的GIS是什么？ comsci Gis
我们都知道一个事实，在行星内部的时候，因为地理信息的坐标都是相对固定的，所以我们获取一组GIS数据之后，就可以存储到硬盘中，长久使用。。。但是，请注意，这种经验在宇宙时代是不能够被继续使用的宇宙是一个高维时空
详解create database命令 czmmiao database
完整命令 CREATE DATABASE mynewdb USER SYS IDENTIFIED BY sys_password USER SYSTEM IDENTIFIED BY system_password LOGFILE GROUP 1 ('/u01/logs/my/redo01a.log','/u02/logs/m
几句不中听却不得不认可的话 datageek
1、人丑就该多读书。 2、你不快乐是因为：你可以像猪一样懒，却无法像只猪一样懒得心安理得。 3、如果你太在意别人的看法，那么你的生活将变成一件裤衩，别人放什么屁，你都得接着。 4、你的问题主要在于：读书不多而买书太多，读书太少又特爱思考，还他妈话痨。 5、与禽兽搏斗的三种结局：(1)、赢了，比禽兽还禽兽。(2)、输了，禽兽不如。(3)、平了，跟禽兽没两样。结论：选择正确的对手很重要。 6
1 14:00 PHP中的“syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM”错误 dcj3sjt126com PHP
原文地址：http://www.kafka0102.com/2010/08/281.html 因为需要，今天晚些在本机使用PHP做些测试，PHP脚本依赖了一堆我也不清楚做什么用的库。结果一跑起来，就报出类似下面的错误：“Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM in /home/kafka/test/
xcode6 Auto layout and size classes dcj3sjt126com ios
官方GUI https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/AutolayoutPG/Introduction/Introduction.html iOS中使用自动布局（一） http://www.cocoachina.com/ind
通过PreparedStatement批量执行sql语句【sql语句相同，值不同】梦见x光 sql 事务批量执行
比如说：我有一个List需要添加到数据库中，那么我该如何通过PreparedStatement来操作呢？ public void addCustomerByCommit(Connection conn , List<Customer> customerList) { String sql = "inseret into customer(id
程序员必知必会----linux常用命令之十【系统相关】 hanqunfeng Linux常用命令
一.linux快捷键 Ctrl+C : 终止当前命令 Ctrl+S : 暂停屏幕输出 Ctrl+Q : 恢复屏幕输出 Ctrl+U : 删除当前行光标前的所有字符 Ctrl+Z : 挂起当前正在执行的进程 Ctrl+L : 清除终端屏幕，相当于clear 二.终端命令 clear : 清除终端屏幕 reset : 重置视窗，当屏幕编码混乱时使用 time com
NGINX IXHONG nginx
pcre 编译安装 nginx conf/vhost/test.conf upstream admin { server 127.0.0.1:8080; } server { listen 80; &
设计模式--工厂模式 kerryg 设计模式
工厂方式模式分为三种： 1、普通工厂模式：建立一个工厂类，对实现了同一个接口的一些类进行实例的创建。 2、多个工厂方法的模式：就是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式就是提供多个工厂方法，分别创建对象。 3、静态工厂方法模式：就是将上面的多个工厂方法模式里的方法置为静态，
Spring InitializingBean/init-method和DisposableBean/destroy-method mx_xiehd java spring bean xml
1.initializingBean/init-method 实现org.springframework.beans.factory.InitializingBean接口允许一个bean在它的所有必须属性被BeanFactory设置后，来执行初始化的工作，InitialzingBean仅仅指定了一个方法。通常InitializingBean接口的使用是能够被避免的，（不鼓励使用，因为没有必要
解决Centos下vim粘贴内容格式混乱问题 qindongliang1922 centos vim
有时候，我们在向vim打开的一个xml，或者任意文件中，拷贝粘贴的代码时，格式莫名其毛的就混乱了，然后自己一个个再重新，把格式排列好，非常耗时，而且很不爽，那么有没有办法避免呢？答案是肯定的，设置下缩进格式就可以了，非常简单：在用户的根目录下直接vi ~/.vimrc文件然后将set pastetoggle=<F9> 写入这个文件中，保存退出，重新登录，
netty大并发请求问题 tianzhihehe netty
多线程并发使用同一个channel java.nio.BufferOverflowException: null at java.nio.HeapByteBuffer.put(HeapByteBuffer.java:183) ~[na:1.7.0_60-ea] at java.nio.ByteBuffer.put(ByteBuffer.java:832) ~[na:1.7.0_60-ea]
Hadoop NameNode单点问题解决方案之一 AvatarNode wyz2009107220 NameNode
我们遇到的情况 Hadoop NameNode存在单点问题。这个问题会影响分布式平台24*7运行。先说说我们的情况吧。我们的团队负责管理一个1200节点的集群(总大小12PB)，目前是运行版本为Hadoop 0.20，transaction logs写入一个共享的NFS filer(注：NetApp NFS Filer)。经常遇到需要中断服务的问题是给hadoop打补丁。 DataNod