1. 整体介绍

Elasticsearch通过docker安装，并安装kibana进行操作。主要是记录了Elasticsearch常用的指令，查询序列，创建序列，查询数据，对数据分类聚合等。
关于更多的使用，直接看ES的官方文档，文档很详细。

2. 软件安装

1. 下载ealastic search和kibana

docker pull elasticsearch:7.12.1
docker pull kibana:7.12.1

2. 安装前配置，将ES配置文件外挂，这样方便修改配置

// 创建外部挂载目录
mkdir -p /mydata/elasticsearch/config  创建目录
mkdir -p /mydata/elasticsearch/data
// 设置其他机器可访问
echo "http.host: 0.0.0.0" >/mydata/elasticsearch/config/elasticsearch.yml

//将mydata/elasticsearch/文件夹中文件都可读可写--**很重要**
chmod -R 777 /mydata/elasticsearch/

3. 启动Elasticsearch，这里设置了启动的内存大小，关于镜像版本，可以选择最新的

// 创建docker容器，单节点启动，设置初始内存大小，挂载外部盘和插件盘，一定要注意文件安家权限问题
docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e  "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms64m -Xmx512m" \
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data \
-v  /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:7.12.1

4. 安装Kibana，这里要和Es的地址进行绑定
   对于地址绑定，也可以不在创建容器时配置，直接到配置文件配置也可以

docker run -name kibana 
-e ELASTICSEARCH_HOSTS=http://192.168.6.128:9200
-d kibana:7.12.1

5. 将Elasticsearch和kibana设置成开机重启

docker update --restart=always elasticsearch
docker update --restart=always kibana

【注意】
在安装时有些要注意的地方“

• Elasticsearch和Kibana的镜像版本要一致
• 在安装ES时，一定要将挂载的文件设置成所有人可读可写，不然会因为权限问题启动不了

3. Spring boot整合Elasticsearch

1. 导入依赖
   这里的有个重要的点，版本要和自己安装的一致，我用的是7.12.1

<!--elasticsearch.client-->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.12.1</version>
        </dependency>

除此之外，Spring boot有维护自己的Elasticsearch版本，这个版本会和我们导入的冲突，所以需要统一版本，这里不多将。就是将spring boot维护的<elasticsearch.version>7.12.1</elasticsearch.version>
改成自己的版本号就可以了。

2. 加入ES镜像仓库-这一步可以不用配置

<!--elasticsearch -->
        <repository>
            <id>es-snapshots</id>
            <name>elasticsearch snapshot repo</name>
            <url>https://snapshots.elastic.co/maven/</url>
        </repository>

到这里，Elasticsearch就安装，配置好了。就可以在实际的项目中使用ES了。
这有一个点：
给ES分配多少内存，这个由自己的机器和具体业务而定，机器好，业务存储数据多，就分配大一些。

4. 使用Kibana操作ES记录

这里包含了基本的操作，使用的是ES官方提供的测试数据bank.使用的是官方提供的测试数据，建议自己找一下，代码太多，这里放不下。通过批量插入，将官网测试数据插入到ES中，这样才能进行接下来的操作。

GET _search
{
  "query": {
    "match_all": {}
  }
}
# 插入数据
POST /customer/external/_bulk
{"index":{"_id":"1"}}
{"name":"John Doe"}
{"index":{"_id":"2"}}
{"name":"John Doe"}

# 批量插入数据
POST /_bulk
{"delete":{"_index":"website","_type":"blog","_id":"123"}}
{"create":{"_index":"website","_type":"blog","_id":"123"}}
{"title":"my first blog post"}
{"index":{"_index":"website","_type":"blog"}}
{"title":"my second blog post"}
{"update":{"_index":"website","_type":"blog","_id":"123"}}
{"doc":{"title":"my updated blog post"}}





GET bank/_search?q=*&sort=account_number:asc

GET bank/_search
{
  "query": {
    "match_all": {}
  },
  "from": 10,
  "size": 10,
  "sort": [
    {
      "account_number": {
        "order": "desc"
      }
    }
  ],
  "_source": ["balance","firstname"]


  
}

# 自定义查询，这里用的是DSL语法
GET bank/_search
{
  "query": {"match_all": {}
    
  },
  "from": 0,
  "size": 5,
  "sort": [
    {
      "account_number": {
        "order": "desc"
      }
    }
  ]
  , "_source": ["balance","account_number", "firstname"]
}


# 用match，可以模糊查询，通过倒排索引进行查询，全文检索会自动分词进行匹配
GET /bank/_search
{
  "query": {
    "match": {
      "address": "kings"
    }
  }
}

# 这里将查询条件当成一个完整的条件，不用分词
GET /bank/_search
{
  "query": {
    "match_phrase": {
      "address": "kings"
    }
  }
}


# 这里进行多字段匹配，这里进行了分词查询
GET /bank/_search
{
  "query": {
    "multi_match": {
      "query": "mill movice",
      "fields": ["address", "city"]
    }
  }
}

# 复合查询,bool-must-must_not--shoud , shoud不是必须的 相关性得分 
GET /bank/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {
            "gender": "M"
          }
        },
        {"match": {
          "address": "mill"
          }
        }
      ],
      "should": [
        {
          "match": {
            "lastname": "wallace"
          }
        }
      ],
      "filter": [
        {"range": {
          "age": {
            "gte": 18,
            "lte": 30
          }
        }}
      ]
    }
  }
}

# filter不会给出相关性得分，should可以给出，一般filter是和shoud联合使用，放到最后过滤结果
GET /bank/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "range": {
            "age": {
              "gte": 10,
              "lte": 20
            }
          }
        }
      ]
    }
  }
}
# term使用，term和match一样，精确字段用term，全文查询用match，因为match可以分词，address不适合用term
GET /bank/_search
{
 "query": {
   "term": { 
     "age": 28
   }
 }
}
# 用match精确某个值，也可用用match_phrase,这个是精确匹配
GET /bank/_search
{
 "query": {
   "match": { 
     "address.keyword": "789 Madison Street"
   }
 }
}
GET /bank/_search
{
 "query": {
   "match_phrase": { 
     "address.keyword": "789 Madison Street"
   }
 }
}

 
# Aggregations模块，这里是一些聚合类型 
# 搜索address中包含mill的所有人的年龄分布以及平均年龄，但不显示这些人的详情
# 通过size来设定不看结果，只看分析结果
GET /bank/_search
{
  "query": {
    "match": {
      "address": "mill"
    }
  },
  "aggs": {
    "ageAgg": {
      "terms": {
        "field": "age",
        "size": 10
      }
    },
    "ageAvg": {
      "avg": {
        "field": "age"
      }
    },
    "balanceAvg": {
      "avg": {
        "field": "balance"
      }
    }
  },
  "size": 0
}
//ageAgg:聚合名字  terms：聚合类型  "field": "age":按照age字段聚合  size:10：取出前十种age
//avg：平均值聚合类型
//不显示这些人的详情，只看聚合结果

# 按照年龄聚合，并且求这些年龄段的这些人的平均薪资
# 这里测试的是嵌套聚合，语法还是很简单 
GET /bank/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "ageAgg": {
      "terms": {
        "field": "age",
        "size": 10
      },
      "aggs": {
        "ageAvg": {
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  }
}

# 查出所有年龄分布，并且这些年龄段中M的平均薪资和F的平均薪资以及这个年龄段的总体平均薪资，不显示查询结果
GET /bank/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "ageAgg": {
      "terms": {
        "field": "age",
        "size": 10
      },
      "aggs": {
        "genderAgg": {
          "terms": {
            "field": "gender.keyword",
            "size": 10
          },
          "aggs": {
            "balanceAvg": {
              "avg": {
                "field": "balance"
              }
            }
          }
        }
      }
    },
    "allBalanceAvg": {
      "avg": {
        "field": "balance"
      }
    }
  },
  "size": 0
}
//"field": "gender.keyword" gender是txt没法聚合 必须加.keyword精确替代


#------------------------------------------应用就是将老的数据迁移到新的索引下-----------------------------------------
#------------------------------------需要自定义索引，然后将数据迁移到新的索引-----------------------------------------
# mapping 映射，查看属性映射
GET /bank/_mapping

# 自定义属性映射，
PUT /my_index
{
  "mappings": {
    "properties": {
      "age":{"type": "integer" },
      "email": {"type": "keyword"},
      "name": {"type": "text"}
    }
  }
}
# 修改某个已存在的索引，这里是添加一个，index属性是显示该字段是否被索引到,已经存在映射不能更新的
PUT /my_index/_mapping
{
  "properties": {
      "employee-id":{
        "type": "keyword" ,
        "index": false
        
      }
    }
  }
}

# 查看索引
GET /my_index/_mapping

# 不能直接更新索引，要更新，只有创建新的索引，将原来的索引的数据迁移到新的索引中来

# 更改映射关系，先创建一个新的索引
PUT /newbank
{
  "mappings": {
    "properties": {
      "account_number": {
        "type": "long"
      },
      "address": {
        "type": "text"
      },
      "age": {
        "type": "integer"
      },
      "balance": {
        "type": "long"
      },
      "city": {
        "type": "text"
      },
      "email": {
        "type": "text"
      },
      "employer": {
        "type": "keyword"
      },
      "firstname": {
        "type": "text"
      },
      "gender": {
        "type": "text"
      },
      "lastname": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "state": {
        "type": "text"
      }
    }
  }
}
# 查看新的索引
GET /newbank/_mapping
# 原来的索引
GET /bank/_mapping

# 数据迁移
POST _reindex
{
  "source": {
    "index": "bank",
    "type": "account"
  },
  "dest": {
    "index": "newbank"
  }
}

GET /newbank/_search
# 新的版本是不用type的