1、本章面试题
https://www.cnblogs.com/heqiyoujing/p/11146178.html
2、知识点
2.1、课程回顾
mycat 数据库中间件（mysql集群，读写分离）
mysql主从配置
master ：配置二进制文件，把所有的写操作，以日志方式记录到配置的文件里面
slave:两个线程，一个IO文件读写线程，读写到中继文件，另外一个SQL线程，执行中继文件中的SQL语句，最终实现主从。
读写分离的好处:数据库操作过程读多写少，读操作，负载均衡，当高并发下，读操作多的时候，会减轻服务器的压力。
2.2、本章重点
es =elastic(灵活的) search (查询)
什么是全文检索，常用全文检索框架的基本原理是什么
es是什么，主要使用场景
es分布式搜索引擎的搭建
3、具体内容
官网：
文档教程:
https://www.elastic.co/guide/en/elasticsearch/reference/6.0/getting-started.html
3.0 全文检索
我们生活中的数据总体分为三种：结构化数据，非结构化数据，半结构化数据
结构化数据：指具有固定格式或有限长度的数据，如数据库，元数据等。
非结构化数据：指不定长或无固定格式的数据，如邮件，word文档等
半结构化数据，如XML，HTML等
非结构化数据又一种叫法叫全文数据。
对结构化数据的搜索：如对数据库的搜索，用SQL语句。
再如对元数据的搜索，如利用windows搜索对文件名，类型，修改时间进行搜索等。
对非结构化数据的搜索：如利用windows的搜索也可以搜索文件内容，Linux下的grep命令，再如用Google和百度可以搜索大量内容数据。
非结构化数据搜索方法
顺序扫描:比如要找内容包含某一个字符串的文件，就是一个文档一个文档的看，对于每一个文档，从头看到尾，如果此文档包含此字符串，则此文档为我们要找的文件，接着看下一个文件，直到扫描完所有的文件。
如利用windows的搜索也可以搜索文件内容，只是相当的慢。如果你有一个80G硬盘，如果想在上面找到一个内容包含某字符串的文件，不花他几个小时，怕是做不到。
Linux下的grep命令也是这一种方式。大家可能觉得这种方法比较原始，但对于小数据量的文件，这种方法还是最直接，最方便的。但是对于大量的文件，这种方法就很慢了。
全文检索的基本思路：将非结构化数据中的一部分信息提取出来，重新组织，使其变得有一定结构，然后对此有一定结构的数据进行搜索，从而达到搜索相对较快的目的。
这部分从非结构化数据中提取出的然后重新组织的信息，我们称之索引。
这种先建立索引，再对索引进行搜索的过程就叫全文检索(Full-text Search)。
3.1 什么是 Elasticsearch?
ElasticSearch是一个高度可扩展的开源全文搜索和分析引擎。它允许您快速、近实时地存储、搜索和分析大量数据。它通常用作底层引擎/技术，为具有复杂搜索功能和需求的应用程序提供动力。
3.2 使用场景：
您运行在线网上商店，允许您的客户搜索您销售的产品。在这种情况下，您可以使用Elasticsearch存储整个产品目录和库存，并为它们提供搜索和自动填充建议。
您希望收集日志或交易数据，并且希望分析和挖掘此数据以查找趋势，统计信息，摘要或异常。一旦数据在Elasticsearch中，您就可以运行搜索和聚合来挖掘您感兴趣的任何信息。
您运行价格警报平台，允许精通价格的客户指定一条规则。。在这种情况下，您可以抓取供应商价格，将其推入Elasticsearch并使用其反向搜索（Percolator）功能来匹配价格变动与客户查询，并最终在发现匹配后将警报推送给客户。
您有分析/商业智能需求，并希望快速调查，分析，可视化并询问有关大量数据的特定问题（想想数百万或数十亿条记录）。在这种情况下，您可以使用Elasticsearch存储数据，然后使用Kibana（Elasticsearch / Logstash / Kibana堆栈的一部分）构建自定义仪表板，以便可视化对您来说重要的数据方面。
3.3 基本概念：
https://www.elastic.co/guide/en/elasticsearch/reference/6.0/_basic_concepts.html
近实时 near realtime(nrt)
Elasticsearch是一个几乎实时的搜索平台。意思是，从索引一个文档到这个文档可被搜索只需要一点点的延迟，这个时间一般为毫秒级。
cluster 集群
群集是一个或多个节点（服务器）的集合， 这些节点共同保存整个数据，并在所有节点上提供联合索引和搜索功能。一个集群由一个唯一集群ID确定，并指定一个集群名（默认为“elasticsearch”）。该集群名非常重要，因为节点可以通过这个集群名加入群集，一个节点只能是群集的一部分。
node 节点
节点是单个服务器实例，它是集群的一部分，可以存储数据，并参与群集的索引和搜索功能。就像一个集群，节点的名称默认为一个随机的通用唯一标识符（UUID），确定在启动时分配给该节点。如果不希望默认，可以定义任何节点名。
index 索引
索引是具有相似特性的文档集合。例如，可以为客户数据提供索引，为产品目录建立另一个索引，以及为订单数据建立另一个索引。索引由名称（必须全部为小写）标识，该名称用于在对其中的文档执行索引、搜索、更新和删除操作时引用索引。就像关系数据库中的“数据库”。它有一个定义多种类型的映射。索引是逻辑名称空间，映射到一个或多个主分片，并且可以有零个或多个副本分片。
document 文档
文档是可以被索引的信息的基本单位。例如，您可以为单个客户提供一个文档，单个产品提供另一个文档，以及单个订单提供另一个文档。本文件的表示形式为JSON（JavaScript Object Notation）格式，这是一种非常普遍的互联网数据交换格式。似于关系数据库中的一行。
shards replicas 碎片和副本
shards：分片数，一个索引分几个片存储，多个分片可以提升读写速度。索引可以存储大量的数据，这些数据可能超过单个节点的硬件限制。例如，十亿个文件占用磁盘空间1TB的单指标可能不适合对单个节点的磁盘或可能太慢服务仅从单个节点的搜索请求。
replicas：副本数量，分多个副本存储索引，好处是防止一个节点挂掉，数据丢失。
它在碎片/节点出现故障时提供高可用性。
它允许您扩展搜索量/吞吐量，因为可以在所有副本上并行执行搜索。
3.4 下载配置，搭建集群：
https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-6.4.0.tar.gz
或者：
wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-6.4.0.tar.gz
集群规划：
es1 192.168.23.71
es2 192.168.23.72
es3 192.168.23.73
解压：
tar -zxvf elasticsearch-6.4.0.tar.gz -C /usr/
修改名称
mv /usr/elasticsearch-6.4.0/ /usr/elasticsearch/
配置环境变量：
vim /etc/porfile
添加配置
export ES_HOME=/usr/elasticsearch
修改配置：
PATH=$ES_HOME/bin
让配置生效：
source /etc/profile
配置：
1，在/usr/elasticsearch创建数据data，后面配置用到:
mkdir /usr/elasticsearch/data
2，在/etc/sysctl.conf最后添加（解决：max virtual memory areas vm.max_map_count [65530] is too low错误，vm.max_map_count单个JVM能开启的最大线程数）
vim /etc/sysctl.conf
vm.max_map_count=655360
让文件生效：
sysctl -p
3，在/etc/security/limits.conf最后添加：（不配置缺省值：1024，解除 Linux 系统的最大进程数和最大文件打开数限制：* 代表针对所有用户 ues表示启动用户名称,与下面创建用户一致 noproc 是代表最大进程数 nofile 是代表最大文件打开数 ）
vim /etc/security/limits.conf
ues soft nofile 65536
ues hard nofile 131072
ues soft nproc 4096
ues hard nproc 4096
4，修改节点的配置文件jvm.options
vim /usr/elasticsearch/config/jvm.options （22行）
-Xms512m
-Xmx512m
原则：
最小堆的大小和最大堆的大小应该相等。
Elasticsearch可获得越多的堆，并且内存也可以使用更多的缓存。但是需要注意，分配了太多的堆给你的项目，将会导致有长时间的垃圾搜集停留。
设置最大堆的值不能超过你物理内存的50%，要确保有足够多的物理内存来保证内核文件缓存。
不要将最大堆设置高于JVM用于压缩对象指针的截止值。
5，修改配置文件 ElasticSearch.yml
vim /usr/elasticsearch/config/elasticsearch.yml
# ======================== Elasticsearch Configuration =========================
#
# NOTE: Elasticsearch comes with reasonable defaults for most settings.
# Before you set out to tweak and tune the configuration, make sure you
# understand what are you trying to accomplish and the consequences.
#
# The primary way of configuring a node is via this file. This template lists
# the most important settings you may want to configure for a production cluster.
#
# Please consult the documentation for further information on configuration options:
# https://www.elastic.co/guide/en/elasticsearch/reference/index.html
#
# ---------------------------------- Cluster -----------------------------------
#
# Use a descriptive name for your cluster:
#
cluster.name: my-app
#
# ------------------------------------ Node ------------------------------------
#
# Use a descriptive name for the node:
#
node.name: node-1
#
# Add custom attributes to the node:
#
#node.attr.rack: r1
#
# ----------------------------------- Paths ------------------------------------
#
# Path to directory where to store the data (separate multiple locations by comma):
#
path.data: /usr/elasticsearch/data
#
# Path to log files:
#
path.logs: /usr/elasticsearch/logs
#
# ----------------------------------- Memory -----------------------------------
#
# Lock the memory on startup:
#锁定物理内存地址，防止elasticsearch内存被交换出去,也就是避免es使用swap交换分区
bootstrap.memory_lock: false
#是否支持过滤掉系统调用
bootstrap.system_call_filter: false
#
# Make sure that the heap size is set to about half the memory available
# on the system and that the owner of the process is allowed to use this
# limit.
#
# Elasticsearch performs poorly when the system is swapping the memory.
#
# ---------------------------------- Network -----------------------------------
#
# Set the bind address to a specific IP (IPv4 or IPv6):
#
network.host: 192.168.23.30
#
# Set a custom port for HTTP:
#
http.port: 9200
#
# For more information, consult the network module documentation.
#
# --------------------------------- Discovery ----------------------------------
#
# Pass an initial list of hosts to perform discovery when new node is started:
# The default list of hosts is ["127.0.0.1", "[::1]"]
#当启动新节点时，通过这个ip列表进行节点发现，组建集群
discovery.zen.ping.unicast.hosts: ["cr1", "cr2","cr3"]
#
# Prevent the "split brain" by configuring the majority of nodes (total number of master-eligible nodes / 2 + 1):
#通过配置这个参数来防止集群脑裂现象 (集群总节点数量/2)+1
discovery.zen.minimum_master_nodes: 2
#
# For more information, consult the zen discovery module documentation.
#
# ---------------------------------- Gateway -----------------------------------
#
# Block initial recovery after a full cluster restart until N nodes are started:
#
#gateway.recover_after_nodes: 3
#
# For more information, consult the gateway module documentation.
#
# ---------------------------------- Various -----------------------------------
#
# Require explicit names when deleting indices:
#
#action.destructive_requires_name: true
因为配置文件中配置了集群节点的主机名称，所以在/etc/hosts添加下面配置：
vim /etc/hosts
192.168.23.81 es1
192.168.23.82 es2
192.168.23.83 es3
6,由于es启动不能直接使用root用户
创建用户：
useradd ues;
赋权：
chown -R ues:ues /usr/elasticsearch
查看：
ll /usr/ |grep elasticsearch
ll /usr
ll /usr/elasticsearch
复习免密：
ssh-keygen -t rsa 三次回车
ssh-copy-id es2 yes 输入密码：tiger
ssh-copy-id es3 yes 输入密码：tiger
7,发送配置好的es到其他节点上：
cd /usr/
直接使用scp命令， 之前配置过ssh免密登录
scp -r /usr/elasticsearch/ cr2:/usr/
scp -r /usr/elasticsearch/ cr3:/usr/
8，在其他节点修改配置及创建用户并赋权（当前集群在cr2和cr3上操作）
发送hosts：
scp /etc/hosts es2:/etc/
scp /etc/hosts es3:/etc/
发送环境变量
scp /etc/profile cr2:/etc/
scp /etc/profile cr3:/etc/
发送/etc/sysctl.conf
scp /etc/sysctl.conf cr2:/etc/
scp /etc/sysctl.conf cr3:/etc/
发送 /etc/security/limits.conf
scp /etc/security/limits.conf cr2:/etc/security/
scp /etc/security/limits.conf cr3:/etc/security/
在cr2和cr3上操作（或者在all session）：
让文件生效：
sysctl -p
让环境变量生效：
source /etc/profile
vim /usr/elasticsearch/config/elasticsearch.yml
分别修改23和56行
node.name: node-2 //cr3上为3
network.host: 192.168.23.31 //cr3上为32
创建用户：
useradd ues;
赋权：
chown -R ues:ues /usr/elasticsearch
查看：
ll /usr/ |grep elasticsearch
启动：
切换到ues用户
su ues;
在to All Sessions中启动：
elasticsearch -d;
查看结果：
curl 192.168.23.31:9200
三个IP都可以测试链接
还可以测试挂掉节点，再启动，注意，启动时速度不会快，可以看着日志
3.5 常用集群命令
查看集群支持命令：
curl 192.168.23.30:9200/_cat
查看集群是否健康
curl 192.168.23.30:9200/_cat/health
查看master:
curl 192.168.23.30:9200/_cat/master?v
命令支持help:
curl 192.168.23.30:9200/_cat/master?help
查看所有索引：
curl 192.168.23.30:9200/_cat/indices
3.6 创建,修改和删除索引及数据的增删改查:
Postman一款非常流行的API调试工具。其实，开发人员用的更多。因为测试人员做接口测试会有更多选择 。不过，对于开发过程中去调试接口，Postman确实足够的简单方便，而且功能强大。
官方网站：https://www.getpostman.com/
数据类型
核心类型（Core datatype）
字符串：string，string类型包含 text 和 keyword。
text：该类型被用来索引长文本，在创建索引前会将这些文本进行分词，转化为词的组合，建立 索引；允许es来检索这些词，text类型不能用来排序和聚合。
keyword：该类型不需要进行分词，可以被用来检索过滤、排序和聚合，keyword类型自读那只能用本身来进行检索（不可用text分词后的模糊检索）。
数值型：long、integer、short、byte、double、float
日期型：date
布尔型：boolean
二进制型：binary
索引的管理：
创建索引的语法
PUT /my_index
{
"settings": { ... any settings ... },
"mappings": {
"type_one": { ... any mappings ... },
"type_two": { ... any mappings ... },
...
}
}
mappings: 映射(Mapping)相当于数据表的表结构
number_of_shards：每个索引的主分片数，这个配置在索引创建后不能修改。默认值为5
number_of_replicas：每个主分片的副本数，默认值是 1 。对于活动的索引库，这个配置可以随时修改。
创建索引的示例
PUT /index_hr
{
"settings":{
"number_of_shards":3,
"number_of_replicas":1
},
"mappings":{
"emp_type":{
"properties":{
"empno":{
"type":"integer"
},
"ename":{
"type":"text"
},
"job":{
"type":"text"
},
"salary":{
"type":"double"
},
"deptno":{
"type":"integer"
},
"hiredate":{
"type":"date"
}
}
}
}
}
成功返回：
{"acknowledged":true,"shards_acknowledged":true,"index":"my_index"}
创建索引时如果503（master_not_discovered_exception）
删除集群各节点下的data下的数据
rm -rf /usr/elasticsearch/data/*
重启集群
2、修改索引
PUT /my_index/_settings
{
"number_of_replicas": 1
}
{"acknowledged":true}
3、删除索引
DELETE /my_index //删除单个索引
DELETE /index_one,index_two //删除多个索引
DELETE /index_* //删除以index_开头的索引
DELETE /_all //删除所有索引
{"acknowledged":true}
可以设置下面的属性，使DELETE /_all 失效，必须指定索引名称，才可以删除。
elasticsearch.yml
action.destructive_requires_name: true
数据管理：
1，插入数据
指定ID插入：
post 192.168.23.30:9200/my_index/my_type/1
{
"my_field":"aaa"
}
返回：
{"_index":"my_index","_type":"my_type","_id":"1","_version":1,"result":"created","_shards":{"total":1,"successful":1,"failed":0},"_seq_no":0,"_primary_term":1}
不指定ID插入：
返回：
{"_index":"my_index","_type":"my_type","_id":"s40HiGwBg5JLnGO8RVwg","_version":1,"result":"created","_shards":{"total":1,"successful":1,"failed":0},"_seq_no":1,"_primary_term":1}
2，查询数据：
查询所有
/index_hr/_search 注意传递的参数{}
带参数查询：
get 192.168.23.30:9200/index_hr/_search?q=ename:lisi
指定id查询：
get 192.168.23.30:9200/index_hr/emp_type/2
3，更新数据：
根据ID更新
post 192.168.182.66:9200/index_hr/emp_type/1
自动生成ID更新
post 192.168.23.30:9200/my_index/my_type/s40HiGwBg5JLnGO8RVwg
4 ，删除数据
根据id删除
delete 192.168.182.66:9200/index_hr/emp_type/1
再次查询
{"_index":"my_index","_type":"my_type","_id":"s40HiGwBg5JLnGO8RVwg","found":false}
3.7 springboot整合es
pom.xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
配置：
spring.data.elasticsearch.cluster-name=my-application
#9200 http请求端口
#9300 java 链接es的端口
spring.data.elasticsearch.cluster-nodes=192.168.23.81:9300
entity:
package com.aaa.sbm.entity;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import java.util.Date;
/**
* fileName:Order
* description:
* author:zz
* createTime:2019/8/16 9:39
* version:1.0.0
*/
@Document(indexName ="index_order",type = "order_type",shards = 3,replicas = 1)
public class Order {
@Id
private long id;
private String orderNo;
private String orderName;
private String orderTime;
private Integer customId;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getOrderNo() {
return orderNo;
}
public void setOrderNo(String orderNo) {
this.orderNo = orderNo;
}
public String getOrderName() {
return orderName;
}
public void setOrderName(String orderName) {
this.orderName = orderName;
}
public String getOrderTime() {
return orderTime;
}
public void setOrderTime(String orderTime) {
this.orderTime = orderTime;
}
public Integer getCustomId() {
return customId;
}
public void setCustomId(Integer customId) {
this.customId = customId;
}
@Override
public String toString() {
return "Order{" +
"id=" + id +
", orderNo='" + orderNo + '\'' +
", orderName='" + orderName + '\'' +
", orderTime=" + orderTime +
", customId=" + customId +
'}';
}
}
dao:
package com.aaa.sbm.esdao;
import com.aaa.sbm.entity.Order;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
/**
* fileName:OrderEsDao
* description:
* author:zz
* createTime:2019/8/16 9:53
* version:1.0.0
*/
public interface OrderEsDao extends ElasticsearchRepository<Order,Long> {
}
service:
package com.aaa.sbm.service;
import com.aaa.sbm.entity.Order;
import java.util.List;
/**
* fileName:OrderService
* description:
* author:zz
* createTime:2019/8/16 9:59
* version:1.0.0
*/
public interface OrderService {
/**
* 带参查询order列表
* @param param
* @return
*/
List<Order> getList(String param,int type);
/**
* 向索引中添加数据
* @param order
* @return
*/
int save(Order order);
/**
* 向索引中修改数据
* @param order
* @return
*/
int update(Order order);
/**
* 向索引中删除数据
* @id
* @return
*/
int delete(long id);
}
package com.aaa.sbm.service;
import com.aaa.sbm.entity.Order;
import com.aaa.sbm.esdao.OrderEsDao;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* fileName:OrderServiceImpl
* description:
* author:zz
* createTime:2019/8/16 10:29
* version:1.0.0
*/
@Service
public class OrderServiceImpl implements OrderService {
@Autowired
private OrderEsDao orderEsDao;
@Override
public List<Order> getList(String param,int type) {
QueryBuilder queryBuilder = null;
if(type==0){
//查询所有
queryBuilder = QueryBuilders.matchAllQuery();
}else if(type==1&&!StringUtils.isEmpty(param)){ //查询匹配的单个列的值
//类似于mybatis中 orderName =#{param}
queryBuilder = QueryBuilders.matchQuery("orderName",param);
}else if(type==2&&!StringUtils.isEmpty(param)){//查询order中所有为字符串的匹配值
// 类似于mybatis中 (orderNo =#{param} or orderName =#{param})
queryBuilder = QueryBuilders.multiMatchQuery(param,"orderNo","orderName");
}else if(type==3&&!StringUtils.isEmpty(param)){//单列模糊查询
//类似于mybatis中 orderName like '%${param}%'
queryBuilder = QueryBuilders.wildcardQuery("orderName","*"+param+"*");
}
//获取order对象迭代集合
Iterable<Order> search = orderEsDao.search(queryBuilder);
//返回迭代器
Iterator<Order> iterator = search.iterator();
//定义返回对象
List<Order> orders = new ArrayList<>();
//迭代对象
while(iterator.hasNext()){
orders.add(iterator.next());
}
return orders;
}
@Override
public int save(Order order) {
//向es中存储对象
Order rorder = orderEsDao.save(order);
if(rorder!=null)
return 1;
return 0;
}
@Override
public int update(Order order) {
//向es中存储对象
Order rorder = orderEsDao.save(order);
if(rorder!=null)
return 1;
return 0;
}
@Override
public int delete(long id) {
try {
orderEsDao.deleteById(id);
return 1;
}catch (Exception e){
e.printStackTrace();
}
return 0;
}
}
controller:
package com.aaa.sbm.controller;
import com.aaa.sbm.entity.Order;
import com.aaa.sbm.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
/**
* fileName:OrderController
* description:
* author:zz
* createTime:2019/8/16 10:59
* version:1.0.0
*/
@RestController
public class OrderController {
@Autowired
private OrderService orderService;
/**
* es的order 索引查询
* @param name
* @param type
* @return
*/
@RequestMapping("orderList")
public Object list(@RequestParam(required = true,defaultValue ="") String name,@RequestParam(required = true,defaultValue ="0") Integer type){
return orderService.getList(name,type);
}
/**
* order索引添加
* @param order
* @return
*/
@RequestMapping("orderAdd")
public Object add(Order order){
return orderService.save(order);
}
/**
* order索引更新
* @param order
* @return
*/
@RequestMapping("orderUpdate")
public Object update(Order order){
return orderService.save(order);
}
/**
* order索引值的删除
* @param id
* @return
*/
@RequestMapping("orderDelete")
public Object delete(Long id){
return orderService.delete(id);
}
}
启动类：
package com.aaa.sbm;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
@SpringBootApplication
@MapperScan("com.aaa.sbm.dao")
@EnableElasticsearchRepositories("com.aaa.sbm.esdao")
public class SpringbootMabatisApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootMabatisApplication.class, args);
}
}
测试
http://localhost:8888/orderList
//查询时，参数为小写
http://localhost:8888/orderList?name=orderb&type=1
http://localhost:8888/orderList?name=ord10002&type=2
http://localhost:8888/orderList?name=orderb&type=3
http://localhost:8888/orderDelete?id=4
4、本章总结
4.1 总结本章知识点
写入原理详解：
https://blog.csdn.net/jiaojiao521765146514/article/details/83753215
4.2 面试题答案
4.3 预习下一章重点
