作者： 清朝云

共计 1331 个字符，预计需要花费 4 分钟才能阅读完成。

缓存机制介绍

Java 基本数据类型的包装类型的大部分都用到了缓存机制来提升性能。

Byte,Short,Integer,Long 这 4 种包装类默认创建了数值 [-128，127] 的相应类型的缓存数据，Character 创建了数值在 [0,127] 范围的缓存数据，Boolean 直接返回 True or False。

Integer 缓存源码：

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}
private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static {
        // high value may be configured by property
        int h = 127;
    }
}

Character 缓存源码:

public static Character valueOf(char c) {
    if (c <= 127) { // must cache
      return CharacterCache.cache[(int)c];
    }
    return new Character(c);
}

private static class CharacterCache {
    private CharacterCache(){}
    static final Character cache[] = new Character[127 + 1];
    static {
        for (int i = 0; i < cache.length; i++)
            cache[i] = new Character((char)i);
    }

}

Boolean 缓存源码：

public static Boolean valueOf(boolean b) {
    return (b ? TRUE : FALSE);
}

如果超出对应范围仍然会去创建新的对象，缓存的范围区间的大小只是在性能和资源之间的权衡。

两种浮点数类型的包装类 Float,Double 并没有实现缓存机制。

示例

Integer i1 = 33;
Integer i2 = 33;
System.out.println(i1 == i2);// 输出 true

Float i11 = 333f;
Float i22 = 333f;
System.out.println(i11 == i22);// 输出 false

Double i3 = 1.2;
Double i4 = 1.2;
System.out.println(i3 == i4);// 输出 false

下面我们来看一下问题。下面的代码的输出结果是 true 还是 false 呢？

Integer i1 = 40;
Integer i2 = new Integer(40);
System.out.println(i1==i2);

Integer i1=40 这一行代码会发生装箱，也就是说这行代码等价于 Integer i1=Integer.valueOf(40) 。因此，i1 直接使用的是缓存中的对象。而Integer i2 = new Integer(40) 会直接创建新的对象。

记住：所有整型包装类对象之间值的比较，全部使用 equals 方法比较。

提醒：本文发布于639天前，文中所关联的信息可能已发生改变，请知悉！

/>

共计 435 个字符，预计需要花费 2 分钟才能阅读完成。

之前写过一篇 Linux 安装 aria2 并使用 AriaNg 图形管理，但其实这篇文章是原生安装，比较复杂。

下面使用 docker 安装会显得非常简单，因为所有的环境都不需要自己配置，并且也是集成了图形管理界面，清朝云强烈推荐这种方式安装。

docker run -d \
--name=aria2 \
-e SECRET=123456 \
-e CACHE=512M \
-p 32516:32516 \
-p 32516:32516/udp \
-p 6800:6800 \
-p 8080:8080 \
-v /home/docker/aria2/config:/config \
-v /home/docker/aria2/downloads:/downloads \
--restart always \
superng6/aria2:webui-latest

SECRET 是 rpc 调用需要的密钥，8080 是 web 图像管理端口，6800 是 rpc 远程调用端口，32516 是 DHT 和 BT 监听端口。

然后只需要填写上面设置的密钥即可，是不是非常简单。

提醒：本文发布于638天前，文中所关联的信息可能已发生改变，请知悉！

/>

共计 868 个字符，预计需要花费 3 分钟才能阅读完成。

Calibre-web 是一个基于 Web 的开源电子书管理系统，只要能连上网络，可以随时随地看自己的电子书。

相比于其他阅读软件，自己搭建的好处就是可以不限容量，不限数量的存放电子书，并且不存在被和谐和软件公司倒闭的风险。

另外，Calibre-web 可以与 Calibre 电子书管理软件同步，用户可以通过 Web 界面访问和管理 Calibre 库中的电子书。

安装

docker run -d \
--name=calibre-web \
--restart=always \
-p 8083:8083 \
-v /home/docker/calibre-web/config:/config \
-v /home/docker/calibre-web/library:/library \
--privileged \
johngong/calibre-web

默认账号密码: admin/admin123

通过 8083 端口登录后记得进行修改密码。

配置

配置上传权限

登陆后的页面如下图所示，左边可以根据不同的条件快速查找到需要的书籍。

/>

安装好以后最重要的就是配置用户的上传权限了，不然可无法阅读电子书。

首先点击右上角的管理权限，再点击编辑基本配置。

/>

然后再勾选功能配置的启用上传。

/>

保存后可以看见右上角多出了上传书籍的按钮。

/>

配置左侧搜索条件

对于大部分人来说，应该用不到左侧那么多浏览条件，这个时候可以根据自己需要配置。

点击右上角 admin 即可配置。

/>

清朝云只保留分类和文件格式的搜索条件，看起来就清爽多了。

/>

效果展示

这里展示只展示阅读 pdf 的了，因为清朝云平常只有阅读 pdf 的习惯，目前这里上传了两本 pdf。

/>

并且都是 100 多兆的。

/>

点击在线阅读后，页面如图所示:

/>

最重要的是 pdf 的文档是懒加载的，而不是把pdf全部下载加载到内存中才能查看!

/>

可以看见只加载了不到 10M。

手机阅读配置

下载 app 后点击网上书库。

/>

再点击右上角的增加新书库，填写自己的地址即可。

/>

然后就能方便的查看电子书了。

/>

下载地址

静读天下：https://pan.baidu.com/s/1WjC_4PLG7-re9qfpOTSKSg?pwd=akak

提醒：本文发布于638天前，文中所关联的信息可能已发生改变，请知悉！

共计 1032 个字符，预计需要花费 3 分钟才能阅读完成。

清朝云之前觉得图床不是很必要，因为 wordpress 可以上传图片，并且临时图片可以上传到免费图床，然后通过 WP Githuber MD 自带的下载远程图片功能可以完美将所有的图片保存到自己服务器上，岂不美哉！

但是后来使用了一段时间发现插件下载的图片还是有点问题的，经常性没有图片后缀，而且清朝云习惯先在 vscode 中写的文章里面的图片链接也不会同步更新。

思来想去，还是决定自己用 lsky 搭建一个图床，数据库就简单实用 sqlite 就行，使用 docker-compose 搭建如下：

service:
  img:
    image: halcyonazure/lsky-pro-docker
    container_name: img
    restart: always
    ports:
      - 8101:8088
    environment:
      - HTTPS_PORT=8088
      - WEB_PORT=8089
    volumes:
      - /home/docker/img/html:/var/www/html

由于这里使用 nginx 反代并配置 https，所以这里只映射了 https 端口，根据自己实际情况进行修改。

接下来就是访问 web 页面进行安装即可，环境检测这里由于是 docker 安装肯定能通过，这里直接进行下一步。

/>

然后就是选择数据库，这里清朝云选 sqlite，选择其他数据库比如 mysql 也是可以的，不过选 sqlite 迁移比较方便一点。

/>

安装完成后就可以进入后台了，非常简单。

/>

上传图片可以返回 url 或者 markdown 等格式的链接。

/>

还支持创建多种存储策略，比如你的图片不想存在自己服务器上，你可以利用其他云厂商的对象存储功能，不过一般都要收费。

/>

其他的话可以根据自己需求调整设置，比如是否可以用户自行注册，限制用户存储容量等等。

并且兰空图床还提供了接口，也就是说可以自己开发一下插件，比如清朝云就开发了一个 vscode 上使用的图片上传插件，只需要复制图片右键运行命令就可以上传图片到图床，然后自动插入markdown 链接。

注意

如果使用 Nginx 反代并设置了 HTTPS 的话，会出现图片加载错误的情况，解决方案如下：

docker exec -it lsky \
sed -i '32 a \\\Illuminate\\Support\\Facades\\URL::forceScheme('"'"'https'"'"');' \
/var/www/html/app/Providers/AppServiceProvider.php

看作者回复是因为接口没有 https 的缘故。

提醒：本文发布于636天前，文中所关联的信息可能已发生改变，请知悉！

/>

共计 19591 个字符，预计需要花费 49 分钟才能阅读完成。

一、RabbitMQ 相关概念

RabbitMQ 整体上是一个生产者与消费者模型，主要负责接收、存储和转发消息。可以把消息传递的过程想象成：当你将一个包裹送到邮局，邮局会暂存并最终将邮件通过邮递员送到收件人的手上，RabbitMQ 就好比邮局、邮箱和邮递员组成的一个系统。从计算机术语层面来说，RabbitMQ 模型更像是一种交换机模型。

/>

1 生产者和消费者

Producer：生产者，投递消息的一方。

生产者创建消息，然后发布到RabbitMQ中。消息一般可以包含2个部分：消息体和标签(Label)。消息体也可以称之为payload，在实际应用中，消息体一般是一个带有业务逻辑结构的数据，比如一个JSON字符串。当然可以进一步对这个消息体进行序列化操作。消息的标签用来描述这条消息，比如一个交换器的名称和一个路由键。生产者把消息交由RabbitMQ，RabbitMQ之后会根据标签把消息发送给感兴趣的消费者(Consumer)。

Consumer：消费者， 接受消息的一方。

消费者连接到RabbitMQ服务器，并订阅到队列上。当消费者消费一条消息时，只是消费消息的消息体(payload)。在消息路由的过程中，消息的标签会丢弃，存入到队列中的消息只有消息体，消费者也只会消费消息体，也就不知道消息的生产者是谁，当然消费者也不需要知道。

Broker：消息中间件的服务节点。

对于RabbitMQ来说，一个RabbitMQ Broker可以简单地看做一个RabbitMQ服务节点，或者RabbitMQ服务实例。大多数情况下也可以将一个RabbitMQ Broker看做一台RabbitMQ服务器。

2 队列

Queue：队列，是 RabbitMQ 的内部对象，用于存储消息。

RabbitMQ 中消息都只能存储在队列中，这一点和Kafka这种消息中间件相反。Kafka 将消息存储在topic(主题)这个逻辑层面，而相对应的队列逻辑知识 topic 实际存储文件中的位移标识。RabbitMQ 的生产者生产消息并最终投递到队列中，消费者可以从队列中获取消息并消费。

多个消费者可以订阅同一个队列，这时队列中的消息会被平均分摊(Round-Robin，即轮询)给多个消费者进行处理，而不是每个消费者都收到所有的消息并处理。

RabbitMQ 不支持队列层面的广播消息，如果需要广播消费，需要在其上进行二次开发，处理逻辑会变得异常复杂，同时也不建议这么做。

3 交换器、路由键、绑定

Exchange：交换器。

生产者将消息发送到Exchange(交换器，通常也可以用大写的”X”来表示)，有交换器将消息路由到一个或者多个队列中。如果路由不到，或许会返回给生产者，或许直接丢弃。这里可以将 RabbitMQ 中的交换器看做一个简单的实体。

/>

交换器有四种类型，不同的类型有着不同的路由决策：

1）fanout

​ 它会把所有发送到该交换器的消息路由到所有与该交换器绑定的队列中。

2）direct

​ direct类型的交换器路由规则也很简单，它会把消息路由到那些BindingKey和RoutingKey完全匹配的队列中。

3）topic

​ 前面讲到direct类型的交换器路由规则是完全匹配BindingKey和RoutingKey，但是这种严格的匹配方式在很多情况下不能满足实际业务的需求。topic类型的交换器在匹配规则上进行了扩展，它与direct类型的交换器类似，也是将消息路由到BindingKey和RoutingKey想匹配的队列中，但这里的匹配规则有些不同，它约定如下：

• RoutingKey为一个点号“.”分割的字符串(被点号“.”分隔开的每一段独立的字符串称为一个单词),如“com.rabbitmq.client”、“java.util.concurrent”、“com.hidden.client”;
• BindingKey和RoutingKey一样也是点号“.”分隔的字符串；
• BindingKey中可以存在两种特殊字符串“*”和“#”，用于做模糊匹配，其中“*”用于匹配一个单词，“#”用于匹配多规则单词(可以是零个)。

4）headers

​ headers类型的交换器不依赖于路由键的匹配规则来路由消息，而是根据发送的消息内容中的headers属性进行匹配。在绑定队列和交换器时制定一组键值对，当发送消息到交换器时，RabbitMQ会获取到该消息的headers(也是一个键值对的形式)，对比其中的键值对是否完全匹配队列和交换器绑定时指定的键值对，如果完全匹配则消息会路由到该队列，否则不会路由到该队列。headers类型的交换器性能会很差，而且也不实用，基本上不会看到它的存在。

RoutingKey：路由键。

生产者将消息发给交换器的时候，一般会指定一个RoutingKey，用来指定这个消息的路由规则，而这个RoutingKey需要与交换器类型和绑定键(BindingKey)联合使用才能最终生效。

在交换器类型和绑定键(BindingKey)固定的情况下，生产者可以在发送消息给交换器时，通过指定RoutingKey来决定消息流向哪里。

Binding： 绑定。

RabbitMQ中通过绑定将交换器与队列联合起来，在绑定的时候一般会指定一个绑定键(BindingKey)，这样RabbitMQ就知道如何正确地将消息路由到队列了

/>

生产者将消息发送给交换器时，需要一个RoutingKey，当BindingKey和RoutingKey相匹配时，消息会被路由到对应的队列中。在绑定多个队列到同一个交换器的时候，这些绑定允许使用相同的BindingKey。BindingKey并不是在所有的情况下都生效，它依赖于交换器类型，比如fanout类型的交换器就会无视BindingKey，而是将消息路由到所有绑定该交换器的队列中。

二、RabbitMQ 运转流程

了解了以上的RabbitMQ架构模型及相关术语，再来回顾整个消息队列过程。

/>

在最初状态下，生产者发送消息的时候

（1）生产者连接到RabbitMQ Broker，建立一个连接(Connection)，开启一个信道(Channel)

（2）生产者声明一个交换器，并设置相关属性，比如交换器类型、是否持久化等

（3）生产者声明一个队列并设置相关属性，比如是否排他、是否持久化、是否自动删除等

（4）生产者通过路由键将交换器和队列绑定起来

（5）生产者发送消息至RabbitMQ Broker，其中包含路由键、交换器等信息

（6）相应的交换器根据接收到的路由键查找相匹配的队列。

（7）如果找到，则将从生产者发送过来的消息存入相应的队列。

（8）如果没有找到，则根据生产者配置的属性选择丢弃还是回退给生产者

（9）关闭信道

（10）关闭连接

消费者接收消息的过程：

（1）消费者连接到RabbitMQ Broker，建立一个连接(Connection)，开启一个信道(Channel)。

（2）消费者向RabbitMQ Broker请求消费相应队列中的消息，可能会设置相应的回调函数，以及做一些准备工作。

（3）等待RabbitMQ Broker回应并投递相应队列中队列的消息，消费者接收消息。

（4）消费者确认(ack)接收到的消息。

（5）RabbitMQ从队列中删除相应已经被确认的消息。

（6）关闭信道

（7）关闭连接

又引入了两个新的概念：Connection和Channel。我们知道无论是生产者还是消费者，都需要和RabbitMQ Broker建立连接，这个连接就是一条TCP连接，也就是Connection。一旦TCP连接建立起来，客户端紧接着可以创建一个AMQP信道(Channel)，每个信道都会被指派一个唯一的ID。信道是建立在Connection之上的虚拟连接，RabbitMQ处理的每条AMQP指令都是通过信道完成的。

/>

完全可以直接使用Connection就能完成信道的工作，为什么还要引入信道呢？试想这样一个场景，一个应用程序中有很多个线程需要从RabbitMQ中消费消息，或者生产消息，那么必然要建立很多个Connection，也就是许多个TCP连接。然后对于操作系统而言，建立和销毁TCP连接是非常昂贵的开销，如果遇到使用高峰，性能瓶颈也随之显现。RabbitMQ采用类似NIO(Non-blocking I/O)的做法，选择TCP连接复用，不仅可以减少性能开销，同时也便于管理。

每个线程把持一个信道，所以信道复用了Connection的TCP连接。同时RabbitMQ可以确保每个线程的私密性，就像拥有独立的连接一样。当每个信道的流量不是很大时，复用单一的Connection可以在产生性能瓶颈的情况下有效地节省TCP连接资源。但是当信道本身的流量很大时，这时候多个信道复用一个Connection就会产生性能瓶颈，进而使整体的流量被限制了。此时就需要开辟多个Connection，将这些信道均摊到这些Connection中，至于这些相关的调优策略需要根据业务自身的实际情况进行调节。

NIO，也称为非阻塞I/O，包含三大核心部分：Channel(信道)、Buffer(缓冲区)和Selector(选择器)。NIO基于Channel和Buffer进行操作，数据总是从信道读取数据到缓冲区中，或者从缓存区写入到信道中。Selector用于监听多个信道的事件(比如连接打开，数据到达等)。因此，单线程可以监听多个数据的信道。

三、RabbitMQ 安装

1 安装依赖

yum install -y make gcc gcc-c++ m4 openssl openssl-devel 
yum install -y ncurses-devel unixODBC unixODBC-devel java java-devel socat

2 安装 Erlang

Erlang RPM包下载地址：https://packagecloud.io/rabbitmq/erlang

下载成功后，到下载的文件资源目录执行以下命令：

yum localinstall erlang-22.3.4.10-1.el7.x86_64.rpm
# 安装成功后，可以以下运行命令来查看erl版本
erl -version

3 安装 RabbitMQ

RabbitMQ RPM包下载地址：https://github.com/rabbitmq/rabbitmq-server/releases

/>

下载完成后，你需要运行下面的命令来将key导入：

rpm --import https://www.rabbitmq.com/rabbitmq-release-signing-key.asc

安装：

yum localinstall rabbitmq-server-3.8.8-1.el7.noarch.rpm
# 命令启动 rabbitmq 服务器
systemctl start rabbitmq-server
# 添加 web 管理插件
rabbitmq-plugins enable rabbitmq_management

通过IP:端口(http://172.16.93.128:15672)的形式，就可以访问RabbitMQ的Web管理界面了。

4 初始操作

添加新用户，用户名为”root”，密码为”root” ：

rabbitmqctl add_user root root

为root用户设置所有权限：

rabbitmqctl set_permissions -p / root ".*" ".*" ".*"

设置用户为管理员角色：

rabbitmqctl set_user_tags root administratorxxxxxxxxxx 设置用户为管理员角色rabbitmqctl set_user_tags root administratorsh

默认情况下，访问RabbitMQ服务的用户名和密码都是”guest”,这个账户有限制，默认只能通过本地网络(如localhost)访问，远程网络访问受限，使用默认的用户 guest / guest （此也为管理员用户）登陆，会发现无法登陆，报错：User can only log in via localhost。那是因为默认是限制了guest用户只能在本机登陆，也就是只能登陆localhost:15672。所以在实现生产和消费消息之前，需要另外添加一个用户，并设置相应的访问权限

四、RabbitMQ 常用命令

1 服务启动与停止

# 启动
systemctl start rabbitmq-server
# 停止
systemctl stop rabbitmq-server
# 查看状态
systemctl status rabbitmq-server

2 插件管理

# 插件列表
rabbitmq-plugins list 
# 启动插件(XXX为插件名)
rabbitmq-plugins enable XXX
# 停用插件(XXX为插件名)
rabbitmq-plugins disable XXX

3 用户管理

# 添加用户
rabbitmqctl add_user username password
# 删除用户
rabbitmqctl delete_user username
# 修改密码
rabbitmqctl change_password username newpassword
# 设置用户角色
rabbitmqctl set_user_tags username tag
# 列出用户
rabbitmqctl list_users

4 权限管理

# 列出所有用户权限
rabbitmqctl list_permissions
# 查看指定用户权限
rabbitmqctl list_user_permissions username
# 清除用户权限
rabbitmqctl clear_permissions [-p vhostpath] username
# 设置用户权限
rabbitmqctl set_permissions [-p vhostpath] username conf write read
    conf: 一个正则匹配哪些资源能被该用户访问
    write:一个正则匹配哪些资源能被该用户写入
    read: 一个正则匹配哪些资源能被该用户读取

五、RabbitMQ 基本使用

准备工作，实现获取连接的工具类：

public class ConnectionUtil {

    public static Connection getConnection() throws Exception {
        //定义连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置服务地址
        factory.setHost("localhost");
        //端口
        factory.setPort(5672);
        //设置账号信息，用户名、密码、vhost
        factory.setVirtualHost("/");
        factory.setUsername("admin");
        factory.setPassword("admin");
        // 通过工程获取连接
        Connection connection = factory.newConnection();
        return connection;
    }
}

1 简单模式

/>

直接发送到队列，只有一个消费者，最简单的模式。

public class Send {
    // 创建队列，发送消息
    public static void main(String[] args) throws Exception {
        // 获取连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建通道
        Channel channel = connection.createChannel();
        // 声明创建队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        // 消息内容
        String message = "Hello World!";
        channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
        System.out.println("发送消息："+message);
        //关闭连接和通道
        channel.close();
        connection.close();
    }
}

public class Recv{
    // 消费者消费消息
    public static void main(String[] args) throws Exception {
        // 获取连接和通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        // 声明通道
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        // 定义消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 监听队列
        channel.basicConsume(QUEUE_NAME,true,consumer);

        while(true){
            //这个方法会阻塞住，直到获取到消息
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println("接收到消息："+message);
        }
    }
}

2 work模式

/>

和简单模式类似，也是直接发送到队列，不同的是有多个消费者，消息将轮流发送给消费者进行消费。

public class Send{
    //消息生产者 
    public static void main(String[] args) throws Exception {
        //获取连接和通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        String message = "";
        for(int i = 0; i<100; i++){
            message = "" + i;
            channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
            System.out.println("发送消息："+message);
            Thread.sleep(i);
        }

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

// 消费者1
public class Recv1 {
    //消费者
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //同一时刻服务器只发送一条消息给消费端
        channel.basicQos(1);

        QueueingConsumer consumer = new QueueingConsumer(channel);

        channel.basicConsume(QUEUE_NAME,false,consumer);

        while(true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println("recive1:"+message);
            Thread.sleep(100);
            //消息消费完给服务器返回确认状态，表示该消息已被消费
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        }
    }
}
// 消费者2
public class Recv2 {
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        channel.basicQos(1);

        QueueingConsumer consumer = new QueueingConsumer(channel);

        channel.basicConsume(QUEUE_NAME,true,consumer);

        while(true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println("recive1:"+message);
            Thread.sleep(10);
            //channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        }
    }
}

消息消费的两种模式：

1、 自动模式

消费者从消息队列获取消息后，服务端就认为该消息已经成功消费。（可能会导致处理异常就移除消息的情况）

        // 监听队列，false表示手动返回完成状态，true表示自动        
        channel.basicConsume(QUEUE_NAME,true,consumer);
        while(true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println("recive1:"+message);
            Thread.sleep(10);
            //无需反馈
            //channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        }

2、 手动模式

消费者从消息队列获取消息后，服务端并没有标记为成功消费
​ 消费者成功消费后需要将状态返回到服务端

        // 监听队列，false表示手动返回完成状态，true表示自动
        channel.basicConsume(QUEUE_NAME,false,consumer);
        while(true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println("recive1:"+message);
            Thread.sleep(100);
            //消息消费完给服务器返回确认状态，表示该消息已被消费
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        }

3 订阅模式

/>

一个生产者发送的消息会被多个消费者获取。

生产者：可以将消息发送到队列或者是交换机。

消费者：只能从队列中获取消息。

如果消息发送到没有队列绑定的交换机上，那么消息将丢失。

每个发到 fanout 类型交换器的消息都会分到所有绑定的队列上去。 fanout 交换器不处理路由键，只是简单的将队列绑定到交换器上，每个发送到交换器的消息都会被转发到与该交换器绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。 fanout 类型转发消息是最快的 。

消息发送到交换机，因为不处理路由键，所以所有与该交换机绑定的队列都将收到消息。

public class Send {
    public static final String EXCHANGE_NAME = "test_exchange_fanout";
    // 生产者，发送消息到交换机
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        // 声明交换机 fanout：交换机类型 主要有fanout,direct,topics三种
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");

        String message = "Hello World!";
        channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes());
        System.out.println(message);
        channel.close();
        connection.close();
    }
}

// 消费者1
public class Recv1 {
    public static final String EXCHANGE_NAME = "test_exchange_fanout";
    public final static String QUEUE_NAME = "test_queue_exchange_1";
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        // 绑定队列到交换机上
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");
        channel.basicQos(1);
        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME,true,consumer);
        while(true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(message);
        }
    }
}
// 消费者2
public class Recv2 {
    public static final String EXCHANGE_NAME = "test_exchange_fanout";
    public final static String QUEUE_NAME = "test_queue_exchange_2";
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        // 绑定队列到交换机上
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");
        channel.basicQos(1);
        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME,true,consumer);

        while(true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(message);
        }
    }
}

4 路由模式

/>

1、 发送消息到交换机时，要指定路由key

2、 消费者将队列绑定到交换机时，需要指定路由key

一种完全匹配，只有匹配到的消费者才能消费消息

消息中的路由键（ routing key）如果和 Binding 中的 binding key 一致， 交换器就将消息发到对应的队列中。路由键与队列名完全匹配，如果一个队列绑定到交换机要求路由键为“ dog”，则只转发 routing key 标记为“ dog”的消息，不会转发“ dog.puppy”，也不会转发“ dog.guard”等等。它是完全匹配、单播的模式。

消息发送到交换机，所有 binding key 与 routing key 一致的队列将收到消息，从而让消费者消费。说白了是生产者有目的的发送消息。

public class Send {
    public static final String EXCHANGE_NAME = "test_exchange_direct";
    //生产者
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        //声明交换机 fanout：交换机类型 主要有fanout,direct,topics三种
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");

        String message = "Hello World!";
        channel.basicPublish(EXCHANGE_NAME,"dog",null,message.getBytes());
        System.out.println(message);
        channel.close();
        connection.close();
    }
}

// 消费者1
public class Recv1 {
    public static final String EXCHANGE_NAME = "test_exchange_direct";
    public final static String QUEUE_NAME = "test_queue_direct_1";
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        // 绑定队列到交换机上,并制定路由键为"dog"
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME,"dog");
        channel.basicQos(1);
        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME,true,consumer);
        while(true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(message);
        }
    }
}
// 消费者2
public class Recv2 {
    public static final String EXCHANGE_NAME = "test_exchange_direct";
    public final static String QUEUE_NAME = "test_queue_direct_2";
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        // 绑定队列到交换机上,并制定路由键为"cat"
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME,"cat");
        channel.basicQos(1);
        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME,true,consumer);
        while(true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(message);
        }
    }
}

5 通配符模式

/>

topic交换器通过模式匹配分配消息的路由键属性，将路由键和某个模式进行匹配，此时队列需要绑定到一个模式上。它将路由键和绑定键的字符串切分成单词，这些单词之间用点隔开。它同样也会识别两个通配符：符号“#”和符号“*”。#匹配0个或多个单词，*匹配一个单词。如下图所示：

/>

消息发送到交换机，类似路由模式，只是这里变成了可以通配符匹配，更方便进行分配。

// 生产者
public class Send {
    public static final String EXCHANGE_NAME = "test_exchange_topic";
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        //声明交换机 topic：交换机类型 
        channel.exchangeDeclare(EXCHANGE_NAME,"topic");
        String message = "Hello World!";
        channel.basicPublish(EXCHANGE_NAME,"dog.1",null,message.getBytes());
        System.out.println(message);
        channel.close();
        connection.close();
    }
}

// 消费者1
public class Recv1 {
    public static final String EXCHANGE_NAME = "test_exchange_topic";
    public final static String QUEUE_NAME = "test_queue_direct_1";
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //绑定队列到交换机上,并制定路由键为"dog"
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME,"dog");
        channel.basicQos(1);
        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME,true,consumer);
        while(true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(message);
        }
    }
}
// 消费者2
public class Recv2 {
    public static final String EXCHANGE_NAME = "test_exchange_topic";
    public final static String QUEUE_NAME = "test_queue_topic_2";
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //绑定队列到交换机上,并制定路由键匹配规则为"#.1"
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME,"#.1");
        channel.basicQos(1);
        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME,true,consumer);

        while(true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(message);
        }
    }
}
// 消费者3
public class Recv3 {
    public static final String EXCHANGE_NAME = "test_exchange_topic";
    public final static String QUEUE_NAME = "test_queue_topic_3";
    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //绑定队列到交换机上,并制定路由键匹配规则为"cat.#"
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME,"cat.#");
        channel.basicQos(1);
        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME,true,consumer);

        while(true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(message);
        }
    }
}

结果：消费者1和消费者2可以收到消息，消费者3不能收到消息。

六、RabbitMQ 整合 SpringBoot

1 新建 SpringBoot 项目

pop.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.rabbit</groupId>
    <artifactId>springboot</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.78</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.properties 文件：

## 端口号
server.port=8080
## rabbitmq
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

2 新建 RabbitMQConfig

@Configuration
public class RabbitMQConfig {

    // 测试队列名称
    private String testQueueName = "test_queue";
    // 测试交换机名称
    private String testExchangeName = "test_exchange";
    // RoutingKey
    private String testRoutingKey = "test_routing_key";

    /** 创建队列 */
    @Bean
    public Queue testQueue() {
        return new Queue(testQueueName);
    }
    /** 创建交换机 */
    @Bean
    public TopicExchange testExchange() {
        return new TopicExchange(testExchangeName);
    }
    /** 通过routingKey把队列与交换机绑定起来 */
    @Bean
    public Binding testBinding() {
        return BindingBuilder.bind(testQueue()).to(testExchange()).with(testRoutingKey);
    }
}

3 创建生产者

@Component
public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(String queueName) {
        public void send(String queueName) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("email", "1532246395@qq.com");
        jsonObject.put("timestamp", System.currentTimeMillis());
        String jsonString = jsonObject.toJSONString();
        rabbitTemplate.convertAndSend(queueName, jsonString);
    }
}

4 创建消费者

@Component
@RabbitListener(queues = "OneByOne")
public class Consumer {

    @RabbitListener(queues = "test_queue")
    public void consumeMessage(Message message) throws Exception{
        String msg = new String(message.getBody(), "UTF-8");
        JSONObject jsonObject = JSONObject.parseObject(msg);
        System.out.println("消费消息：" + jsonObject);
    }
}

5 编写controller测试

@RestController
public class ProducerController {
    @Autowired
    private Producer producer;

    @RequestMapping("/sendMsg")
    public String sendFanout() {
        producer.send("test_queue");
        return "success";
    }
}

浏览器访问 http://localhost:8080/sendMsg，结果：

消费消息：{“email”:”1532246395@qq.com”,”timestamp”:1629766485289}

提醒：本文发布于635天前，文中所关联的信息可能已发生改变，请知悉！

共计 337 个字符，预计需要花费 1 分钟才能阅读完成。

现在很多中间件都提供了 Docker 容器运行的方式，这样大大降低了初学者的学习成本，提高了效率。

Rabbitmq 也不例外，今天介绍一下如何用 docker 安装，其实也比较简单。

docker run -d \
--name rabbitmq \
-p 15672:15672 \
-p 5672:5672 \
--hostname rabbitmq \
--restart always \
rabbitmq:3.9.8

此时 rabbitmq 虽然已经可以使用了，但是还不能使用图形界面进行管理，还需要开启图形界面的插件。

docker exec -it rabbitmq rabbitmq-plugins enable rabbitmq_management

这样就可以访问 15672 端口进行访问，默认账号密码：guest/guest。

提醒：本文发布于635天前，文中所关联的信息可能已发生改变，请知悉！

/>

共计 23677 个字符，预计需要花费 60 分钟才能阅读完成。

一、简介和安装

ElasticSearch 是一个基于 Lucene 的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于 RESTful web 接口。

这里使用 Docker 安装 Elasticsearch：

docker run -d \
--name elasticsearch \
-p 9200:9200 \
-p 9300:9300 \
-e "discovery.type=single-node" \
-v /home/docker/es/plugins:/usr/share/elasticsearch/plugins \
-v /home/docker/es/data:/usr/share/elasticsearch/data \
--restart always \
elasticsearch:7.14.2

如果启动报错，执行 chmod 777 /home/docker/es/data

访问 9200 端口，能够看见如下信息则表示搭建成功。

/>

二、相关概念

• 索引(Index)： ES将数据存储于一个或多个索引中，索引是具有类似特性的文档的集合。类比传统的关系型数据库领域来说，索引相当于SQL中的一个数据库，或者一个数据存储方案(schema)。索引由其名称(必须为全小写字符)进行标识，并通过引用此名称完成文档的创建、搜索、更新及删除操作。一个ES集群中可以按需创建任意数目的索引。

• 类型(Type)：类型是索引内部的逻辑分区(category/partition)，然而其意义完全取决于用户需求。因此，一个索引内部可定义一个或多个类型(type)。一般来说，类型就是为那些拥有相同的域的文档做的预定义。例如，在索引中，可以定义一个用于存储用户数据的类型，一个存储日志数据的类型，以及一个存储评论数据的类型。类比传统的关系型数据库领域来说，类型相当于“表”。

• 文档(Document)：文档是Lucene索引和搜索的原子单位，它是包含了一个或多个域的容器，基于JSON格式进行表示。文档由一个或多个域组成，每个域拥有一个名字及一个或多个值，有多个值的域通常称为“多值域”。每个文档可以存储不同的域集，但同一类型下的文档至应该有某种程度上的相似之处。

• 映射(Mapping)： ES中，所有的文档在存储之前都要首先进行分析。用户可根据需要定义如何将文本分割成token、哪些token应该被过滤掉，以及哪些文本需要进行额外处理等等。另外，ES还提供了额外功能，例如将域中的内容按需排序。事实上，ES也能自动根据其值确定域的类型。

• 节点(Node)：运行了单个实例的ES主机称为节点，它是集群的一个成员，可以存储数据、参与集群索引及搜索操作。类似于集群，节点靠其名称进行标识，默认为启动时自动生成的随机Marvel字符名称。用户可以按需要自定义任何希望使用的名称，但出于管理的目的，此名称应该尽可能有较好的识别性。节点通过为其配置的ES集群名称确定其所要加入的集群。

• 分片(Shard)和副本(Replica)：ES的“分片(shard)”机制可将一个索引内部的数据分布地存储于多个节点，它通过将一个索引切分为多个底层物理的Lucene索引完成索引数据的分割存储功能，这每一个物理的Lucene索引称为一个分片(shard)。每个分片其内部都是一个全功能且独立的索引，因此可由集群中的任何主机存储。创建索引时，用户可指定其分片的数量，默认数量为5个。

三、基本使用

1、基础

1.1 索引

1.1.1 创建索引

PUT http://127.0.0.1:9200/sj

{
    "acknowledged": true,
    "shards_acknowledged": true,
    "index": "sj"
}

1.1.2 查看所有索引

GET http://127.0.0.1:9200/_cat/indices

green  open .geoip_databases                69SccWg_Qy-WcYTahh-x7g 1 0   46    7  48.2mb  48.2mb
yellow open bank                            p1ZJWKzLSL2yPe_NfhED5w 1 1 1000    0 372.7kb 372.7kb
green  open .apm-custom-link                sfwTjQZjTMy7QZgQfR-0Zg 1 0    0    0    208b    208b
yellow open my_index                        a_wq-ITURwCCxxa5TCQgAA 1 1    0    0    208b    208b
green  open .kibana_task_manager_7.14.2_001 zi4N4a88S5uJC3JDjRvu7A 1 0   14 2758 474.9kb 474.9kb
yellow open sj                              Frku6z9qQ-ih4cNV-CcyiQ 1 1    1    2  17.7kb  17.7kb
green  open .apm-agent-configuration        cv7NcBeERa-ZwoRuXEgbgQ 1 0    0    0    208b    208b
green  open .kibana_7.14.2_001              2qIDo8JJSGuJj7DdBOYzAg 1 0   44    1   2.3mb   2.3mb
yellow open 2sj                             xAc5JA7WSD-YSGei6RhDaQ 1 1    0    0    208b    208b
yellow open index                           WvnJ6OIRQ2GGewXderW0ew 1 1    4    0    16kb    16kb
green  open .tasks                          sn8q8od2QNC9rujgg51RGQ 1 0    8    0  36.6kb  36.6kb
green  open .kibana-event-log-7.14.2-000001 7_Wq_AiMRjemTW3nOOSD2g 1 0    5    0  27.3kb  27.3kb

1.1.3 删除索引

DELETE http://127.0.0.1:9200/sj

{
    "acknowledged": true
}

1.2 文档

1.2.1 创建文档

POST http://127.0.0.1:9200/sj/sj/1001
{
    "title": "小米手机",
    "catagory": "xiaomi",
    "images": "www.baidu.com",
    "price": 8999
}

{
    "_index": "sj",
    "_type": "sj",
    "_id": "1001",
    "_version": 2,
    "result": "updated",
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 1,
    "_primary_term": 9
}

1.2.2 查询单个文档

GET http://127.0.0.1:9200/sj/sj/1001

{
    "_index": "sj",
    "_type": "sj",
    "_id": "1001",
    "_version": 2,
    "_seq_no": 1,
    "_primary_term": 9,
    "found": true,
    "_source": {
        "title": "小米手机",
        "catagory": "xiaomi",
        "images": "www.baidu.com",
        "price": 8999
    }
}

1.2.3 查询单个索引下所有文档

GET http://127.0.0.1:9200/sj/_search

{
    "took": 2,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1,
            "relation": "eq"
        },
        "max_score": 1.0,
        "hits": [
            {
                "_index": "sj",
                "_type": "sj",
                "_id": "1001",
                "_score": 1.0,
                "_source": {
                    "title": "小米手机",
                    "catagory": "xiaomi",
                    "images": "www.baidu.com",
                    "price": 8999
                }
            }
        ]
    }
}

1.2.4 局部更新文档

POST http://127.0.0.1:9200/sj/sj/1001/_update
{
    "doc": {
        "title": "华为手机"
    }
}

{
    "_index": "sj",
    "_type": "sj",
    "_id": "1001",
    "_version": 3,
    "result": "updated",
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 2,
    "_primary_term": 9
}

再次查询结果：

{
    "_index": "sj",
    "_type": "sj",
    "_id": "1001",
    "_version": 3,
    "_seq_no": 2,
    "_primary_term": 9,
    "found": true,
    "_source": {
        "title": "华为手机",
        "catagory": "xiaomi",
        "images": "www.baidu.com",
        "price": 8999
    }
}

1.2.5 完全覆盖更新

POST http://127.0.0.1:9200/sj/sj/1001
{
    "title": "锤子手机"
}

{
    "_index": "sj",
    "_type": "sj",
    "_id": "1001",
    "_version": 4,
    "result": "updated",
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 3,
    "_primary_term": 9
}

再次查询结果：

{
    "_index": "sj",
    "_type": "sj",
    "_id": "1001",
    "_version": 4,
    "_seq_no": 3,
    "_primary_term": 9,
    "found": true,
    "_source": {
        "title": "锤子手机"
    }
}

1.2.6 删除文档

DELETE http://127.0.0.1:9200/sj/sj/1001

{
    "_index": "sj",
    "_type": "sj",
    "_id": "1001",
    "_version": 5,
    "result": "deleted",
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 4,
    "_primary_term": 9
}

2、进阶

2.1 批量操作

2.1.1 批量创建

POST http://127.0.0.1:9200/sj/sj/_bulk
{"index":{"_id":"11"}}
{"price":10,"productID":"华为"}
{"index":{"_id":"12"}}
{"price":20,"productID":"小米"}
{"index":{"_id":"13"}}
{"price":30,"productID":"oppo"}
{"index":{"_id":"14"}}
{"price":40,"productID":"vivo"}

{
    "took": 654,
    "errors": false,
    "items": [
        {
            "index": {
                "_index": "sj",
                "_type": "sj",
                "_id": "11",
                "_version": 1,
                "result": "created",
                "_shards": {
                    "total": 2,
                    "successful": 1,
                    "failed": 0
                },
                "_seq_no": 5,
                "_primary_term": 9,
                "status": 201
            }
        },
        {
            "index": {
                "_index": "sj",
                "_type": "sj",
                "_id": "12",
                "_version": 1,
                "result": "created",
                "_shards": {
                    "total": 2,
                    "successful": 1,
                    "failed": 0
                },
                "_seq_no": 6,
                "_primary_term": 9,
                "status": 201
            }
        },
        {
            "index": {
                "_index": "sj",
                "_type": "sj",
                "_id": "13",
                "_version": 1,
                "result": "created",
                "_shards": {
                    "total": 2,
                    "successful": 1,
                    "failed": 0
                },
                "_seq_no": 7,
                "_primary_term": 9,
                "status": 201
            }
        },
        {
            "index": {
                "_index": "sj",
                "_type": "sj",
                "_id": "14",
                "_version": 1,
                "result": "created",
                "_shards": {
                    "total": 2,
                    "successful": 1,
                    "failed": 0
                },
                "_seq_no": 8,
                "_primary_term": 9,
                "status": 201
            }
        }
    ]
}

2.1.2 批量增删改

POST http://127.0.0.1:9200/sj/sj/_bulk
{"delete":{"_index":"sj","_type":"sj","_id":"11"}}
{"create":{"_index":"sj","_type":"sj","_id":"10"}}
{"price":50,"productID":"1115"}
{"index":{"_index":"sj","_type":"sj","_id":"16"}}
{"price":60,"productID":"1116"}
{"update":{"_index":"sj","_type":"sj","_id":"12"}}
{"doc": {"price":120,"productID":"11120"}}

{
    "took": 141,
    "errors": false,
    "items": [
        {
            "index": {
                "_index": "sj",
                "_type": "sj",
                "_id": "11",
                "_version": 2,
                "result": "updated",
                "_shards": {
                    "total": 2,
                    "successful": 1,
                    "failed": 0
                },
                "_seq_no": 9,
                "_primary_term": 9,
                "status": 200
            }
        },
        {
            "index": {
                "_index": "sj",
                "_type": "sj",
                "_id": "12",
                "_version": 2,
                "result": "updated",
                "_shards": {
                    "total": 2,
                    "successful": 1,
                    "failed": 0
                },
                "_seq_no": 10,
                "_primary_term": 9,
                "status": 200
            }
        },
        {
            "index": {
                "_index": "sj",
                "_type": "sj",
                "_id": "13",
                "_version": 2,
                "result": "updated",
                "_shards": {
                    "total": 2,
                    "successful": 1,
                    "failed": 0
                },
                "_seq_no": 11,
                "_primary_term": 9,
                "status": 200
            }
        },
        {
            "index": {
                "_index": "sj",
                "_type": "sj",
                "_id": "14",
                "_version": 2,
                "result": "updated",
                "_shards": {
                    "total": 2,
                    "successful": 1,
                    "failed": 0
                },
                "_seq_no": 12,
                "_primary_term": 9,
                "status": 200
            }
        }
    ]
}

2.2 普通查询

2.2.1 数据导入

POST http://127.0.0.1:9200/bank/account/_bulk
... (es 官方测试数据，可以 github 中找到)

{
    "took": 2450,
    "errors": false,
    ...
}

2.2.2 分页查询

GET http://127.0.0.1:9200/bank/_search
{
    "query":{
        "match_all": {}
    },
    "from": 0,
    "size": 2
}

{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1000,
            "relation": "eq"
        },
        "max_score": 1.0,
        "hits": [
            {
                "_index": "bank",
                "_type": "account",
                "_id": "1",
                "_score": 1.0,
                "_source": {
                    "account_number": 1,
                    "balance": 39225,
                    "firstname": "Amber",
                    "lastname": "Duke",
                    "age": 32,
                    "gender": "M",
                    "address": "880 Holmes Lane",
                    "employer": "Pyrami",
                    "email": "amberduke@pyrami.com",
                    "city": "Brogan",
                    "state": "IL"
                }
            },
            {
                "_index": "bank",
                "_type": "account",
                "_id": "6",
                "_score": 1.0,
                "_source": {
                    "account_number": 6,
                    "balance": 5686,
                    "firstname": "Hattie",
                    "lastname": "Bond",
                    "age": 36,
                    "gender": "M",
                    "address": "671 Bristol Street",
                    "employer": "Netagy",
                    "email": "hattiebond@netagy.com",
                    "city": "Dante",
                    "state": "TN"
                }
            }
        ]
    }
}

2.2.3 返回部分字段

POST http://127.0.0.1:9200/bank/_search
{
    "query":{
        "match_all":{}
    },
    "sort":[
        {
          "balance": {
            "order": "desc"
          }  
        }
    ],
    "from": 0,
    "size": 2,
    "_source": [
        "firstname",
        "lastname",
        "city",
        "age"
    ]
}

{
    "took": 2,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1000,
            "relation": "eq"
        },
        "max_score": null,
        "hits": [
            {
                "_index": "bank",
                "_type": "account",
                "_id": "248",
                "_score": null,
                "_source": {
                    "firstname": "West",
                    "city": "Maury",
                    "age": 36,
                    "lastname": "England"
                },
                "sort": [
                    49989
                ]
            },
            {
                "_index": "bank",
                "_type": "account",
                "_id": "854",
                "_score": null,
                "_source": {
                    "firstname": "Jimenez",
                    "city": "Moscow",
                    "age": 25,
                    "lastname": "Barry"
                },
                "sort": [
                    49795
                ]
            }
        ]
    }
}

2.2.4 数值等值匹配

对于数值，只查询等值匹配的数据

GET http://127.0.0.1:9200/bank/_search
{
    "query":{
        "match":{
            "account_number": 20
        }
    }
}

{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1,
            "relation": "eq"
        },
        "max_score": 1.0,
        "hits": [
            {
                "_index": "bank",
                "_type": "account",
                "_id": "20",
                "_score": 1.0,
                "_source": {
                    "account_number": 20,
                    "balance": 16418,
                    "firstname": "Elinor",
                    "lastname": "Ratliff",
                    "age": 36,
                    "gender": "M",
                    "address": "282 Kings Place",
                    "employer": "Scentric",
                    "email": "elinorratliff@scentric.com",
                    "city": "Ribera",
                    "state": "WA"
                }
            }
        ]
    }
}

2.2.5 字符串模糊匹配

将匹配类似的数据

GET http://127.0.0.1:9200/bank/_search
{
    "query":{
        "match":{
            "address": "mill lane foajfoaofjja"
        }
    }
}

{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    ...
}

2.2.6 短语匹配

不拆分关键字，当作一个整体

GET http://127.0.0.1:9200/bank/_search
{
    "query":{
        "match_phrase":{
            "address": "mill lane"
        }
    }
}

{
    "took": 6,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1,
            "relation": "eq"
        },
        "max_score": 9.507477,
        "hits": [
            {
                "_index": "bank",
                "_type": "account",
                "_id": "136",
                "_score": 9.507477,
                "_source": {
                    "account_number": 136,
                    "balance": 45801,
                    "firstname": "Winnie",
                    "lastname": "Holland",
                    "age": 38,
                    "gender": "M",
                    "address": "198 Mill Lane",
                    "employer": "Neteria",
                    "email": "winnieholland@neteria.com",
                    "city": "Urie",
                    "state": "IL"
                }
            }
        ]
    }
}

2.2.7 多字段匹配

GET http://127.0.0.1:9200/bank/_search
{
    "query":{
        "multi_match":{
            "query": "mill Movico",
            "fields": ["address", "city"]
        }
    }
}

{
    "took": 5,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 4,
            "relation": "eq"
        },
        "max_score": 6.5059485,
        "hits": [
            {
                "_index": "bank",
                "_type": "account",
                "_id": "472",
                "_score": 6.5059485,
                "_source": {
                    "account_number": 472,
                    "balance": 25571,
                    "firstname": "Lee",
                    "lastname": "Long",
                    "age": 32,
                    "gender": "F",
                    "address": "288 Mill Street",
                    "employer": "Comverges",
                    "email": "leelong@comverges.com",
                    "city": "Movico",
                    "state": "MT"
                }
            },
            {
                "_index": "bank",
                "_type": "account",
                "_id": "970",
                "_score": 5.4032025,
                "_source": {
                    "account_number": 970,
                    "balance": 19648,
                    "firstname": "Forbes",
                    "lastname": "Wallace",
                    "age": 28,
                    "gender": "M",
                    "address": "990 Mill Road",
                    "employer": "Pheast",
                    "email": "forbeswallace@pheast.com",
                    "city": "Lopezo",
                    "state": "AK"
                }
            },
            {
                "_index": "bank",
                "_type": "account",
                "_id": "136",
                "_score": 5.4032025,
                "_source": {
                    "account_number": 136,
                    "balance": 45801,
                    "firstname": "Winnie",
                    "lastname": "Holland",
                    "age": 38,
                    "gender": "M",
                    "address": "198 Mill Lane",
                    "employer": "Neteria",
                    "email": "winnieholland@neteria.com",
                    "city": "Urie",
                    "state": "IL"
                }
            },
            {
                "_index": "bank",
                "_type": "account",
                "_id": "345",
                "_score": 5.4032025,
                "_source": {
                    "account_number": 345,
                    "balance": 9812,
                    "firstname": "Parker",
                    "lastname": "Hines",
                    "age": 38,
                    "gender": "M",
                    "address": "715 Mill Avenue",
                    "employer": "Baluba",
                    "email": "parkerhines@baluba.com",
                    "city": "Blackgum",
                    "state": "KY"
                }
            }
        ]
    }
}

2.2.8 复合查询

GET http://127.0.0.1:9200/bank/_search
{
    "query":{
        "bool":{
            "must":[
                {"match": {
                    "gender": "M"
                }},
                {"match": {
                    "address": "mill"
                }}
            ],
            "must_not":[
               {
                   "match":{
                       "age": 28
                   }
               }
            ],
            "should":[
                {"match": {
                    "lastname": "Wallace"
                }}
            ]
        }
    }
}

{
    "took": 6,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 2,
            "relation": "eq"
        },
        "max_score": 6.0824604,
        "hits": [
            {
                "_index": "bank",
                "_type": "account",
                "_id": "136",
                "_score": 6.0824604,
                "_source": {
                    "account_number": 136,
                    "balance": 45801,
                    "firstname": "Winnie",
                    "lastname": "Holland",
                    "age": 38,
                    "gender": "M",
                    "address": "198 Mill Lane",
                    "employer": "Neteria",
                    "email": "winnieholland@neteria.com",
                    "city": "Urie",
                    "state": "IL"
                }
            },
            {
                "_index": "bank",
                "_type": "account",
                "_id": "345",
                "_score": 6.0824604,
                "_source": {
                    "account_number": 345,
                    "balance": 9812,
                    "firstname": "Parker",
                    "lastname": "Hines",
                    "age": 38,
                    "gender": "M",
                    "address": "715 Mill Avenue",
                    "employer": "Baluba",
                    "email": "parkerhines@baluba.com",
                    "city": "Blackgum",
                    "state": "KY"
                }
            }
        ]
    }
}

2.2.9 过滤

must should会贡献相关性得分，filter 不参与

POST http://127.0.0.1:9200/bank/_search
{
    "query":{
        "bool":{
            "must":[
                {"match": {
                    "gender": "M"
                }},
                {"match": {
                    "address": "mill"
                }}
            ],
            "must_not":[
               {
                   "match":{
                       "age": 28
                   }
               }
            ],
            "should":[
                {"match": {
                    "lastname": "Wallace"
                }}
            ],
            "filter":[
                {"range":{
                    "age":{
                        "gte": 18,
                        "lte": 40
                    }
                }}
            ]
        }
    }
}

{
    "took": 2,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 2,
            "relation": "eq"
        },
        "max_score": 6.0824604,
        "hits": [
            {
                "_index": "bank",
                "_type": "account",
                "_id": "136",
                "_score": 6.0824604,
                "_source": {
                    "account_number": 136,
                    "balance": 45801,
                    "firstname": "Winnie",
                    "lastname": "Holland",
                    "age": 38,
                    "gender": "M",
                    "address": "198 Mill Lane",
                    "employer": "Neteria",
                    "email": "winnieholland@neteria.com",
                    "city": "Urie",
                    "state": "IL"
                }
            },
            {
                "_index": "bank",
                "_type": "account",
                "_id": "345",
                "_score": 6.0824604,
                "_source": {
                    "account_number": 345,
                    "balance": 9812,
                    "firstname": "Parker",
                    "lastname": "Hines",
                    "age": 38,
                    "gender": "M",
                    "address": "715 Mill Avenue",
                    "employer": "Baluba",
                    "email": "parkerhines@baluba.com",
                    "city": "Blackgum",
                    "state": "KY"
                }
            }
        ]
    }
}

2.2.10 term

和match类似，推荐：找精确字段使用term，找文本字段使用match

GET http://127.0.0.1:9200/bank/_search
{
    "query":{
        "term":{
            "account_number": 20
        }
    }
}

2.3 聚合查询

2.3.1 聚合一

搜索 address中包含mill的所有人的年龄分布以及平均年龄

GET http://127.0.0.1:9200/bank/_search
{
    "query":{
        "match":{
            "address": "mill"
        }
    },
    "aggs": {
        "ageAgg": {
            "terms":{
                "field": "age",
                "size": 10
            }
        },
        "ageAvg": {
             "avg": {
                 "field": "age"
             }
        },
        "balanceAvg": {
            "avg": {
                "field": "balance"
            }
        }
    },
    "size": 0
}

{
    "took": 2,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 4,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "ageAgg": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": 38,
                    "doc_count": 2
                },
                {
                    "key": 28,
                    "doc_count": 1
                },
                {
                    "key": 32,
                    "doc_count": 1
                }
            ]
        },
        "ageAvg": {
            "value": 34.0
        },
        "balanceAvg": {
            "value": 25208.0
        }
    }
}

2.3.2 聚合二

按照年龄聚合，并且请求这些年龄段的这些人的平均薪资

GET http://127.0.0.1:9200/bank/_search
{
    "query":{
        "match_all": {}
    },
    "aggs": {
        "ageAgg": {
            "terms": {
                "field": "age",
                "size": 100
            },
            "aggs": {
                "ageAvg": {
                    "avg": {
                        "field": "balance"
                    }
                }
            }
        }
    },
    "size": 0
}

{
    "query":{
        "match_all": {}
    },
    "aggs": {
        "ageAgg": {
            "terms": {
                "field": "age",
                "size": 100
            },
            "aggs": {
                "ageAvg": {
                    "avg": {
                        "field": "balance"
                    }
                }
            }
        }
    },
    "size": 0
}

2.3.3 聚合三

查出所有年龄分布，并且这些年龄段中M的平均薪资和F的平均薪资以及这个年龄段的总体平均薪资

GET http://127.0.0.1:9200/bank/_search
{
    "query":{
        "match_all": {}
    },
    "aggs": {
        "ageAgg": {
            "terms": {
                "field": "age",
                "size": 100
            },
            "aggs": {
                "genderAgg": {
                    "terms": {
                        "field": "gender.keyword"
                    },
                    "aggs": {
                        "balanceAvg": {
                            "avg": {
                                "field": "balance"
                            }
                        }
                    }
                },
                "balanceAvg": {
                    "avg": {
                        "field": "balance"
                    }
                }
            }
        }
    },
    "size": 0

}

{
    "took": 7,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1000,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "ageAgg": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": 31,
                    "doc_count": 61,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "M",
                                "doc_count": 35,
                                "balanceAvg": {
                                    "value": 29565.628571428573
                                }
                            },
                            {
                                "key": "F",
                                "doc_count": 26,
                                "balanceAvg": {
                                    "value": 26626.576923076922
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 28312.918032786885
                    }
                },
                {
                    "key": 39,
                    "doc_count": 60,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "F",
                                "doc_count": 38,
                                "balanceAvg": {
                                    "value": 26348.684210526317
                                }
                            },
                            {
                                "key": "M",
                                "doc_count": 22,
                                "balanceAvg": {
                                    "value": 23405.68181818182
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 25269.583333333332
                    }
                },
                {
                    "key": 26,
                    "doc_count": 59,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "M",
                                "doc_count": 32,
                                "balanceAvg": {
                                    "value": 25094.78125
                                }
                            },
                            {
                                "key": "F",
                                "doc_count": 27,
                                "balanceAvg": {
                                    "value": 20943.0
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 23194.813559322032
                    }
                },
                {
                    "key": 32,
                    "doc_count": 52,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "M",
                                "doc_count": 28,
                                "balanceAvg": {
                                    "value": 22941.964285714286
                                }
                            },
                            {
                                "key": "F",
                                "doc_count": 24,
                                "balanceAvg": {
                                    "value": 25128.958333333332
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 23951.346153846152
                    }
                },
                {
                    "key": 35,
                    "doc_count": 52,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "M",
                                "doc_count": 28,
                                "balanceAvg": {
                                    "value": 24226.321428571428
                                }
                            },
                            {
                                "key": "F",
                                "doc_count": 24,
                                "balanceAvg": {
                                    "value": 19698.791666666668
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 22136.69230769231
                    }
                },
                {
                    "key": 36,
                    "doc_count": 52,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "M",
                                "doc_count": 31,
                                "balanceAvg": {
                                    "value": 20884.677419354837
                                }
                            },
                            {
                                "key": "F",
                                "doc_count": 21,
                                "balanceAvg": {
                                    "value": 24079.04761904762
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 22174.71153846154
                    }
                },
                {
                    "key": 22,
                    "doc_count": 51,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "F",
                                "doc_count": 27,
                                "balanceAvg": {
                                    "value": 22152.74074074074
                                }
                            },
                            {
                                "key": "M",
                                "doc_count": 24,
                                "balanceAvg": {
                                    "value": 27631.708333333332
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 24731.07843137255
                    }
                },
                {
                    "key": 28,
                    "doc_count": 51,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "F",
                                "doc_count": 31,
                                "balanceAvg": {
                                    "value": 27076.8064516129
                                }
                            },
                            {
                                "key": "M",
                                "doc_count": 20,
                                "balanceAvg": {
                                    "value": 30129.35
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 28273.882352941175
                    }
                },
                {
                    "key": 33,
                    "doc_count": 50,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "F",
                                "doc_count": 26,
                                "balanceAvg": {
                                    "value": 26437.615384615383
                                }
                            },
                            {
                                "key": "M",
                                "doc_count": 24,
                                "balanceAvg": {
                                    "value": 23638.291666666668
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 25093.94
                    }
                },
                {
                    "key": 34,
                    "doc_count": 49,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "F",
                                "doc_count": 30,
                                "balanceAvg": {
                                    "value": 26039.166666666668
                                }
                            },
                            {
                                "key": "M",
                                "doc_count": 19,
                                "balanceAvg": {
                                    "value": 28027.0
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 26809.95918367347
                    }
                },
                {
                    "key": 30,
                    "doc_count": 47,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "F",
                                "doc_count": 25,
                                "balanceAvg": {
                                    "value": 25316.16
                                }
                            },
                            {
                                "key": "M",
                                "doc_count": 22,
                                "balanceAvg": {
                                    "value": 20028.545454545456
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 22841.106382978724
                    }
                },
                {
                    "key": 21,
                    "doc_count": 46,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "F",
                                "doc_count": 24,
                                "balanceAvg": {
                                    "value": 28210.916666666668
                                }
                            },
                            {
                                "key": "M",
                                "doc_count": 22,
                                "balanceAvg": {
                                    "value": 25640.18181818182
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 26981.434782608696
                    }
                },
                {
                    "key": 40,
                    "doc_count": 45,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "M",
                                "doc_count": 24,
                                "balanceAvg": {
                                    "value": 26474.958333333332
                                }
                            },
                            {
                                "key": "F",
                                "doc_count": 21,
                                "balanceAvg": {
                                    "value": 27992.571428571428
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 27183.17777777778
                    }
                },
                {
                    "key": 20,
                    "doc_count": 44,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "M",
                                "doc_count": 27,
                                "balanceAvg": {
                                    "value": 29047.444444444445
                                }
                            },
                            {
                                "key": "F",
                                "doc_count": 17,
                                "balanceAvg": {
                                    "value": 25666.647058823528
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 27741.227272727272
                    }
                },
                {
                    "key": 23,
                    "doc_count": 42,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "M",
                                "doc_count": 24,
                                "balanceAvg": {
                                    "value": 27730.75
                                }
                            },
                            {
                                "key": "F",
                                "doc_count": 18,
                                "balanceAvg": {
                                    "value": 26758.833333333332
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 27314.214285714286
                    }
                },
                {
                    "key": 24,
                    "doc_count": 42,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "F",
                                "doc_count": 23,
                                "balanceAvg": {
                                    "value": 29414.521739130436
                                }
                            },
                            {
                                "key": "M",
                                "doc_count": 19,
                                "balanceAvg": {
                                    "value": 27435.052631578947
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 28519.04761904762
                    }
                },
                {
                    "key": 25,
                    "doc_count": 42,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "M",
                                "doc_count": 23,
                                "balanceAvg": {
                                    "value": 29336.08695652174
                                }
                            },
                            {
                                "key": "F",
                                "doc_count": 19,
                                "balanceAvg": {
                                    "value": 25156.263157894737
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 27445.214285714286
                    }
                },
                {
                    "key": 37,
                    "doc_count": 42,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "M",
                                "doc_count": 23,
                                "balanceAvg": {
                                    "value": 25015.739130434784
                                }
                            },
                            {
                                "key": "F",
                                "doc_count": 19,
                                "balanceAvg": {
                                    "value": 29451.21052631579
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 27022.261904761905
                    }
                },
                {
                    "key": 27,
                    "doc_count": 39,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "F",
                                "doc_count": 21,
                                "balanceAvg": {
                                    "value": 21618.85714285714
                                }
                            },
                            {
                                "key": "M",
                                "doc_count": 18,
                                "balanceAvg": {
                                    "value": 21300.38888888889
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 21471.871794871793
                    }
                },
                {
                    "key": 38,
                    "doc_count": 39,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "F",
                                "doc_count": 20,
                                "balanceAvg": {
                                    "value": 27931.65
                                }
                            },
                            {
                                "key": "M",
                                "doc_count": 19,
                                "balanceAvg": {
                                    "value": 24350.894736842107
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 26187.17948717949
                    }
                },
                {
                    "key": 29,
                    "doc_count": 35,
                    "genderAgg": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "M",
                                "doc_count": 23,
                                "balanceAvg": {
                                    "value": 29943.17391304348
                                }
                            },
                            {
                                "key": "F",
                                "doc_count": 12,
                                "balanceAvg": {
                                    "value": 28601.416666666668
                                }
                            }
                        ]
                    },
                    "balanceAvg": {
                        "value": 29483.14285714286
                    }
                }
            ]
        }
    }
}

2.4 映射

2.4.1 查看映射关系

GET http://127.0.0.1:9200/bank/_mapping

{
    "bank": {
        "mappings": {
            "properties": {
                "account_number": {
                    "type": "long"
                },
                "address": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                },
                "age": {
                    "type": "long"
                },
                "balance": {
                    "type": "long"
                },
                "city": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                },
                "email": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                },
                "employer": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                },
                "firstname": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                },
                "gender": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                },
                "lastname": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                },
                "state": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                }
            }
        }
    }
}

2.4.2 创建时指定映射

PUT http://127.0.0.1:9200/my_index
{
  "mappings": {
    "properties": {
      "age": {"type": "integer"},
      "email": {"type": "keyword"},
      "name": {"type": "text"}
    }
  }
}

{
    "acknowledged": true,
    "shards_acknowledged": true,
    "index": "my_index"
}

2.4.3 添加新字段

PUT http://127.0.0.1:9200/my_index/_mapping
{
  "properties": {
    "employee-id": {
      "type": "keyword",
      "index": false
    }
  }
}

{
    "acknowledged": true
}

2.4.4 修改映射

本质：创建一个新的索引，然后进行数据迁移

PUT http://127.0.0.1:9200/my_index2
{
  "mappings": {
      "properties": {
        "account_number": {
          "type": "long"
        },
        "address": {
          "type": "text"
        },
        "age": {
          "type": "integer"
        },
        "balance": {
          "type": "long"
        },
        "city": {
          "type": "text",
          "fields": {
            "keyword": {
              "type": "keyword",
              "ignore_above": 256
            }
          }
        },
        "email": {
          "type": "text",
          "fields": {
            "keyword": {
              "type": "keyword",
              "ignore_above": 256
            }
          }
        },
        "employer": {
          "type": "text",
          "fields": {
            "keyword": {
              "type": "keyword",
              "ignore_above": 256
            }
          }
        },
        "firstname": {
          "type": "text",
          "fields": {
            "keyword": {
              "type": "keyword",
              "ignore_above": 256
            }
          }
        },
        "gender": {
          "type": "text",
          "fields": {
            "keyword": {
              "type": "keyword",
              "ignore_above": 256
            }
          }
        },
        "lastname": {
          "type": "text",
          "fields": {
            "keyword": {
              "type": "keyword",
              "ignore_above": 256
            }
          }
        },
        "state": {
          "type": "text",
          "fields": {
            "keyword": {
              "type": "keyword",
              "ignore_above": 256
            }
          }
        }
      }
    }
}

{
    "acknowledged": true,
    "shards_acknowledged": true,
    "index": "my_index2"
}

2.4.5 数据迁移

POST http://127.0.0.1:9200/_reindex
{
  "source": {
    "index": "my_index",
    "type": "table"
  },
  "dest": {
    "index": "my_index3"
  }
}

{
    "took": 1,
    "timed_out": false,
    "total": 0,
    "updated": 0,
    "created": 0,
    "deleted": 0,
    "batches": 0,
    "version_conflicts": 0,
    "noops": 0,
    "retries": {
        "bulk": 0,
        "search": 0
    },
    "throttled_millis": 0,
    "requests_per_second": -1.0,
    "throttled_until_millis": 0,
    "failures": []
}

2.5 分词器

2.5.1 测试分词器

POST http://127.0.0.1:9200/_analyze
{
  "analyzer": "standard",
  "text": "I am huangzhen,come from China"
}

{
    "tokens": [
        {
            "token": "i",
            "start_offset": 0,
            "end_offset": 1,
            "type": "<ALPHANUM>",
            "position": 0
        },
        {
            "token": "am",
            "start_offset": 2,
            "end_offset": 4,
            "type": "<ALPHANUM>",
            "position": 1
        },
        {
            "token": "huangzhen",
            "start_offset": 5,
            "end_offset": 14,
            "type": "<ALPHANUM>",
            "position": 2
        },
        {
            "token": "come",
            "start_offset": 15,
            "end_offset": 19,
            "type": "<ALPHANUM>",
            "position": 3
        },
        {
            "token": "from",
            "start_offset": 20,
            "end_offset": 24,
            "type": "<ALPHANUM>",
            "position": 4
        },
        {
            "token": "china",
            "start_offset": 25,
            "end_offset": 30,
            "type": "<ALPHANUM>",
            "position": 5
        }
    ]
}

2.5.2 中文分词器

需要安装ik分词器

POST http://127.0.0.1:9200/_analyze
{
  "analyzer": "ik_max_word",
  "text": "我是中国人"
}

{
    "tokens": [
        {
            "token": "我",
            "start_offset": 0,
            "end_offset": 1,
            "type": "CN_CHAR",
            "position": 0
        },
        {
            "token": "是",
            "start_offset": 1,
            "end_offset": 2,
            "type": "CN_CHAR",
            "position": 1
        },
        {
            "token": "中国人",
            "start_offset": 2,
            "end_offset": 5,
            "type": "CN_WORD",
            "position": 2
        },
        {
            "token": "中国",
            "start_offset": 2,
            "end_offset": 4,
            "type": "CN_WORD",
            "position": 3
        },
        {
            "token": "国人",
            "start_offset": 3,
            "end_offset": 5,
            "type": "CN_WORD",
            "position": 4
        }
    ]
}

提醒：本文发布于635天前，文中所关联的信息可能已发生改变，请知悉！