张毅SOHO
张毅SOHO

数据库架构之【ELK（Elasticsearch+Logstash+Kibana）】OLAP 集群方案

ELK 是三个开源项目的首字母缩写，这三个项目分别是：Elasticsearch、Logstash 和 Kibana。它是一套以 Elasticsearch 为核心的 OLAP 集成解决方案。

本方案基于CentOS8系统设计，建议在RedHat/CentOS系统中使用。方案使用服务器及网络资源较多，建议在实施前做好规划工作，有利于部署工作顺利、有序进行。

目录

1.前言

2.集群部署拓扑图

3.Elasticsearch 单点安装和配置
3.1.安装和配置
3.2.安全性扩展
3.3.中文分词扩展

4.Elasticsearch 集群化
4.1.Elasticsearch 集群的概念
4.2.Elasticsearch 集群的示例

5.Kibana 安装和配置

6.Logstash 安装和作业部署

7.Java 开发集成
7.1.ES 编程语言
7.2.ES + Jest 可复用类库
7.3.ELK + Jest 最佳集成方案

1.前言

1、"集群"指的是 Elasticsearch 组成的集群，实现负载均衡，故障转移，实时热备和读写分离。但与 Logstash 和 Kibana 无关。

2、核心组件简介

1）Elasticsearch： 一个搜索和分析引擎，提供搜集、分析、存储数据三大功能。具有分布式，零配置，自动发现，索引自动分片，索引副本机制，Restful风格接口，多数据源，自动搜索负载等特点。Elasticsearch 能够对PB级海量数据进行近实时的处理（从写入到查询的延时≈1秒），且能够支持数百台服务器节点的分布式集群架构。

2）IKAnalyzer ：一个开源的，基于Java语言开发的轻量级的中文分词工具包。

2）Logstash： 一个服务器端数据处理管道，能够同时从多个来源采集数据，转换数据，然后将数据发送到 Elasticsearch 中。Logstash 通过部署JOB来完成工作，JOB工作流程如下：

Logstash JOB 工作流程

3）Kibana： 一个 Elasticsearch 的可视化管理用户接口，使用图形和图表对数据进行可视化。

3、ELK 适用于以下应用场景：

1）普通用于具有全文检索、海量数据检索类型的应用或功能，作为OLAP数据库支撑业务；

2）可以用于数据分析类型的应用或功能，且能够满足较高的实时性要求，作为OLAP数据库支撑业务；

3）可以用于具有高并发读写，弱ACID管理，弱安全性控制，小型文档型数据特点的应用或功能，作为数据库支撑业务。

补充知识：ACID是数据库事务的4个特征,分别是原子性、一致性、隔离性和持久性。

2.集群部署拓扑图

ELK集群部署拓扑图

网络资源规划：

1、ES Node 1 ： OLAP 数据库服务器

1）操作系统：CentOS8；

2）IP地址和端口号：192.168.216.128:9200；

3）主机名：ES-1；

4）数据库：Elasticsearch；

5）角色：OLAP 数据库集群节点。

2、ES Node 2 ：OLAP 数据库服务器

1）操作系统：CentOS8；

2）IP地址和端口号：192.168.216.129:9200；

3）主机名：ES-2；

4）数据库：Elasticsearch；

5）角色：OLAP 数据库集群节点。

3、ES Node 3 ：OLAP 数据库服务器

1）操作系统：CentOS8；

2）IP地址和端口号：192.168.216.130:9200；

3）主机名：ES-3；

4）数据库：Elasticsearch；

5）角色：OLAP 数据库集群节点。

4、Kinaba： 可视化管理客户端

1）操作系统：CentOS8；

2）IP地址和端口号：192.168.216.131:5601；

3）主机名：ESVM；

4）中间件：Kibana；

5）角色：OLAP 数据库可视化管理器。

5、Logstash ： 数据 ETL 服务器

1）操作系统：CentOS8；

2）IP地址：192.168.216.132；

3）主机名：ETL；

4）中间件：Logstash；

5）角色：数据采集器。

6、外部数据源： 作为 OLAP 数据分析的外部数据来源数据库，如：PostgreSQL、MySQL 等 RDBMS 数据库 。IP地址：192.168.216.133

3.Elasticsearch 单点安装和配置

3.1.安装和配置

以"ES Node 1"节点为例：

1、打开 Elasticsearch 官方网站下载页面【https://www.elastic.co/cn/downloads/elasticsearch】，下载 Elasticsearch 的编译程序 tar 包到用户主目录中。

Elasticsearch 官方下载页面

2、解压缩编译程序 tar 包到"/usr/local"目录中。

[centos@ES-1 ~]$ sudo tar zxvf elasticsearch-7.6.2-linux-x86_64.tar.gz -C /usr/local
[centos@ES-1 ~]$ ll /usr/local
drwxr-xr-x. 9 root root 155 3月  26 14:36 elasticsearch-7.6.2

3、创建 Elastcsearch 的数据存储目录和日志存储目录。

[centos@ES-1 ~]$ sudo mkdir -p /data/elasticsearch/data
[centos@ES-1 ~]$ sudo mkdir -p /data/elasticsearch/logs

4、创建 ELK 管理用户和组，并设置为程序安装目录、数据存储目录的拥有者。

[centos@ES-1 ~ ]$ sudo id elastic
id: “elastic”：无此用户
[centos@ES-1 ~ ]$ sudo groupadd elastic
[centos@ES-1 ~ ]$ sudo useradd -g elastic -s /bin/false elastic
[centos@ES-1 ~ ]$ sudo chown -R elastic:elastic /usr/local/elasticsearch-7.6.2
[centos@ES-1 ~ ]$ sudo chown -R elastic:elastic /data/elasticsearch

ELK组件的管理用户和组（如："elastic"）可以共享使用，创建用户和组之前首先查询一下账户是否存在。如果账户和组已经存在，可能是因为在安装其他ELK组件时已创建，这种情况下不必重复创建用户和组，只需要更改程序安装目录、数据存储目录的拥有者即可。

5、设置 Elastcsearch 的配置文件参数。

使用文本编辑器打开配置文件：

[centos@ES-1 ~]$ sudo gedit /usr/local/elasticsearch-7.6.2/config/elasticsearch.yml

修改或验证文件中的以下参数并保存：

# --常用设置项--

node.name: es-node-1
# 设置当前ES节点的名称，默认随机指定一个预置列表中名字。

path.data: /data/elasticsearch/data
# 设置索引数据的存储路径，默认是ES根目录下的data文件夹。可以设置多个存储路径，用逗号隔开，例：
# path.data: /path/to/data1,/path/to/data2

path.logs: /data/elasticsearch/logs
# 设置日志文件的存储路径，默认是ES根目录下的logs文件夹 。

network.host: 0.0.0.0
# 设置ES服务的监听网络地址（IPv4 或 IPv6），默认是示例地址。

http.port: 9200
# 设置ES服务的HTTP端口，默认为9200。

transport.tcp.port: 9300
# 设置节点之间交互的TCP端口，默认是9300。

http.cors.enabled: true
http.cors.allow-origin: "*"
# 设置允许HTTP跨域访问

discovery.seed_hosts: ["127.0.0.1", "[::1]"]
# 设置集群节点发现清单，默认为IPv4和IPv6回路地址。

cluster.initial_master_nodes: ["es-node-1"]
# 设置集群初始化主要节点清单，默认是node-1。


# --其他可用设置项--

# cluster.name: elasticsearch-cluster
# 设置的集群名称，默认是elasticsearch。ES通过广播方式自动发现同一网段其他节点，若同一网段下有多个集群，则通过集群名称区分不同的集群。

# node.master: true
# 设置当前节点是否有资格被选举成为主要节点，默认是true。ES默认集群中的第一个节点为主要节点，如果这个节点故障就会重新选举主要节点。

# node.data: true
# 设置当前节点是否存储索引数据，默认为true。

# path.conf: /path/to/conf
# 设置配置文件的存储路径，默认是ES根目录下的config文件夹。

# path.work: /path/to/work
# 设置临时文件的存储路径，默认是ES根目录下的work文件夹。

# path.plugins: /path/to/plugins
# 设置插件的存放路径，默认是ES根目录下的plugins文件夹, 插件在ES里面普遍使用，用来增强原系统核心功能。

# bootstrap.mlockall: true
# 设置为true来锁住JVM内存。

# network.bind_host: 0.0.0.0
# 设置监听的ip地址，可以是IPv4或IPv6的，默认为0.0.0.0。可以绑定这台机器的任何一个IP地址。

# network.publish_host: 0.0.0.0
# 设置其它节点和该节点交互的IP地址，如果不设置它会自动判断，值必须是个真实的IP地址。

# transport.tcp.compress: true
# 设置是否压缩TCP传输时的数据，默认为false。

# http.max_content_length: 100mb
# 设置HTTP协议请求内容的最大容量，默认100mb。

# http.enabled: true
# 设置是否使用HTTP协议对外提供服务，默认为true。

# gateway.type: local
# 设置gateway的类型，默认为local即为本地文件系统。可以设置为本地文件系统，分布式文件系统，hadoop的HDFS，和amazon的s3服务器等。

# gateway.recover_after_nodes: 1
# 设置集群中N个节点启动时进行数据恢复，默认为1。

# gateway.recover_after_time: 5m
# 设置初始化数据恢复进程的超时时间，默认是5分钟。

# gateway.expected_nodes: 2
# 设置这个集群中节点的数量，默认为2，一旦这N个节点启动，就会立即进行数据恢复。

# cluster.routing.allocation.node_initial_primaries_recoveries: 4
# 初始化数据恢复时，并发恢复线程的个数，默认为4。

# cluster.routing.allocation.node_concurrent_recoveries: 2
# 添加删除节点或负载均衡时并发恢复线程的个数，默认为4。

# indices.recovery.max_size_per_sec: 0
# 设置数据恢复时限制的带宽，如入100mb，默认为0，即无限制。

# indices.recovery.concurrent_streams: 5
# 设置这个参数来限制从其它分片恢复数据时最大同时打开并发流的个数，默认为5。

# discovery.zen.ping.timeout: 3s
# 设置集群中自动发现其它节点时ping连接超时时间，默认为3秒，对于比较差的网络环境可以高点的值来防止自动发现时出错。

# discovery.zen.ping.multicast.enabled: true
# 设置是否打开多播发现节点，默认是true。

# discovery.zen.ping.unicast.hosts: ["127.0.0.1", "[::1]"]
# 设置集群中主要节点的初始列表，可以通过这些节点来自动发现新加入集群的节点。

# discovery.zen.minimum_master_nodes: 1
# 设置集群有主要节点资格的数量，默认为1。对于大的集群来说，可以设置大一点的值（2-4）。

# xpack.security.enabled: true
# xpack.security.transport.ssl.enabled: true
# xpack.security.transport.ssl.verification_mode: certificate
# xpack.security.transport.ssl.keystore.path: elastic-certificates.p12
# xpack.security.transport.ssl.truststore.path: elastic-certificates.p12
# 启用 X-Pack 安全认证模块，启用前需要导出证书文件，如：elastic-certificates.p12。

6、设置 Elasticsearch 运行的Linux系统参数。

1）在"/etc/sysctl.conf"文件中设置内核参数。

使用文本编辑器创建配置文件：

[centos@ES-1 ~ ]$ sudo gedit /etc/sysctl.conf

在文件中追加内容并保存如下：

vm.max_map_count=655360

2）在"/etc/security/limits.conf"文件中设置用户 SHELL 参数。
使用文本编辑器创建配置文件：

[centos@ES-1 ~ ]$ sudo gedit /etc/security/limits.conf

在文件中追加内容并保存如下：

elastic soft nofile 65536
elastic hard nofile 65536

3）重新启动操作系统。

[centos@ES-1 ~ ]$ sudo reboot

7、配置 Elasticsearch 服务开机自启动。

使用文本编辑器创建配置文件：

[centos@ES-1 ~ ]$ sudo gedit /usr/lib/systemd/system/elasticsearch-server.service

编写文件内容并保存如下：

[Unit]
Description=Elasticsearch Server
After=syslog.target network.target

[Service]
User=elastic
Group=elastic

ExecStart=/usr/local/elasticsearch-7.6.2/bin/elasticsearch
ExecStop=/bin/kill -HUP $MAINPID
ExecReload=/bin/kill -HUP $MAINPID

KillMode=mixed
KillSignal=SIGINT

LimitNOFILE=100000
LimitNPROC=100000

[Install]
WantedBy=multi-user.target

设置开机启动：

[centos@ES-1 ~]$ sudo systemctl daemon-reload
[centos@ES-1 ~]$ sudo systemctl enable elasticsearch-server.service

8、启动 Elasticsearch 服务。

[centos@ES-1 ~]$ sudo systemctl start elasticsearch-server.service

9、设置防火墙端口（CentOS8默认安装firewall防火墙），允许"9200"，"9300"端口（Elasticsearch 默认端口）访问服务器。

[centos@ES-1 ~]$ sudo firewall-cmd --zone=public --add-port=9200/tcp --permanent
[centos@ES-1 ~]$ sudo firewall-cmd --zone=public --add-port=9300/tcp --permanent
[centos@ES-1 ~]$ sudo firewall-cmd --reload

10、验证 Elasticsearch 服务正常运行。使用浏览器客户端访问 Elasticsearch 的 Http 服务接口进行测试，输入：http://:

Elastisearch 服务正常运行反馈消息

11、Elasticsearch 运维管理

1）启动 Elasticsearch 服务（任选一种方式）

[centos@ES-1 ~]$ sudo systemctl start elasticsearch-server.service

或者

[centos@ES-1 ~]$ sudo -u elastic /usr/local/elasticsearch-7.6.2/bin/elasticsearch

2）停止 Elasticsearch 服务（任选一种方式）

[centos@ES-1 ~]$ sudo systemctl stop elasticsearch-server.service

或者

[centos@ES-1 ~]$ sudo ps -ef | grep Elasticsearch
elastic    3377      1  2 13:15 ?        00:00:37 /usr/local/elasticsearch-7.6.2/jdk/bin/java ...
[centos@ES-1 ~]$ sudo kill -9 3377

3）重启 Elasticsearch 服务

[centos@ES-1 ~]$ sudo systemctl restart elasticsearch-server.service

或者

[centos@ES-1 ~]$ sudo ps -ef | grep Elasticsearch
elastic    3377      1  2 13:15 ?        00:00:37 /usr/local/elasticsearch-7.6.2/jdk/bin/java...
[centos@ES-1 ~]$ sudo kill -9 3377
[centos@ES-1 ~]$ sudo -u elastic /usr/local/elasticsearch-7.6.2/bin/elasticsearch

4）查看 Elasticseach 服务状态

[centos@ES-1 ~]$ sudo systemctl status elasticsearch-server.service

或者

[centos@ES-1 ~]$ sudo netstat -ntap | grep -E "9200|9300"
tcp6       0      0 :::9200                 :::*                    LISTEN      3377/java           
tcp6       0      0 :::9300                 :::*                    LISTEN      3377/java

5）开启 Elasticsearch 服务开机自启动

[centos@ES-1 ~]$ sudo systemctl enable elasticsearch-server.service

6）禁用 Elasticsearch 服务开机自启动

[centos@ES-1 ~]$ sudo systemctl disable elasticsearch-server.service

在多个实例并行的情况下，全部实例共享使用管理用户和组、Linux内核配置，但每个实例独立安装（包括独立的程序安装目录和数据存储目录）、独立端口、独立启动服务。

注意：其他"ES Node"节点上全部需要按照以上步骤配置。

3.2.安全性扩展

Elasticsearch 集成了 X-Pack 作为安全性组件，直接开启使用即可。

首先完成 Elasticsearch 的安装和配置。以"ES Node 1"节点为例：

1、导出 Elasticsearch X-Pack 证书文件。导出文件命令需要设置证书口令为空。

[centos@ES-1 ~]$ sudo -u elastic /usr/local/elasticsearch-7.6.2/bin/elasticsearch-certutil cert -out /usr/local/elasticsearch-7.6.2/config/elastic-certificates.p12 -pass ""

2、修改 Elastcsearch 的配置文件参数。

使用文本编辑器打开配置文件：

[centos@ES-1 ~]$ sudo gedit /usr/local/elasticsearch-7.6.2/config/elasticsearch.yml

追加或验证文件中的以下参数并保存：

xpack.security.enabled: true
xpack.security.transport.ssl.enabled: true
xpack.security.transport.ssl.verification_mode: certificate
xpack.security.transport.ssl.keystore.path: elastic-certificates.p12
xpack.security.transport.ssl.truststore.path: elastic-certificates.p12

3、重新启动 Elasticsearch 服务。

[centos@ES-1 ~]$ sudo systemctl restart elasticsearch-server.service

4、设置 Elasticsearch 服务内置账号的口令。

[centos@ES-1 ~]$ sudo -u elastic  /usr/local/elasticsearch-7.6.2/bin/elasticsearch-setup-passwords interactive

Initiating the setup of passwords for reserved users elastic,apm_system,kibana,logstash_system,beats_system,remote_monitoring_user.
You will be prompted to enter passwords as the process progresses.
Please confirm that you would like to continue [y/N]y

Enter password for [elastic]: 
Reenter password for [elastic]: 
Enter password for [apm_system]: 
Reenter password for [apm_system]: 
Enter password for [kibana]: 
Reenter password for [kibana]: 
Enter password for [logstash_system]: 
Reenter password for [logstash_system]: 
Enter password for [beats_system]: 
Reenter password for [beats_system]: 
Enter password for [remote_monitoring_user]: 
Reenter password for [remote_monitoring_user]: 

Changed password for user [apm_system]
Changed password for user [kibana]
Changed password for user [logstash_system]
Changed password for user [beats_system]
Changed password for user [remote_monitoring_user]
Changed password for user [elastic]

5、验证 X-Pack 认证。使用浏览器客户端访问 Elasticsearch 的 Http 服务接口进行测试，输入：http://:

X-Pack 认证界面

注意：其他 "ES Node" 节点上不需要执行此步骤。但是需要将此服务器上已经创建的 "elastic-certificates.p12" 文件和 "elasticsearch.keystore" 文件拷贝到其他"ES Node"节点的同一位置上，一致使用。即：集群中所有节点的安全认证文件是一致的。

3.3.中文分词扩展

在中文环境下使用 Elasticsearch 一般是需要扩展中文分词器，建议使用 IkAnalyzer 。IKAnalyzer 是一个开源的，基于 Java 语言开发的轻量级的中文分词工具包。

首先完成 Elasticsearch 的安装和配置。以"ES Node 1"节点为例：

1、从【https://github.com/medcl/elasticsearch-analysis-ik/releases】下载 IKAnalyzer 的编译程序 zip 包到用户主目录中。使用的 IKAnalyzer 分词器的版本应与 Elasticsearch 的版本保持一致。

IKAnalyzer 下载页面

2、解压缩编译程序 zip 包到 Elasticsearch 程序安装目录下的"plugins"目录下，并设置 ELK 管理用户和组为拥有者。

[centos@ES-1 ~]$ sudo unzip elasticsearch-analysis-ik-7.6.2.zip -d /usr/local/elasticsearch-7.6.2/plugins/ik
[centos@ES-1 ~]$ sudo chown -R elastic:elastic /usr/local/elasticsearch-7.6.2/plugins/ik

3、重新启动 Elasticsearch 服务。

[centos@ES-1 ~]$ sudo systemctl restart elasticsearch-server.service

4、验证 IkAnalyzer 插件集成。使用浏览器客户端访问 Elasticsearch 的 Http 服务接口进行测试，输入：http://:/_cat/plugins

IkAnalyzer 正确集成反馈消息

注意：其他"ES Node"节点上全部需要按照以上步骤配置。

4.Elasticsearch 集群化

4.1.Elasticsearch 集群的概念

1、Elasticsearch 集群的组成

1）节点（Node）和 集群（Cluster）：节点是单个 Elastcsearch 服务，一般部署在单独的服务器上。如果这些单个 Elasticsearch 服务的配置文件（elasticsearch.yml 文件） 中具有相同的"cluster.name"设置值，那就自动发现这些节点并组成一个集群，集群中允许有1个或者大于1个的单数节点组成。

2）文档（Document）和 索引（Index）：文档是一组由 JSON 结构组成的结构化数据，它由若干属性和值组成，而索引是存储文档的库。可以将索引比作 RDBMS 中仅有一个"表"的数据库，文档是"表"中的"行"，而文档属性是"行"中的"列"。

3）shard（分片）：Elasticsearch 将一个索引切分为多个分片，在集群的节点中分布存储，构成分布式搜索机制。因此 ES 具有横向扩展的能力，可以存储大量数据并且让搜索和分析等操作分布到多台服务器上去执行，提升吞吐量和性能。分片数量在建立索引时一次设置，不能修改，默认5个。

4）shard replica（分片副本）：Elasticsearch 允许每个分片创建多个副本。分片副本可以在多个节点中冗余数据，以保障在节点故障时数据不被丢失，同时可以提升搜索操作的吞吐量和性能。分片副本数量可以随时修改，默认1个。

2、Elasticsearch 集群节点的类型

1）主节点：主节点负责创建索引、删除索引、分配分片、追踪集群中的节点状态等工作。Elasticsearch 中的主节点的工作量相对较轻，用户的请求可以发往集群中任何一个节点，由该节点负责分发和返回结果，而不需要经过主节点转发。而主节点是由候选主节点通过 ZenDiscovery 机制选举出来的。

2）候选主节点：在 Elasticsearch 集群初始化或者主节点宕机的情况下，从候选主节点中选举其中一个作为主节点。候选主节点的 Elasticsearch 服务的配置文件（elasticsearch.yml 文件）设置项特点：

node.master: true
# 设置当前节点是否有资格被选举成为主要节点，默认是true。ES默认集群中的第一个节点为主要节点，如果这个节点故障就会重新选举主要节点。

node.data: false
# 设置当前节点是否存储索引数据，默认为true。

3）数据节点：数据节点负责数据的存储和相关具体操作，比如CRUD、搜索、聚合。所以，数据节点对机器配置要求比较高，首先需要有足够的磁盘空间来存储数据，其次数据操作对系统CPU、Memory和IO的性能消耗都很大。数据节点的 Elasticsearch 服务的配置文件（elasticsearch.yml 文件）设置项特点：

node.master: false
# 设置当前节点是否有资格被选举成为主要节点，默认是true。ES默认集群中的第一个节点为主要节点，如果这个节点故障就会重新选举主要节点。

node.data: true
# 设置当前节点是否存储索引数据，默认为true。

4）候选主节点+数据节点：一个节点可以同时成为候选主节点和数据节点，主需要在候选主节点配置的基础上开启数据节点即可。候选主节点+数据节点的 Elasticsearch 服务的配置文件（elasticsearch.yml 文件）设置项特点：

node.master: true
# 设置当前节点是否有资格被选举成为主要节点，默认是true。ES默认集群中的第一个节点为主要节点，如果这个节点故障就会重新选举主要节点。

node.data: true
# 设置当前节点是否存储索引数据，默认为true。

5）客户端节点：客户端节点就是既不做候选主节点也不做数据节点的节点，只负责请求的分发、汇总。这是所有节点的共性能力，单独增加这样的节点一般是为了负载均衡。数据节点的 Elasticsearch 服务的配置文件（elasticsearch.yml 文件）设置项特点：

node.master: false
# 设置当前节点是否有资格被选举成为主要节点，默认是true。ES默认集群中的第一个节点为主要节点，如果这个节点故障就会重新选举主要节点。

node.data: false
# 设置当前节点是否存储索引数据，默认为true。

4.2.Elasticsearch 集群的示例

首先完成 Elasticsearch 的安装和配置。假设按照本文规划的集群拓扑图，所有集群节点都是"候选主节点+数据节点"的类型，以"ES Node 1"节点为例：

1、设置 Elastcsearch 的配置文件参数。

使用文本编辑器打开配置文件：

[centos@ES-1 ~]$ sudo gedit /usr/local/elasticsearch-7.6.2/config/elasticsearch.yml

修改或验证文件中的以下参数并保存：

# -- 必须一致的配置 --

cluster.name: elasticsearch-cluster
# 设置的集群名称，同一集群的节点应该设置相同的集群名称。

cluster.initial_master_nodes: ["es-node-1","es-node-2"]
# 设置集群初始化主节点清单。本例中将【es-node-1】和【es-node-2】节点设置为初始化主节点。

discovery.send_hosts: ["192.168.216.128:9300", "192.168.216.129:9300"]
# 设置集群节点发现清单，一般是候选主节点IP地址，不写端口号时默认9300端口。

discovery.zen.minimum_master_nodes: 2
# 设置集群候选主节点的最少数量。

# -- 各节点的个性化配置 --

node.name: es-node-1
# 设置当前ES节点的名称，每个节点应设置不同的名称。

node.master: true
# 设置当前节点是候选主节点。

node.data: true
# 设置当前节点是数据节点。

path.data: /data/elasticsearch/data
# 设置索引数据的存储路径，默认是ES根目录下的data文件夹。可以设置多个存储路径，用逗号隔开，例：
# path.data: /path/to/data1,/path/to/data2

path.logs: /data/elasticsearch/logs
# 设置日志文件的存储路径，默认是ES根目录下的logs文件夹 。

network.host: 0.0.0.0
# 设置ES服务的监听网络地址（IPv4 或 IPv6），默认是示例地址。

http.port: 9200
# 设置ES服务的HTTP端口，默认为9200。

transport.tcp.port: 9300
# 设置节点之间交互的TCP端口，默认是9300。

http.cors.enabled: true
http.cors.allow-origin: "*"
# 设置允许HTTP跨域访问

# xpack.security.enabled: true
# xpack.security.transport.ssl.enabled: true
# xpack.security.transport.ssl.verification_mode: certificate
# xpack.security.transport.ssl.keystore.path: elastic-certificates.p12
# xpack.security.transport.ssl.truststore.path: elastic-certificates.p12
# 启用 X-Pack 安全认证模块，集群中所有节点的安全认证文件是一致的。
# 只需要在其中一个节点中创建认证文件（elastic-certificates.p12 文件和 elasticsearch.keystore 文件），其他节点只需要拷贝这两个文件即可，注意要存放在一致的目录下。

2、认证文件一致化设置。

假设在 "ES Node 1" 上已经创建安全认证文件 "elastic-certificates.p12" 和 "elasticsearch.keystore" ，这些文件存放在 Elasticsearch 程序安装目录下的 "config" 目录中（本例为：/usr/local/elasticsearch-7.6.2/config 目录）。

将两个文件分别拷贝至其他 "ES Node" 节点上的 Elasticsearch 程序安装目录下的 "config" 目录中（本例为：/usr/local/elasticsearch-7.6.2/config 目录）。

注意：除上述操作以外，无需进行任何有关安全性扩展的配置。

3、重启启动集群。

首先启动"ES Node 1"节点，然后依次启动其他"ES Node"节点。

[centos@ES-1 ~]$ sudo systemctl restart elasticsearch-server.service

[centos@ES-2 ~]$ sudo systemctl restart elasticsearch-server.service

[centos@ES-3 ~]$ sudo systemctl restart elasticsearch-server.service

4、验证集群。使用浏览器客户端访问 Elasticsearch 的 Http 服务接口进行测试，输入：http://:/_cluster/health

Elasticsearch 集群验证页面

5.Kibana 安装和配置

1、打开 Kibana 官方网站下载页面【https://www.elastic.co/cn/downloads/kibana】，下载 Kibana 的编译程序 tar 包到用户主目录中。

Kibana 官方下载页面

2、解压缩编译程序 tar 包到"/usr/local"目录中。

[centos@ESVM ~]$ sudo tar zxvf kibana-7.6.2-linux-x86_64.tar.gz -C /usr/local
[centos@ESVM ~]$ ll /usr/local
drwxr-xr-x. 13 root    root    266 4月  20 15:25 kibana-7.6.2-linux-x86_64

3、创建 ELK 管理用户和组，并设置为程序安装目录的拥有者。

[centos@ESVM ~ ]$ sudo id elastic
id: “elastic”：无此用户
[centos@ESVM ~ ]$ sudo groupadd elastic
[centos@ESVM ~ ]$ sudo useradd -g elastic -s /bin/false elastic
[centos@ESVM ~ ]$ sudo chown -R elastic:elastic /usr/local/kibana-7.6.2-linux-x86_64

ELK组件的管理用户和组（如："elastic"）可以共享使用，创建用户和组之前首先查询一下账户是否存在。如果账户和组已经存在，可能是因为在安装其他ELK组件时已创建，这种情况下不必重复创建用户和组，只需要更改程序安装目录、数据存储目录的拥有者即可。

4、设置 Kibana 的配置文件参数。

使用文本编辑器打开配置文件：

[centos@ESVM ~]$ sudo gedit /usr/local/kibana-7.6.2-linux-x86_64/config/kibana.yml

修改或验证文件中的以下参数并保存：

server.port: 5601
# 服务监听端口。

server.host: "192.168.216.131"
# 服务监听地址。

server.name: "ESVM Kibana"
# 服务的显示名称。

elasticsearch.hosts: ["http://192.168.216.128:9200","http://192.168.216.129:9200","http://192.168.216.130:9200"]
# ElasticSearch 集群 URLs 集合。

kibana.index: ".kibana"
# Kibana 在 ElasticSearch 中存储搜索、可视化和仪表板数据的索引名字。

elasticsearch.username: "elastic"
# Kibana 访问 ElasticSearch 的账号，"elastic" 账号是 Elasticsearch 的预置用户。

elasticsearch.password: "password"
# Kibana 访问 ElasticSearch 账号的口令。

i18n.locale: "zh-CN"
# 本地化区域语言设置，支持英文和中文，默认是中文。

5、配置 Kibana 服务开机自启动。

使用文本编辑器创建配置文件：

[centos@ESVM ~ ]$ sudo gedit /usr/lib/systemd/system/kibana-server.service

编写文件内容并保存如下：

[Unit]
Description=Kibana Server
After=syslog.target network.target

[Service]
User=elastic
Group=elastic

ExecStart=/usr/local/kibana-7.6.2-linux-x86_64/bin/kibana
ExecStop=/bin/kill -HUP $MAINPID
ExecReload=/bin/kill -HUP $MAINPID

KillMode=mixed
KillSignal=SIGINT

LimitNOFILE=100000
LimitNPROC=100000

[Install]
WantedBy=multi-user.target

设置开机启动：

[centos@ESVM ~]$ sudo systemctl daemon-reload
[centos@ESVM ~]$ sudo systemctl enable kibana-server.service

6、启动 Kibana 服务。

[centos@ESVM ~]$ sudo systemctl start kibana-server.service

7、设置防火墙端口（CentOS8默认安装firewall防火墙），允许"5601"端口（Kibana 默认端口）访问服务器。

[centos@ESVM ~]$ sudo firewall-cmd --zone=public --add-port=5601/tcp --permanent
[centos@ESVM ~]$ sudo firewall-cmd --reload

8、验证 Kibana 服务正常运行。使用浏览器客户端访问 Kibana 的 Http 服务接口进行测试，输入：http://:

Kibana 登录页面
Kibana 主页面

9、Kibana 运维管理

1）启动 Kibana 服务（任选一种方式）

[centos@ESVM ~]$ sudo systemctl start kibana-server.service

或者

[centos@ESVM ~]$ sudo -u elastic /usr/local/kibana-7.6.2-linux-x86_64/bin/kibana

2）停止 Kibana 服务（任选一种方式）

[centos@ESVM ~]$ sudo systemctl stop kibana-server.service

或者

[centos@ESVM ~]$ sudo ps -ef | grep kibana
elastic   12268      1  1 4月20 ?       00:12:00 /usr/local/kibana-7.6.2-linux-x86_64/bin/..
[centos@ESVM ~]$ sudo kill -9 12268

3）重启 Kibana 服务

[centos@ESVM ~]$ sudo systemctl restart kibana-server.service

或者

[centos@ESVM ~]$ sudo ps -ef | grep kibana
elastic   12268      1  1 4月20 ?       00:12:00 /usr/local/kibana-7.6.2-linux-x86_64/bin/..
[centos@ESVM ~]$ sudo kill -9 12268
[centos@ESVM ~]$ sudo -u elastic /usr/local/kibana-7.6.2-linux-x86_64/bin/kibana

4）查看 Kibana 服务状态

[centos@ESVM ~]$ sudo systemctl status kibana-server.service

或者

[centos@ESVM ~]$ sudo netstat -ntap | grep 5601
tcp        0      0 192.168.216.131:5601    0.0.0.0:*               LISTEN      12268/node

5）启动 Kibana 服务开机自启动

[centos@ESVM ~]$ sudo systemctl enable kibana-server.service

6）禁用 Kibana 服务开机自启动

[centos@ESVM ~]$ sudo systemctl disable kibana-server.service

6.Logstash 安装和作业部署

1、安装 OpenJDK 1.8 或 OracleJDK 1.8。

1）使用 YUM 源安装OpenJDK 1.8。

[centos@ETL ~]$ sudo dnf install java-1.8.0-openjdk

2）验证Java运行环境。

[centos@ETL ~]$ java -vserion
openjdk version "1.8.0_242"
OpenJDK Runtime Environment (build 1.8.0_242-b08)
OpenJDK 64-Bit Server VM (build 25.242-b08, mixed mode)

2、打开 Logstash 官方网站下载页面【https://www.elastic.co/cn/downloads/logstash】，下载 Logstash 的编译程序 tar 包到用户主目录中。

Logstash 官方下载页面

3、解压缩编译程序 tar 包到"/usr/local"目录中。

[centos@ETL ~]$ sudo tar zxvf logstash-7.6.2.tar.gz -C /usr/local
[centos@ETL ~]$ ll /usr/local
drwxr-xr-x. 12     631     503 255 3月  26 17:42 logstash-7.6.2

4、创建 Logstash 的数据、日志、作业配置存储目录。

[centos@ETL ~]$ sudo mkdir -p /data/logstash/data
[centos@ETL ~]$ sudo mkdir -p /data/logstash/logs
[centos@ETL ~]$ sudo mkdir -p /data/logstash/config

5、创建 ELK 管理用户和组，并设置为程序安装目录、数据存储目录的拥有者。

[centos@ETL ~ ]$ sudo id elastic
id: “elastic”：无此用户
[centos@ETL ~ ]$ sudo groupadd elastic
[centos@ETL ~ ]$ sudo useradd -g elastic -s /bin/false elastic
[centos@ETL ~ ]$ sudo chown -R elastic:elastic /usr/local/logstash-7.6.2
[centos@ETL ~ ]$ sudo chown -R elastic:elastic /data/logstash

ELK组件的管理用户和组（如："elastic"）可以共享使用，创建用户和组之前首先查询一下账户是否存在。如果账户和组已经存在，可能是因为在安装其他ELK组件时已创建，这种情况下不必重复创建用户和组，只需要更改程序安装目录、数据存储目录的拥有者即可。

6、设置 Logstash 的配置文件参数。

使用文本编辑器打开配置文件：

[centos@ETL ~]$ sudo gedit /usr/local/logstash-7.6.2/config/logstash.yml

修改或验证文件中的以下参数并保存：

# --常用设置项--

path.data: /data/logstash/data
# 插件数据持久化目录，默认为程序安装目录下的"data"目录。

path.logs: /data/logstash/logs
# 设置日志文件目录，默认输出到控制台。

path.config: /data/logstash/config
# 设置管道配置文件目录。

config.reload.automatic: true
# 开启管道配置文件自动加载，默认为false。

config.reload.interval: 3s
# 设置管道配置文件检查更新的时间。

# --其他可用设置项--

# node.name: ETL Logstash
# 节点名称，默认为主机名称。

# pipeline.workers: 2
# 输出通道的工作workers数据量（提升输出效率）默认为CPU核数。

# pipeline.batch.size: 125
# 每批次输入数据的条数，默认125条。

# pipeline.batch.delay: 50
# 每批次延时等待的时间（单位毫秒），默认50毫秒。

# http.host: "127.0.0.1"
# 用户指标收集REST服务绑定主机地址，默认为"127.0.0.1"。

# http.port: 9600-9700
# 用户指标收集REST服务绑定主机端口，默认为9600-9700。

# log.level: info
# 日志输出级别，如果config.debug开启，这里一定要是debug日志 ，默认为 info。

# path.plugins: []
# 自定义插件目录

7、配置 ETL 作业。

以从 PostgreSQL 数据库中抽取数据，并写入 Elasticsearch 中为例：

1）下载 PostgreSQL JDBC 的 jar 包到指定位置。打开 PostgreSQL JDBC 官方网站下载页面【https://jdbc.postgresql.org/download.html】，下载 PostgreSQL JDBC 的 jar 包到用户主目录中。**

PostgreSQL JDBC 的 jar 包下载页面

2）将 PostgreSQL JDBC 的 jar 包拷贝到 Logstash 程序目录中的指定位置：

[centos@ETL ~]$ sudo -u elastic cp postgresql-42.2.12.jar /usr/local/logstash-7.6.2/logstash-core/lib/jars

3）在 Logstash 的作业配置存储目录中创建 JOB 配置文件。

使用文本编辑器创建配置文件：

[centos@ETL ~]$ sudo -u elastic gedit /data/logstash/config/pgsql.conf

编写以下配置脚本并保存：

input {
    stdin {
    }
    jdbc {
          # 数据库 JDBC 的 jar 包位置，JDBC 的 jar 包需要自行下载准备
          jdbc_driver_library => "/usr/local/logstash-7.6.2/logstash-core/lib/jars/postgresql-42.2.12.jar"
          # 数据库驱动
          jdbc_driver_class => "org.postgresql.Driver"
          # 数据库连接字符串
          jdbc_connection_string => "jdbc:postgresql://192.168.216.133:5432/pgsql"
          # 数据库用户名密码
          jdbc_user => "postgres"
          jdbc_password => "postgres"
          # 数据库重连尝试次数
          connection_retry_attempts => "3"
          # 判断数据库连接是否可用，默认false不开启
          jdbc_validate_connection => "true"
          # 数据库连接可用校验超时时间，默认3600S
          jdbc_validation_timeout => "3600"
          # 开启分页查询（默认false不开启）
          jdbc_paging_enabled => "true"
          # 单次分页查询条数（默认100000,若字段较多且更新频率较高，建议调低此值）
          jdbc_page_size => "5000"
          # sql脚本文件或脚本
          # statement_filepath => "pgsql.sql"
          statement => "select row_number() over(order by last_modify_dt  asc) as rn,* from table where last_modify_dt >= :sql_last_value"
          # 是否将列名转为小写，默认为true
          lowercase_column_names => "false"
          # 定期执行周期，"*"从左到右依次代表： 分 时 天 月 年  
          schedule => "* * * * *"
          # 是否记录上次执行结果, 如果为真,将会把上次执行到的 tracking_column 字段的值记录下来,保存到 last_run_metadata_path 指定的文件中
          record_last_run => "true"
          # 是否需要记录某个column 的值,如果record_last_run为真,可以自定义我们需要 track 的 column 名称，此时该参数就要为 true. 否则默认 track 的是 timestamp 的值.
          use_column_value => "true"
          # 如果 use_column_value 为真,需配置数据表增量字段的类型，只能是"numeric"或"timestamp"
          tracking_column_type => "timestamp"
              # 如果 use_column_value 为真,需配置数据表增量字段名,该字段必须是递增的. 一般序号或时间戳
          tracking_column => "last_modify_dt"
          last_run_metadata_path => "/data/logstash/config/sql_last_value"
    }
}
filter {
    mutate {
        # 将 keyword_tag 字段的内容通过 "," 分割成数组
        split => { "keyword_tag" => "," }
    }
    mutate {
        # 将 taxonomy 字段的内容中的前缀"/"和"//"替换为""。
        gsub => ["taxonomy", "^/(/)?", ""]
    }
}
output {
    elasticsearch {
        # Elasticsearch 服务IP和端口,账号和密码
        hosts => ["192.168.216.128:9200", "192.168.216.129:9200", "192.168.216.130:9200"]
        user => "elastic"
        password => "elastic"
        # 索引名
        index => "pgsql_index"
        # 需要关联的数据表中有一个uuid字段，对应索引文档的id号
        document_id => "%{uuid}"
    }
    stdout {
        codec => rubydebug
    }
}

4）验证 JOB 配置文件。

[centos@ETL ~]$ sudo -u elastic /usr/local/logstash-7.6.2/bin/logstash -f /data/logstash/config/pgsql.conf -t

其他配置请参加官方文档：

  • input（输入）配置：【https://www.elastic.co/guide/en/logstash/current/input-plugins.html】
  • filter（过滤器）配置：【https://www.elastic.co/guide/en/logstash/current/filter-plugins.html】
  • output（输出）配置：【https://www.elastic.co/guide/en/logstash/current/output-plugins.html】

注意：每个作业编写独立的配置脚本。

8、配置 Logstash 开机自启动。

使用文本编辑器创建配置文件：

[centos@ETL ~ ]$ sudo gedit /usr/lib/systemd/system/logstash.service

编写文件内容并保存如下：

[Unit]
Description=Logstash
After=syslog.target network.target

[Service]
User=elastic
Group=elastic

ExecStart=/usr/local/logstash-7.6.2/bin/logstash
ExecStop=/bin/kill -HUP $MAINPID
ExecReload=/bin/kill -HUP $MAINPID

KillMode=mixed
KillSignal=SIGINT

LimitNOFILE=100000
LimitNPROC=100000

[Install]
WantedBy=multi-user.target

设置开机启动：

[centos@ETL ~]$ sudo systemctl daemon-reload
[centos@ETL ~]$ sudo systemctl enable logstash.service

9、启动 Logstash 服务。

[centos@ETL ~]$ sudo systemctl start logstash.service

10、Logstash 运维管理

1）启动 Logstash 服务（任选一种方式）

[centos@ETL ~]$ sudo systemctl start logstash.service

或者

[centos@ETL ~]$ sudo -u elastic /usr/local/logstash-7.6.2/bin/logstash

2）停止 Logstash 服务（任选一种方式）

[centos@ETL ~]$ sudo systemctl stop logstash.service

或者

[centos@ETL ~]$ sudo ps -ef | grep logstash
elastic   26393  26391  5 11:01 ?        00:01:38 /bin/java...
[centos@ETL ~]$ sudo kill -9 26393

3）重启 Logstash 服务

[centos@ETL ~]$ sudo systemctl restart logstash.service

或者

[centos@ETL ~]$ sudo ps -ef | grep logstash
elastic   26393  26391  5 11:01 ?        00:01:38 /bin/java...
[centos@ETL ~]$ sudo kill -9 26393
[centos@ETL ~]$ sudo -u elastic /usr/local/logstash-7.6.2/bin/logstash

4）查看 Logstash 服务状态

[centos@ETL ~]$ sudo systemctl status logstash.service

或者

[centos@ETL ~]$ sudo -u elastic tail /data/logstash/logs/logstash-plain.log

5）启动 Logstash 服务开机自启动

[centos@ETL ~]$ sudo systemctl enable logstash.service

6）禁用 Logstash 服务开机自启动

[centos@ETL ~]$ sudo systemctl disable logstash.service

7.Java 开发集成

7.1.ES 编程语言

  • Elasticsearch: 权威指南：【https://www.elastic.co/guide/cn/elasticsearch/guide/current/index.html】
  • Elasticsearch 7.x 实战入门：【https://www.jianshu.com/nb/44794154】

7.2.ES + Jest 可复用类库

JestClient 是 Elasticsearch 的 JavaAPI 包，以下是 Maven 项目的程序案例。

1、从 Maven 库中引入 JestClient 包。


    io.searchbox
    jest-common
    6.3.1

2、编写 Elasticsearch 会话工厂类 "SearchSessionFacade.java"。

/**
 * 
 * ElasticSearch Libs
 * 
 * ©2020 张毅
 * 
 */

import com.google.gson.GsonBuilder;

import io.searchbox.client.JestClient;
import io.searchbox.client.JestClientFactory;
import io.searchbox.client.config.HttpClientConfig;

/**
 * ElasticSearch 会话工厂类 (ElasticSearch Session Factory)
 */
public class SearchSessionFactory {

    /** 请求服务地址 */
    private String[] serverUris;

    /** 是否启用多线程 */
    private boolean multiThreaded = true;

    /** 连接超时时长 */
    private int connTimeout = 10000;

    /** 数据读取超时时长 */
    private int readTimeout = 10000;

    /** 日期格式 */
    private String dateFormat = "yyyy-MM-dd HH:mm:ss";

    /** 访问账号 */
    private String user;

    /** 访问密码 */
    private String pass;

    /** Jest客户端 */
    private JestClient jestClient;

    /**
     * 获取请求服务地址。
     * 
     * @return 请求服务地址。
     */
    public String[] getServerUris() {
        return serverUris;
    }

    /**
     * 设置请求服务地址。
     * 
     * @param serverUris 请求服务地址。
     */
    public void setServerUris(String[] serverUris) {
        this.serverUris = serverUris;
    }

    /**
     * 获取是否启用多线程。
     * 
     * @return 启用多线程返回true，否则返回false。
     */
    public boolean isMultiThreaded() {
        return multiThreaded;
    }

    /**
     * 设置是否启用多线程。
     * 
     * @param multiThreaded 设置为true启用，false停用。
     */
    public void setMultiThreaded(boolean multiThreaded) {
        this.multiThreaded = multiThreaded;
    }

    /**
     * 获取连接超时时长（毫秒）。
     * 
     * @return 连接超时时长（毫秒）。
     */
    public int getConnTimeout() {
        return connTimeout;
    }

    /**
     * 设置连接超时时长（毫秒）。
     * 
     * @param connTimeout 连接超时时长（毫秒）。
     */
    public void setConnTimeout(int connTimeout) {
        this.connTimeout = connTimeout;
    }

    /**
     * 获取数据读取超时时长（毫秒）。
     * 
     * @return 数据读取超时时长（毫秒）。
     */
    public int getReadTimeout() {
        return readTimeout;
    }

    /**
     * 设置数据读取超时时长（毫秒）。
     * 
     * @param readTimeout 数据读取超时时长（毫秒）。
     */
    public void setReadTimeout(int readTimeout) {
        this.readTimeout = readTimeout;
    }

    /**
     * 获取日期格式。
     * 
     * @return 日期格式。
     */
    public String getDateFormat() {
        return dateFormat;
    }

    /**
     * 设置日期格式。
     * 
     * @param dateFormat 日期格式。
     */
    public void setDateFormat(String dateFormat) {
        this.dateFormat = dateFormat;
    }

    /**
     * 获取访问账号。
     * 
     * @return 访问账号。
     */
    public String getUser() {
        return user;
    }

    /**
     * 设置访问账号。
     * 
     * @param user 访问账号。
     */
    public void setUser(String user) {
        this.user = user;
    }

    /**
     * 获取访问密码。
     * 
     * @return 访问密码。
     */
    public String getPass() {
        return pass;
    }

    /**
     * 设置访问访问密码。
     * 
     * @param pass 访问密码。
     */
    public void setPass(String pass) {
        this.pass = pass;
    }

    /**
     * 获取Jest连接客户端。
     * 
     * @return Jest客户端。
     */
    public JestClient getJestClient() {

        if (jestClient == null) {
            jestClient = this.createJestClient();
        }
        return jestClient;
    }

    /**
     * 创建Jest客户端实例。
     * 
     * @return Jest客户端实例。
     */
    protected JestClient createJestClient() {

        JestClientFactory factory = new JestClientFactory();
        if (this.getUser() != null && !this.getUser().equals("") && this.getPass() != null
                && !this.getPass().equals("")) {
            factory.setHttpClientConfig(new HttpClientConfig.Builder(serverUris).multiThreaded(multiThreaded)
                    .connTimeout(connTimeout).readTimeout(readTimeout)
                    .gson(new GsonBuilder().setDateFormat(dateFormat).create()).defaultCredentials(user, pass).build());
            this.jestClient = factory.getObject();
        } else {
            factory.setHttpClientConfig(new HttpClientConfig.Builder(serverUris).multiThreaded(multiThreaded)
                    .connTimeout(connTimeout).readTimeout(readTimeout)
                    .gson(new GsonBuilder().setDateFormat(dateFormat).create()).build());
            this.jestClient = factory.getObject();
        }

        return this.jestClient;
    }
}

3、编写 Elasticsearch 会话类 "SearchSession.java"。

/**
 * 
 * ElasticSearch Libs
 * 
 * ©2020 张毅
 * 
 */

import java.util.Collection;
import java.util.List;
import java.util.Map;

import com.google.gson.JsonObject;

import io.searchbox.action.BulkableAction;
import io.searchbox.client.JestClient;
import io.searchbox.client.JestResult;
import io.searchbox.cluster.GetSettings;
import io.searchbox.cluster.Health;
import io.searchbox.cluster.NodesInfo;
import io.searchbox.cluster.NodesStats;
import io.searchbox.core.Bulk;
import io.searchbox.core.Count;
import io.searchbox.core.CountResult;
import io.searchbox.core.Delete;
import io.searchbox.core.DeleteByQuery;
import io.searchbox.core.Get;
import io.searchbox.core.Index;
import io.searchbox.core.MultiGet;
import io.searchbox.core.Search;
import io.searchbox.core.Search.Builder;
import io.searchbox.core.SearchResult;
import io.searchbox.core.SearchScroll;
import io.searchbox.core.Update;
import io.searchbox.core.UpdateByQuery;
import io.searchbox.indices.ClearCache;
import io.searchbox.indices.CloseIndex;
import io.searchbox.indices.CreateIndex;
import io.searchbox.indices.DeleteIndex;
import io.searchbox.indices.Flush;
import io.searchbox.indices.IndicesExists;
import io.searchbox.indices.OpenIndex;
import io.searchbox.indices.Optimize;
import io.searchbox.indices.aliases.AddAliasMapping;
import io.searchbox.indices.aliases.AliasExists;
import io.searchbox.indices.aliases.GetAliases;
import io.searchbox.indices.aliases.ModifyAliases;
import io.searchbox.indices.aliases.RemoveAliasMapping;
import io.searchbox.indices.mapping.DeleteMapping;
import io.searchbox.indices.mapping.GetMapping;
import io.searchbox.indices.mapping.PutMapping;
import io.searchbox.indices.settings.UpdateSettings;
import io.searchbox.indices.template.DeleteTemplate;
import io.searchbox.indices.template.GetTemplate;
import io.searchbox.indices.template.PutTemplate;
import io.searchbox.params.Parameters;

/**
 * ElasticSearch 会话类 (ElasticSearch Session)
 */
public class SearchSession {

    /** Jest客户端 */
    protected final JestClient jestClient;

    /**
     * 获取Jest连接客户端。
     * 
     * @return Jest客户端。
     */
    protected JestClient getJestClient() {

        return jestClient;
    }

    /**
     * 构造器。
     * 
     * @param factory ElasticSearch创建工厂。
     */
    public SearchSession(SearchSessionFactory factory) {

        this.jestClient = factory.getJestClient();
    }

    /**
     * 执行批量事务。
     * 
     * @param actions 事务动作集合。
     * @return 执行结果模型。
     */
    @SuppressWarnings("rawtypes")
    public JestResult executeBulk(Collection actions) {

        try {
            Bulk bulk = new Bulk.Builder().addAction(actions).build();
            JestResult jestResult = jestClient.execute(bulk);
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 优化。
     * 
     * @return 执行结果模型。
     */
    public JestResult optimize() {

        try {
            JestResult jestResult = jestClient.execute(new Optimize.Builder().build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 刷新。
     * 
     * @return 执行结果模型。
     */
    public JestResult flush() {

        try {
            JestResult jestResult = jestClient.execute(new Flush.Builder().build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 清除缓存。
     * 
     * @return 执行结果模型。
     */
    public JestResult clearCache() {

        try {
            JestResult jestResult = jestClient.execute(new ClearCache.Builder().build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取集群健康信息。
     * 
     * @return 执行结果模型。
     */
    public JestResult getClusterHealth() {

        try {
            JestResult jestResult = jestClient.execute(new Health.Builder().build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取节点信息。
     * 
     * @return 执行结果模型。
     */
    public JestResult getNodesInfo() {

        try {
            JestResult jestResult = jestClient.execute(new NodesInfo.Builder().build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取节点状态信息。
     * 
     * @return 执行结果模型。
     */
    public JestResult getNodesStats() {

        try {
            JestResult jestResult = jestClient.execute(new NodesStats.Builder().build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 更新配置。
     * 
     * @param setting 配置更新脚本JSON字符串。。
     * @return 执行结果模型。
     */
    public JestResult updateSettings(String setting) {

        try {
            JestResult jestResult = jestClient.execute(new UpdateSettings.Builder(setting).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 更新配置。
     * 
     * @param setting 配置更新脚本JSON模型。
     * @return 执行结果模型。
     */
    public JestResult updateSettings(JsonObject setting) {

        return this.updateSettings(setting.toString());
    }

    /**
     * 获取配置。
     * 
     * @return 执行结果模型。
     */
    public JestResult geSettings() {
        try {
            JestResult jestResult = jestClient.execute(new GetSettings.Builder().build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 创建索引。
     * 
     * @param index 索引名字。
     * @return 执行结果模型。
     */
    public JestResult createIndex(String index) {

        try {
            if (this.indicesExists(index).isSucceeded()) {
                this.deleteIndex(index);
            }
            JestResult jestResult = jestClient.execute(new CreateIndex.Builder(index).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 删除索引。
     * 
     * @param index 索引名字。
     * @return 执行结果模型。
     */
    public JestResult deleteIndex(String index) {

        try {
            JestResult jestResult = jestClient.execute(new DeleteIndex.Builder(index).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 判断索引是否存在。
     * 
     * @param index 索引名字。
     * @return 执行结果模型。
     */
    public JestResult indicesExists(String index) {
        try {
            JestResult jestResult = jestClient.execute(new IndicesExists.Builder(index).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 关闭索引。
     * 
     * @param index 索引名字。
     * @return 执行结果模型。
     */
    public JestResult closeIndex(String index) {

        try {
            JestResult jestResult = jestClient.execute(new CloseIndex.Builder(index).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 打开索引。
     * 
     * @param index 索引名字。
     * @return 执行结果模型。
     */
    public JestResult openIndex(String index) {

        try {
            JestResult jestResult = jestClient.execute(new OpenIndex.Builder(index).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 创建映射。
     * 
     * @param index   索引名字。
     * @param type    索引类型。
     * @param mapping 映射创建脚本JSON字符串。
     * @return 执行结果模型。
     */
    public JestResult putMappting(String index, String type, String mapping) {

        try {
            JestResult jestResult = jestClient.execute(new PutMapping.Builder(index, type, mapping).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 创建映射。
     * 
     * @param index   索引名字。
     * @param type    索引类型。
     * @param mapping 映射创建脚本JSON模型。
     * @return 执行结果模型。
     */
    public JestResult putMappting(String index, String type, JsonObject mapping) {

        return this.putMappting(index, type, mapping.toString());
    }

    /**
     * 删除映射。
     * 
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 执行结果模型。
     */
    public JestResult deleteMappting(String index, String type) {

        try {
            JestResult jestResult = jestClient.execute(new DeleteMapping.Builder(index, type).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取映射。
     * 
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 执行结果模型。
     */
    public JestResult getMappting(String index, String type) {

        try {
            JestResult jestResult = jestClient.execute(new GetMapping.Builder().addIndex(index).addType(type).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 创建别名。
     * 
     * @param indexes 索引名字列表。
     * @param alias   别名。
     * @return 执行结果模型。
     */
    public JestResult addAliasMapping(List indexes, String alias) {

        try {
            AddAliasMapping build = new AddAliasMapping.Builder(indexes, alias).build();
            JestResult jestResult = jestClient.execute(new ModifyAliases.Builder(build).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 删除别名。
     * 
     * @param indexes 索引名字列表。
     * @param alias   别名。
     * @return 执行结果模型。
     */
    public JestResult deleteAliasMapping(List indexes, String alias) {

        try {
            RemoveAliasMapping build = new RemoveAliasMapping.Builder(indexes, alias).build();
            JestResult jestResult = jestClient.execute(new ModifyAliases.Builder(build).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 判断别名是否存在。
     * 
     * @param alias 别名。
     * @return 执行结果模型。
     */
    public JestResult aliasExists(String alias) {

        try {
            JestResult jestResult = jestClient.execute(new AliasExists.Builder().alias(alias).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取别名。
     * 
     * @param indexes 索引名字列表。
     * @param alias   别名。
     * @return 执行结果模型。
     */
    public JestResult getAliases(String index) {

        try {
            JestResult jestResult = jestClient.execute(new GetAliases.Builder().addIndex(index).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 创建模板。
     * 
     * @param name     模板名字。
     * @param template 模板创建脚本JSON字符串。
     * @return 执行结果模型。
     */
    public JestResult putTemplate(String name, String template) {

        try {
            JestResult jestResult = jestClient.execute(new PutTemplate.Builder(name, template).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 创建模板。
     * 
     * @param name     模板名字。
     * @param template 模板创建脚本JSON模型。
     * @return 执行结果模型。
     */
    public JestResult putTemplate(String name, JsonObject template) {

        return this.putTemplate(name, template.toString());
    }

    /**
     * 删除模板。
     * 
     * @param name 模板名字。
     * @return 执行结果模型。
     */
    public JestResult deleteTemplate(String name) {

        try {
            JestResult jestResult = jestClient.execute(new DeleteTemplate.Builder(name).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取模板。
     * 
     * @param name 模板名字。
     * @return 执行结果模型。
     */
    public JestResult getTemplate(String name) {

        try {
            JestResult jestResult = jestClient.execute(new GetTemplate.Builder(name).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 插入文档。
     * 
     * @param doc   文档。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 执行结果模型。
     */
    public JestResult insertDocuments(List> docs, String index, String type) {

        try {
            Bulk.Builder bulk = new Bulk.Builder().defaultIndex(index);
            for (Map doc : docs) {
                Index action;
                if (doc.get("id") != null) {
                    action = new Index.Builder(doc).id(doc.get("id").toString()).index(index).type(type).build();
                    bulk.addAction(action);
                } else {
                    action = new Index.Builder(doc).index(index).build();
                    bulk.addAction(action);
                }
            }
            JestResult jestResult = jestClient.execute(bulk.build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 插入文档。
     * 
     * @param doc   文档。
     * @param id    文档ID。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 执行结果模型。
     */
    public JestResult insertDocument(Map doc, String id, String index, String type) {

        try {
            JestResult jestResult = jestClient.execute(new Index.Builder(doc).id(id).index(index).type(type).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 插入文档。
     * 
     * @param doc   文档。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 执行结果模型。
     */
    public JestResult insertDocument(Map doc, String index, String type) {

        try {
            if (doc.get("id") != null) {
                JestResult jestResult = jestClient
                        .execute(new Index.Builder(doc).id(doc.get("id").toString()).index(index).type(type).build());
                if (!jestResult.isSucceeded()) {
                    throw new Exception(jestResult.getErrorMessage());
                }
                return jestResult;
            } else {
                JestResult jestResult = jestClient.execute(new Index.Builder(doc).index(index).type(type).build());
                if (!jestResult.isSucceeded()) {
                    throw new Exception(jestResult.getErrorMessage());
                }
                return jestResult;
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 更新文档。
     * 
     * @param doc   文档。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 执行结果模型。
     */
    public JestResult updateDocuments(List> docs, String index, String type) {

        try {
            Bulk.Builder bulk = new Bulk.Builder().defaultIndex(index);
            for (Map doc : docs) {
                Update action;
                if (doc.get("id") != null) {
                    action = new Update.Builder(doc).id(doc.get("id").toString()).index(index).type(type).build();
                    bulk.addAction(action);
                }
            }
            JestResult jestResult = jestClient.execute(bulk.build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 更新文档。
     * 
     * @param doc   文档。
     * @param id    文档ID。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 执行结果模型。
     */
    public JestResult updateDocument(Map doc, String id, String index, String type) {

        try {
            JestResult jestResult = jestClient.execute(new Update.Builder(doc).id(id).index(index).type(type).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 更新文档。
     * 
     * @param doc   文档。
     * @param id    文档ID。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 执行结果模型。
     */
    public JestResult updateDocument(Map doc, String index, String type) {

        try {
            if (doc.get("id") != null) {
                JestResult jestResult = jestClient
                        .execute(new Update.Builder(doc).id(doc.get("id").toString()).index(index).type(type).build());
                if (!jestResult.isSucceeded()) {
                    throw new Exception(jestResult.getErrorMessage());
                }
                return jestResult;
            }
            return null;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 更新文档。
     * 
     * @param query 查询脚本JSON字符串。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 执行结果模型。
     */
    public JestResult updateDocumentByQuery(String query, String index, String type) {

        try {
            JestResult jestResult = jestClient
                    .execute(new UpdateByQuery.Builder(query).addIndex(index).addType(type).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    /**
     * 更新文档。
     * 
     * @param query 查询脚本JSON模型。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 执行结果模型。
     */
    public JestResult updateDocumentByQuery(JsonObject query, String index, String type) {

        try {
            JestResult jestResult = jestClient
                    .execute(new UpdateByQuery.Builder(query.toString()).addIndex(index).addType(type).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 删除文档。
     * 
     * @param ids   文档ID。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 执行结果模型。
     */
    public JestResult deleteDocuments(String[] ids, String index, String type) {

        try {
            Bulk.Builder bulk = new Bulk.Builder().defaultIndex(index).defaultType(type);
            for (String id : ids) {
                Delete action = new Delete.Builder(id).build();
                bulk.addAction(action);
            }
            JestResult jestResult = jestClient.execute(bulk.build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 删除文档。
     * 
     * @param id    文档ID。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 执行结果模型。
     */
    public JestResult deleteDocument(String id, String index, String type) {

        try {
            JestResult jestResult = jestClient.execute(new Delete.Builder(id).index(index).type(type).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 删除文档。
     * 
     * @param query 查询脚本。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 执行结果模型。
     */
    public JestResult deleteDocumentByQuery(String query, String index, String type) {

        try {
            JestResult jestResult = jestClient
                    .execute(new DeleteByQuery.Builder(query).addIndex(index).addType(index).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 删除文档。
     * 
     * @param query 查询脚本JSON模型。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 执行结果模型。
     */
    public JestResult deleteDocumentByQuery(JsonObject query, String index, String type) {

        try {
            JestResult jestResult = jestClient
                    .execute(new DeleteByQuery.Builder(query.toString()).addIndex(index).addType(index).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取指定ID的文档。
     * 
     * @param ids   文档ID集合。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 指定ID的文档JSON模型集合。
     */
    public List getDocumentsByIds(List ids, String index, String type) {

        try {
            JestResult jestResult = jestClient.execute(new MultiGet.Builder.ById(index, type).addId(ids).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            List docs = jestResult.getSourceAsObjectList(JsonObject.class);
            return docs;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取指定ID。
     * 
     * @param id    文档ID。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 指定ID的文档JSON模型。
     */
    public JsonObject getDocumentsById(String id, String index, String type) {

        try {
            JestResult jestResult = jestClient.execute(new Get.Builder(index, id).type(type).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            JsonObject doc = jestResult.getSourceAsObject(JsonObject.class);
            return doc;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取文档数量。
     * 
     * @param search 查询脚本JSON字符串。
     * @param index  索引名字。
     * @param type   索引类型。
     * @return 文档数量。
     */
    public Double getDocumentCount(String query, String index, String type) {

        try {
            CountResult jestResult = jestClient
                    .execute(new Count.Builder().query(query).addIndex(index).addType(type).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult.getCount();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取文档数量。
     * 
     * @param query 查询脚本JSON模型。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 文档数量。
     */
    public Double getDocumentCount(JsonObject query, String index, String type) {

        return this.getDocumentCount(query.toString(), index, type);
    }

    /**
     * 查询文档。
     * 
     * @param query 查询脚本JSON字符串。
     * @param from  页起点。
     * @param size  页长度。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 查询结果模型。
     */
    public SearchResult search(String query, Integer from, Integer size, String index, String type) {

        try {
            Builder builder = new Search.Builder(query).addIndex(index).addType(type)
                    .setParameter(Parameters.SIZE, size != null && size > 0 ? size : 15)
                    .setParameter(Parameters.FROM, from != null && from > 0 ? from : 0);
            SearchResult result = jestClient.execute(builder.build());
            if (!result.isSucceeded()) {
                throw new Exception(result.getErrorMessage());
            }
            return result;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 查询文档。
     * 
     * @param query 查询脚本JSON模型。
     * @param from  页起点。
     * @param size  页长度。
     * @param index 索引名字。
     * @param type  索引类型。
     * @return 查询结果模型。
     */
    public SearchResult search(JsonObject query, Integer from, Integer size, String index, String type) {

        return this.search(query.toString(), from, size, index, type);
    }

    /**
     * 向后滚动查询文档。
     * 
     * @param scrollId 向后滚动ID。
     * @param scroll   有效时间，如："5m"。
     * @return 查询结果模型。
     */
    public JestResult search(String scrollId, String scroll) {

        try {
            JestResult jestResult = jestClient.execute(new SearchScroll.Builder(scrollId, scroll).build());
            if (!jestResult.isSucceeded()) {
                throw new Exception(jestResult.getErrorMessage());
            }
            return jestResult;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 向后滚动查询文档。
     * 
     * @param scrollId 向后滚动ID。
     * @return 查询结果模型。
     */
    public JestResult search(String scrollId) {

        return this.search(scrollId, "5m");
    }

    /**
     * 实例回收方法。
     */
    @Override
    protected void finalize() throws Throwable {

        if (this.jestClient != null) {
            this.jestClient.close();
        }
        super.finalize();
    }
}

4、编写主程序。

1）编写 Elasticsearch 连接文件 "elasticsearch.properties" 。

es.serverUri=http://192.168.216.128:9200
es.multiThreaded=true
es.connTimeout=10000
es.readTimeout=10000
es.dateFormat=yyyy-MM-dd HH:mm:ss
es.user=elastic
es.pass=elastic

2）编写主程序文件 "JestApp.java"。

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.ResourceBundle;

public class JestApp {
    
    public static void main( String[] args ) {
        
        // 获取 Elasticsearch 连接文件信息
        ResourceBundle resource = ResourceBundle.getBundle("elasticsearch");
        
        String serverUri = resource.getString("serverUri");
        String multiThreaded = resource.getString("multiThreaded");
        String connTimeout = resource.getString("connTimeout");
        String readTimeout = resource.getString("readTimeout");
        String dateFormat = resource.getString("dateFormat");
        String user = resource.getString("user");
        String pass = resource.getString("pass");
        
        // 定义 Elasticsearch 连接工厂的实例
        SearchSessionFactory factory = new SearchSessionFactory();
        
        factory.setServerUri(serverUri);
        factory.setMultiThreaded(Boolean.valueOf(multiThreaded));
        factory.setConnTimeout(Integer.valueOf(connTimeout));
        factory.setReadTimeout(Integer.valueOf(readTimeout));
        factory.setDateFormat(dateFormat);
        factory.setUser(user);
        factory.setPass(pass);
        
        // 定义  Elasticsearch 连接会话
        SearchSession session = new SearchSession(factory);
        
        // 索引名称
        String index = "pgsql_index";
        
        // 索引文档类型，固定值
        String type = "_doc";
        
        // 文档ID
        String id = "document_id";
        
        // 文档内容，一个空文档。
        Map doc = new LinkedHashMap();
        
        // 创建索引
        session.createIndex(index);
        
        // 删除索引
        session.deleteIndex(index);
        
        // 验证索引是否存在
        session.indicesExists(index);
        
        // 打开索引
        session.openIndex(index);
        
        // 关闭索引
        session.closeIndex(index);
        
        // 插入文档
        session.insertDocument(doc, id, index, type);
        
        // 更新文档
        session.updateDocument(doc, id, index, type);
        
        // 删除文档
        session.deleteDocument(id, index, type);
        
        // 获取指定ID的文档
        session.getDocumentsById(id, index, type);
        
        // 查询全部数据的前10个文档
        String query = "{\"query\": {\"match_all\": {}}}";
        session.search(query, 0, 10, index, type);
    }
}

7.3.ELK + Jest 最佳集成方案

Elasticsearch 作为 OLAP 数据库，它的数据一般都是来源于业务系统的持久化数据库中，如：PostgreSQL、MySQL、Oracle、SQLServer 等 RDBMS 数据库或 MongoDB 等 NoSQL数据库。基于类似场景，建议通过以下方式来完成 Elasticsearch、Kibana、Logstash、Jest 的集成使用：

1、使用 Kibana 创建和管理 Elasticsearch 模板。

Elasticsearch 支持通过模板来定义索引格式，模板可以应用于索引名称中包含指定字符的索引，它实现在创建索引时，将索引中包含指定字符的属性设置为特定的格式。使用 Kibana 在 Elasticsearch 中一次性创建模板。例如：

PUT _template/pgsql_template
{
  "version": 1,
  "order": 1,
  "index_patterns": [
    "pgsql-*"
  ],
  "settings": {
    "index": {
      "analysis": {
        "analyzer": {
          "ik_smart_analyzer": {
            "tokenizer": "ik_smart"
          }
        }
      },
      "number_of_shards": "3",
      "number_of_replicas": "3",
      "refresh_interval": "5s"
    }
  },
  "mappings": {
    "dynamic_templates": [
      {
        "tag_field": {
          "mapping": {
            "norms": false,
            "type": "keyword"
          },
          "match_mapping_type": "string",
          "match": "*_tag"
        }
      },
      {
        "msg_field": {
          "mapping": {
            "anaylzer": "ik_smart_analyzer",
            "norms": false,
            "type": "text"
          },
          "match_mapping_type": "string",
          "match": "*_msg"
        }
      },
      {
        "str_fields": {
          "mapping": {
            "anaylzer": "ik_smart_analyzer",
            "norms": false,
            "type": "text",
            "fields": {
              "keyword": {
                "ignore_above": 256,
                "type": "keyword"
              }
            }
          },
          "match_mapping_type": "string",
          "match": "*"
        }
      }
    ]
  }
}

在上面的模板设置中，它设置了以下内容：

1）"index_patterns" 中定义将索引名称前缀为 "pgsql-" 的索引在创建时应用此模板。

2） "settings" 中定义了索引使用的分词器、分片和刷新时间等参数。

3） "mappings" 中定义了以下规则：

  • 名称以 "_tag" 结尾的属性，其类型为不支持分词的 keyword 数组；
  • 名称以 "_msg" 结尾的属性，其类型为支持中文分词、拼音分词的文本，且对全部分词进行索引；
  • 其他所有属性，其类型为支持中文分词、拼音分词的 text 文本，但只对前256个字符进行索引。

2、使用 Logstash 创建索引和插入、更新文档。

Logstash 可以高效的从数据库层面完成从业务数据库抽取数据，经过简单的过滤处理之后，向 Elasticsearch 中根据文档ID来插入或更新文档，但不能物理删除文档。在插入文档时，如果索引不存在则自动创建索引。

3、使用 Jest 删除索引、文档。

因为 Logstash 不能完成物理删除文档的处理，因此应用在业务数据库中进行物理数据删除操作时，需要使用 Jest 调用 API 同步将这些数据在 Elasticsearch 中删除。

你可能感兴趣的:(数据库架构之【ELK（Elasticsearch+Logstash+Kibana）】OLAP 集群方案)

  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿 小鹿_33
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
  • 《大清方方案》| 第二话 谁佐清欢
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
  • 《庄子.达生9》 钱江潮369
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • 2020-04-12每天三百字之连接与替代 冷眼看潮
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库python
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
  • 东南林氏之九牧林候选父系 祖缘树TheYtree
    渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
  • 大伟说成语之唉声叹气 求索大伟
    ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
  • libyuv之linux编译 jaronho Linuxlinux运维服务器
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
  • CX8903：Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片 诚芯微科技 社交电子
    CX8903：电动Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片推荐。电动助力自行车EBIKE凭借其环保、健康、低噪、和便捷等特点，成为了越来越受欢迎的骑行便利交通工具。提供电动Ebike自行车仪表电源方案开发、E-BIKE电动助力自行车仪表供电电源解决方案。CX8903采用100V高压制造工艺（芯片最高耐压可到100V以上），SOP-8L贴片封装，CX8903内置100V/90mΩ
  • CX8836：小体积大功率升降压方案推荐（附Demo设计指南） 诚芯微科技 社交电子
    CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
  • 怎么做淘客赚钱(2022最新免费淘客盈利的方法) 高省_飞智666600
    很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 锁之缘 尘缘诗词原创作品
    是谁追寻梦的足迹，是谁在偷偷的哭泣，日月隔离在黑白天地情感在心中蔓延的痕迹天与地的距离有多远流失的星晨落入哪片空间不要让泪水模糊双眼心牢中一样充满温暖谁说爱情没有永远白娘子又为何爱许仙蝴蝶墓地展翅翩翩轻歌慢舞袖卷人间传奇千古留爱万年…………月落星飞徘徊是选择不去问自已为合舍不得寂寞本就是痛苦的不在追寻梦中的痕迹才不会失去真实的自已
  • 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
  • Low Power概念介绍-Voltage Area 飞奔的大虎
    随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • 2020-12-24 我和我的天使们
    阅读《老子的心事》391—403“将欲取之，必固与之”：想要得到什么，首先就要送出什么。我常常对孩子们说，你希望别人怎样对你你就怎样对待别人。想要得到别人的尊重，首先要尊重别人。我希望她们可以不迟到，因为不迟到是对别人的尊重，我就自己就先做到不迟到。哪怕是约朋友逛街，我尽量准时赴约。我严格要求孩子们，也同样严格要求自己，我跟孩子们一起把好的品格变成习惯。“是谓微明”：这就是微妙的智慧。看起来很少很
  • 18、架构-可观测性之聚合度量 大树~~ 架构javapython后端架构
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
  • 摩托车加装车载手机充电usb方案/雅马哈USB充电方案开发 诚芯微科技 社交电子
    长途骑行需要给手机与行车记录仪等设备供电，那么，加装USB充电器就相继在两轮电动车上应用起来了。摩托车加装usb充电方案主要应用于汽车、电动自行车、摩托车、房车、渡轮、游艇等交通工具。提供电动车USB充电器方案/摩托车加装usb充电方案/渡轮加装usb充电方案/游艇加装usb充电方案开发。摩托车加装车载手机充电usb方案、汽车游艇改装四孔面板装双USB车充点烟器5V/4A电动车USB充电器输入4.
  • 学习“论语”-第59天 春峰轩
    12.14子张问政。子曰：“居之无倦，行之以忠。”子张问为政之道。孔子说：“在位尽职不懈怠，执行政令要忠诚。”12.15子曰：“博学于文，约之以礼，亦可以弗畔矣夫！”孔子说：“君子广泛地学习文献，并且用礼节约束自己，也就不会离经叛道了。”12.16子曰：“君子成人之美，不成人之恶。小人反是。”孔子说：“君子成全别人的好事，而不助长别人的坏处。小人则与此相反行事。”知识点:“成人之美，不成人之恶”贯
  • 2021-11-15 宙火
    我给宋小姐写了首诗，是我在课上因思恋宋小姐而写的。“自古多情是唐宋，从来双飞归巢燕。邻家小女相聘婷，常使春意荡漾我。不知单思可为爱，惟愿一心付之汝。”我拿给宋小姐看了，她说我写得很棒。我很开心，但又不是那么开心。宋小姐是回复我了，但也只是说我写得很棒，对我诗句中蕴藏的真切感情，不知道是真的没发现，还是装作没发现。但我不深究，只是这样，我就很开心了。我答应宋小姐，一天给她写一首诗。
  • 《我的青葱岁月之缘来是你》 第二章 迎新晚会 思源思缘思怨
    “怎么你也来了这里？”我愉快的问到，想着这是上天给的缘分吗？我还没去找他竟然就相遇了。那个让我开心的老乡。“你好，我也是舞蹈社的新人啊！”他说，笑起来回答我，眼睛弯弯的。“这么巧，我叫吴倩，你叫啥？”“我叫韩欢，你也是B市人吧，c中毕业的？”“我不是，我是f中的，不然肯定会认识你的”“是吗？以后多多关照了”他还冲我眨了眨眼睛。内心一阵悸动，这是……回到寝室，我兴奋的告诉我的室友这个事情，我再次觉得
  • OPENAIGC开发者大赛企业组AI黑马奖 | AIGC数智传媒解决方案 RPA中国 人工智能AIGC传媒
    在第二届拯救者杯OPENAIGC开发者大赛中，涌现出一批技术突出、创意卓越的作品。为了让这些优秀项目被更多人看到，我们特意开设了优秀作品报道专栏，旨在展示其独特之处和开发者的精彩故事。无论您是技术专家还是爱好者，希望能带给您不一样的知识和启发。让我们一起探索AIGC的无限可能，见证科技与创意的完美融合！创未来AI应用赛-企业组AI黑马奖作品名称：AIGC数智传媒解决方案参赛团队：深圳市三象智能技术
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • 厦门自由行之第一天: 大苏子在广漂
    厦门三人行之杂记出发前一天:12️28日下午15:00从广州粗发，来深圳集合！但是中间发生一个小插曲，验票时候发现车票不见了，或许也是一场恶作剧，对于不排队的人，忍不住说了一下，接下来就发现车票不见了，已经是拿在手上！不过还好，可以凭借购票订单查看到信息，所以有惊无险，顺利进站！晚上三个人一起去吃了柠檬鱼，说实话，那会，感觉美吃饱，啊哈哈！晚上回来，两个人又开始彻夜长谈，发现身边优秀的人，一大把，
  • Xinference如何注册自定义模型 玩人工智能的辣条哥 人工智能AI大模型Xinference
    环境：Xinference问题描述：Xinference如何注册自定义模型解决方案：1.写个model_config.json，内容如下{"version":1,"context_length":2048,"model_name":"custom-llama-3","model_lang":["en","ch"],"model_ability":["generate","chat"],"model
  • Spring的注解积累 yijiesuifeng spring注解
    用注解来向Spring容器注册Bean。   需要在applicationContext.xml中注册： <context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。 如：在base-package指明一个包    <context:component-sc
  • 传感器 百合不是茶 android传感器
    android传感器的作用主要就是来获取数据,根据得到的数据来触发某种事件   下面就以重力传感器为例;   1,在onCreate中获得传感器服务   private SensorManager sm;// 获得系统的服务 private Sensor sensor;// 创建传感器实例 @Override protected void
  • [光磁与探测]金吕玉衣的意义 comsci
          这是一个古代人的秘密:现在告诉大家       信不信由你们:       穿上金律玉衣的人,如果处于灵魂出窍的状态,可以飞到宇宙中去看星星       这就是为什么古代
  • 精简的反序打印某个数 沐刃青蛟 打印
    以前看到一些让求反序打印某个数的程序。 比如：输入123，输出321。   记得以前是告诉你是几位数的，当时就抓耳挠腮，完全没有思路。   似乎最后是用到%和/方法解决的。   而今突然想到一个简短的方法，就可以实现任意位数的反序打印（但是如果是首位数或者尾位数为0时就没有打印出来了）   代码如下： long num, num1=0;
  • PHP：6种方法获取文件的扩展名 IT独行者 PHP扩展名
      PHP：6种方法获取文件的扩展名   1、字符串查找和截取的方法   1 $extension = substr ( strrchr ( $file ,  '.' ), 1); 2、字符串查找和截取的方法二   1 $extension = substr
  • 面试111 文强chu 面试
    1事务隔离级别有那些 ，事务特性是什么（问到一次） 2 spring aop 如何管理事务的，如何实现的。动态代理如何实现，jdk怎么实现动态代理的，ioc是怎么实现的，spring是单例还是多例，有那些初始化bean的方式，各有什么区别（经常问） 3 struts默认提供了那些拦截器 （一次） 4 过滤器和拦截器的区别 （频率也挺高） 5 final，finally final
  • XML的四种解析方式 小桔子 domjdomdom4jsax
    在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。 　　预 备 　　测试环境： 　　AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server
  • wordpress中常见的操作 aichenglong 中文注册wordpress移除菜单
    1 wordpress中使用中文名注册解决办法   1)使用插件   2)修改wp源代码      进入到wp-include/formatting.php文件中找到       function sanitize_user( $username, $strict = false
  • 小飞飞学管理-1 alafqq 管理
    项目管理的下午题，其实就在提出问题（挑刺），分析问题，解决问题。 今天我随意看下10年上半年的第一题。主要就是项目经理的提拨和培养。 结合我自己经历写下心得 对于公司选拔和培养项目经理的制度有什么毛病呢？ 1，公司考察，选拔项目经理，只关注技术能力，而很少或没有关注管理方面的经验，能力。 2，公司对项目经理缺乏必要的项目管理知识和技能方面的培训。 3，公司对项目经理的工作缺乏进行指
  • IO输入输出部分探讨 百合不是茶 IO
     //文件处理  在处理文件输入输出时要引入java.IO这个包； /* 1，运用File类对文件目录和属性进行操作 2，理解流，理解输入输出流的概念 3，使用字节/符流对文件进行读/写操作 4，了解标准的I/O 5，了解对象序列化 */   //1，运用File类对文件目录和属性进行操作   //在工程中线创建一个text.txt
  • getElementById的用法 bijian1013 element
            getElementById是通过Id来设置/返回HTML标签的属性及调用其事件与方法。用这个方法基本上可以控制页面所有标签，条件很简单，就是给每个标签分配一个ID号。        返回具有指定ID属性值的第一个对象的一个引用。        语法： &n
  • 励志经典语录 bijian1013 励志人生
    经典语录1:   哈佛有一个著名的理论：人的差别在于业余时间，而一个人的命运决定于晚上8点到10点之间。每晚抽出2个小时的时间用来阅读、进修、思考或参加有意的演讲、讨论，你会发现，你的人生正在发生改变，坚持数年之后，成功会向你招手。不要每天抱着QQ/MSN/游戏/电影/肥皂剧……奋斗到12点都舍不得休息，看就看一些励志的影视或者文章，不要当作消遣；学会思考人生，学会感悟人生
  • [MongoDB学习笔记三]MongoDB分片 bit1129 mongodb
    MongoDB的副本集(Replica Set)一方面解决了数据的备份和数据的可靠性问题，另一方面也提升了数据的读写性能。MongoDB分片(Sharding)则解决了数据的扩容问题，MongoDB作为云计算时代的分布式数据库，大容量数据存储，高效并发的数据存取，自动容错等是MongoDB的关键指标。 本篇介绍MongoDB的切片(Sharding)   1.何时需要分片 &nbs
  • 【Spark八十三】BlockManager在Spark中的使用场景 bit1129 manager
    1. Broadcast变量的存储，在HttpBroadcast类中可以知道 2. RDD通过CacheManager存储RDD中的数据，CacheManager也是通过BlockManager进行存储的 3. ShuffleMapTask得到的结果数据，是通过FileShuffleBlockManager进行管理的，而FileShuffleBlockManager最终也是使用BlockMan
  • yum方式部署zabbix ronin47 yum方式部署zabbix
    安装网络yum库#rpm -ivh http://repo.zabbix.com/zabbix/2.4/rhel/6/x86_64/zabbix-release-2.4-1.el6.noarch.rpm 通过yum装mysql和zabbix调用的插件还有agent代理#yum install zabbix-server-mysql zabbix-web-mysql mysql-
  • Hibernate4和MySQL5.5自动创建表失败问题解决方法 byalias J2EEHibernate4
    今天初学Hibernate4，了解了使用Hibernate的过程。大体分为4个步骤： ①创建hibernate.cfg.xml文件 ②创建持久化对象 ③创建*.hbm.xml映射文件 ④编写hibernate相应代码 在第四步中，进行了单元测试，测试预期结果是hibernate自动帮助在数据库中创建数据表，结果JUnit单元测试没有问题，在控制台打印了创建数据表的SQL语句，但在数据库中
  • Netty源码学习-FrameDecoder bylijinnan javanetty
    Netty 3.x的user guide里FrameDecoder的例子，有几个疑问： 1.文档说：FrameDecoder calls decode method with an internally maintained cumulative buffer whenever new data is received. 为什么每次有新数据到达时，都会调用decode方法？ 2.Dec
  • SQL行列转换方法 chicony 行列转换
    create table tb(终端名称 varchar(10) , CEI分值 varchar(10) , 终端数量 int) insert into tb values('三星' , '0-5' , 74) insert into tb values('三星' , '10-15' , 83) insert into tb values('苹果' , '0-5' , 93)
  • 中文编码测试 ctrain 编码
    循环打印转换编码 String[] codes = { "iso-8859-1", "utf-8", "gbk", "unicode" }; for (int i = 0; i < codes.length; i++) { for (int j
  • hive 客户端查询报堆内存溢出解决方法 daizj hive堆内存溢出
    hive> select * from t_test where ds=20150323 limit 2; OK Exception in thread "main" java.lang.OutOfMemoryError: Java heap space   问题原因： hive堆内存默认为256M   这个问题的解决方法为： 修改/us
  • 人有多大懒，才有多大闲 (评论『卓有成效的程序员』) dcj3sjt126com 程序员
      卓有成效的程序员给我的震撼很大，程序员作为特殊的群体，有的人可以这么懒，  懒到事情都交给机器去做 ，而有的人又可以那么勤奋，每天都孜孜不倦得做着重复单调的工作。   在看这本书之前，我属于勤奋的人，而看完这本书以后，我要努力变成懒惰的人。 不要在去庞大的开始菜单里面一项一项搜索自己的应用程序，也不要在自己的桌面上放置眼花缭乱的快捷图标
  • Eclipse简单有用的配置 dcj3sjt126com eclipse
    1、显示行号  Window -- Prefences -- General -- Editors -- Text Editors -- show line numbers   2、代码提示字符 Window ->Perferences，并依次展开 Java -> Editor -> Content Assist，最下面一栏 auto-Activation
  • 在tomcat上面安装solr4.8.0全过程 eksliang Solrsolr4.0后的版本安装solr4.8.0安装
    转载请出自出处： http://eksliang.iteye.com/blog/2096478       首先solr是一个基于java的web的应用，所以安装solr之前必须先安装JDK和tomcat，我这里就先省略安装tomcat和jdk了         第一步：当然是下载去官网上下载最新的solr版本，下载地址
  • Android APP通用型拒绝服务、漏洞分析报告 gg163 漏洞androidAPP分析
    点评：记得曾经有段时间很多SRC平台被刷了大量APP本地拒绝服务漏洞，移动安全团队爱内测（ineice.com）发现了一个安卓客户端的通用型拒绝服务漏洞，来看看他们的详细分析吧。  0xr0ot和Xbalien交流所有可能导致应用拒绝服务的异常类型时，发现了一处通用的本地拒绝服务漏洞。该通用型本地拒绝服务可以造成大面积的app拒绝服务。  针对序列化对象而出现的拒绝服务主要
  • HoverTree项目已经实现分层 hvt 编程.netWebC#ASP.ENT
    HoverTree项目已经初步实现分层，源代码已经上传到 http://hovertree.codeplex.com请到SOURCE CODE查看。在本地用SQL Server 2008 数据库测试成功。数据库和表请参考：http://keleyi.com/a/bjae/ue6stb42.htmHoverTree是一个ASP.NET 开源项目，希望对你学习ASP.NET或者C#语言有帮助，如果你对
  • Google Maps API v3: Remove Markers 移除标记 天梯梦 google maps api
    Simply do the following:   I. Declare a global variable: var markersArray = [];   II. Define a function: function clearOverlays() { for (var i = 0; i < markersArray.length; i++ )
  • jQuery选择器总结 lq38366 jquery选择器
      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
  • 基础数据结构和算法六：Quick sort sunwinner AlgorithmQuicksort
    Quick sort is probably used more widely than any other. It is popular because it is not difficult to implement, works well for a variety of different kinds of input data, and is substantially faster t
  • 如何让Flash不遮挡HTML div元素的技巧_HTML/Xhtml_网页制作 刘星宇 htmlWeb
    今天在写一个flash广告代码的时候，因为flash自带的链接，容易被当成弹出广告，所以做了一个div层放到flash上面，这样链接都是a触发的不会被拦截，但发现flash一直处于div层上面，原来flash需要加个参数才可以。 让flash置于DIV层之下的方法，让flash不挡住飘浮层或下拉菜单，让Flash不档住浮动对象或层的关键参数：wmode=opaque。 方法如下：
  • Mybatis实用Mapper SQL汇总示例 wdmcygah sqlmysqlmybatis实用
    Mybatis作为一个非常好用的持久层框架，相关资料真的是少得可怜，所幸的是官方文档还算详细。本博文主要列举一些个人感觉比较常用的场景及相应的Mapper SQL写法，希望能够对大家有所帮助。 不少持久层框架对动态SQL的支持不足，在SQL需要动态拼接时非常苦恼，而Mybatis很好地解决了这个问题，算是框架的一大亮点。对于常见的场景，例如：批量插入/更新/删除，模糊查询，多条件查询，联表查询，
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他