Elasticsearch

测试类

;SpringBootTest
public class RestHighLevelClientForObject{

    ;Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 将对象放入es中
     */
    ;Test
    public void testIndex() throws IOException {
        Product product = new Product();
        product.setId(1);
        product.setTitle(;小浣熊干吃面;);
        product.setPrice(1.5);
        product.setDescription(;小浣熊真好吃!;);

        // 录入es中
        IndexRequest indexRequest = new IndexRequest(;products;);
        indexRequest.id(product.getId().toString())       // 设置文档的_id
                    .source(new ObjectMapper().writeValueAsString(product), XContentType.JSON);  // 将对象转换为json
        IndexResponse indexResponse = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
        System.out.println(indexResponse.status());
    }

    /*
    从es中查询数据并转换为对象
     */
    ;Test
    public void testSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest(;products;);
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.requireFieldMatch(false).field(;description;).preTags(;<span style=;color:red;;>;).postTags(;</span>;); // 设置高亮
        sourceBuilder
                .query(QueryBuilders.termQuery(;description;, ;浣熊;))     // 查询所有
                .from(0)
                .size(30)
                .highlighter(highlightBuilder);
        searchRequest.source(sourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        System.out.println(;符合条件的文档条数: ; ; searchResponse.getHits().getTotalHits().value);
        System.out.println(searchResponse.getHits().getMaxScore());
        List<Product> productList = new ArrayList<>();
        SearchHit[] hits = searchResponse.getHits().getHits();
        for (SearchHit hit : hits) {
            //System.out.println(hit.getSourceAsString());    // json
            Product product = new ObjectMapper().readValue(hit.getSourceAsString(), Product.class);// 将json转为对象
            // 处理高亮
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            if(highlightFields.containsKey(;description;)){
                product.setDescription(highlightFields.get(;description;).fragments()[0].toString());
            }
            productList.add(product);
        }
        productList.forEach(product -> System.out.println(product));   // 遍历
    }
}

# 创建索引 index 和映射 mapping
PUT /fruit
{
  ;mappings;: {
    ;properties;: {
      ;title;:{
        ;type;: ;keyword;
      },
      ;price;:{
        ;type;:;double;
      },
      ;description;:{
        ;type;: ;text;,
        ;analyzer;: ;ik_max_word;
      }
    }
  }
}
# 放入测试数据
PUT /fruit/_bulk
{;index;:{}}
  {;title; : ;面包;,;price; : 19.9,;description; : ;小面包非常好吃;}
{;index;:{}}
  {;title; : ;旺仔牛奶;,;price; : 29.9,;description; : ;非常好喝;}
{;index;:{}}
  {;title; : ;日本豆;,;price; : 19.9,;description; : ;日本豆非常好吃;}
{;index;:{}}
  {;title; : ;小馒头;,;price; : 19.9,;description; : ;小馒头非常好吃;}
{;index;:{}}
  {;title; : ;大辣片;,;price; : 39.9,;description; : ;大辣片非常好吃;}
{;index;:{}}
  {;title; : ;透心凉;,;price; : 9.9,;description; : ;透心凉非常好喝;}
{;index;:{}}
  {;title; : ;小浣熊;,;price; : 19.9,;description; : ;童年的味道;}
{;index;:{}}
  {;title; : ;海苔;,;price; : 19.9,;description; : ;海的味道;}

# 根据某个字段进行分组 统计数量
GET /fruit/_search
{
  ;query;: {
    ;match_all;: {}
  }, 
  ;size;: 0, 
  ;aggs;: {
    ;price_group;: {	
      ;terms;: {
        ;field;: ;price;
      }
    }
  }
}

/*
;size;: 0  表示只想要聚合的结果,不想要查询的数据
price_group 聚合的名字,自己随便写
price 是对哪个字段进行分组
*/

# 求最大值 
GET /fruit/_search
{
  ;query;: {
    ;match_all;: {}
  }, 
  ;size;: 0, 
  ;aggs;: {
    ;price_max;: {
      ;max;: {
        ;field;: ;price;
      }
    }
  }
}

/*
;size;: 0  表示只想要聚合的结果,不想要查询的数据
price_max 表示这个聚合查询的名字,自己随便写
price 表示对哪个字段求最大值
*/

# 求最小值
GET /fruit/_search
{
  ;query;: {
    ;match_all;: {}
  }, 
  ;size;: 0, 
  ;aggs;: {
    ;price_min;: {
      ;min;: {
        ;field;: ;price;
      }
    }
  }
}

/*
;size;: 0  表示只想要聚合的结果,不想要查询的数据
price_min  表示聚合名字,自己随便写
price  表示对哪个字段求最小值
*/

# 求平均值
GET /fruit/_search
{
  ;query;: {
    ;match_all;: {}
  }, 
  ;size;: 0, 
  ;aggs;: {
    ;price_avg;: {
      ;avg;: {
        ;field;: ;price;
      }
    }
  }
}

/*
;size;: 0  表示只想要聚合的结果,不想要查询的数据
price_avg  表示聚合名字,自己随便写
price  表示对哪个字段求平均值
*/

# 求和
GET /fruit/_search
{
  ;query;: {
    ;match_all;: {}
  }, 
  ;size;: 0, 
  ;aggs;: {
    ;price_sum;: {
      ;sum;: {
        ;field;: ;price;
      }
    }
  }
}

/*
;size;: 0  表示只想要聚合的结果,不想要查询的数据
price_sum  表示聚合名字,自己随便写
price  表示对哪个字段求和
*/

;SpringBootTest
public class RestHighLevelClientForAggs {

    ;Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 基于 term 类型进行聚合   基于字段进行分组聚合
     */
    ;Test
    public void testAggs() throws IOException {
        SearchRequest searchRequest = new SearchRequest(;fruit;);
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder
                .query(QueryBuilders.matchAllQuery())     // 设置查询条件
                // 聚合名字(自己随便起)    对哪个字段进行聚合       下面这段意思是对指定字段分组
                .aggregation(AggregationBuilders.terms(;price_group;).field(;price;))  // 设置聚合处理
                .size(0);       // 只要聚合的结果,不要查询到的文档
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        // 处理聚合的结果
        Aggregations aggregations = searchResponse.getAggregations();
        // 由聚合的名字继续处理
        ParsedDoubleTerms aggregation = aggregations.get(;price_group;); //price是double类型,所以用ParsedDoubleTerms

        List<? extends Terms.Bucket> buckets = aggregation.getBuckets();
        for (Terms.Bucket bucket : buckets) {
            System.out.println(bucket.getKey() ; ; ; ; bucket.getDocCount());
        }
    }

    /**
     * max(ParsedMax接收) min(ParsedMin接收) sum(ParsedSum接收) avg(ParsedAvg接收) 聚合查询    桶中只有一个返回值
     */
    ;Test
    public void testAggsFunction() throws IOException {
        SearchRequest searchRequest = new SearchRequest(;fruit;);
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder
                .query(QueryBuilders.matchAllQuery())     // 设置查询条件
                // 聚合名字(自己随便起)    对哪个字段进行聚合       下面这段意思是求哪个字段的和
                .aggregation(AggregationBuilders.sum(;sum_price;).field(;price;))  // 设置聚合处理
                .size(0);       // 只要聚合的结果,不要查询到的文档
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        // 处理聚合的结果
        Aggregations aggregations = searchResponse.getAggregations();
        // 由聚合的名字继续处理
        ParsedSum parsedSum = aggregations.get(;sum_price;);//返回的类型是求和数据, 所以使用ParsedSum
        System.out.println(parsedSum.getValue());
    }
}

// 求不同价格的数量
;Test
public void testAggsPrice() throws IOException {
  SearchRequest searchRequest = new SearchRequest(;fruit;);
  SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  sourceBuilder.aggregation(AggregationBuilders.terms(;group_price;).field(;price;));
  searchRequest.source(sourceBuilder);
  SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
  Aggregations aggregations = searchResponse.getAggregations();
  ParsedDoubleTerms terms = aggregations.get(;group_price;);
  List<? extends Terms.Bucket> buckets = terms.getBuckets();
  for (Terms.Bucket bucket : buckets) {
    System.out.println(bucket.getKey() ; ;, ;; bucket.getDocCount());
  }
}

// 求不同名称的数量
;Test
public void testAggsTitle() throws IOException {
  SearchRequest searchRequest = new SearchRequest(;fruit;);
  SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  sourceBuilder.aggregation(AggregationBuilders.terms(;group_title;).field(;title;));
  searchRequest.source(sourceBuilder);
  SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
  Aggregations aggregations = searchResponse.getAggregations();
  ParsedStringTerms terms = aggregations.get(;group_title;);
  List<? extends Terms.Bucket> buckets = terms.getBuckets();
  for (Terms.Bucket bucket : buckets) {
  	System.out.println(bucket.getKey() ; ;, ;; bucket.getDocCount());
  }
}

// 求和
;Test
public void testAggsSum() throws IOException {
  SearchRequest searchRequest = new SearchRequest(;fruit;);
  SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  sourceBuilder.aggregation(AggregationBuilders.sum(;sum_price;).field(;price;));
  searchRequest.source(sourceBuilder);
  SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
  ParsedSum parsedSum = searchResponse.getAggregations().get(;sum_price;);
  System.out.println(parsedSum.getValue());
}

# 1.准备3个ES节点和一个kibana 节点  ES 9200 9300 
- web: 9201 tcp:9301  node-1  elasticsearch.yml   
- web: 9202 tcp:9302  node-2  elasticsearch.yml
- web: 9203 tcp:9303  node-3  elasticsearch.yml
- kibana: 5602

# node-1 配置文件

# 指定集群名称 3个节点必须一致
cluster.name: es-cluster
# 指定节点名称 每个节点名字唯一
node.name: node-1
# 开放远程链接
network.host: 0.0.0.0
# 指定使用发布地址进行集群间通信
network.publish_host: 192.168.204.137
# 指定 web 端口
http.port: 9201
# 指定 tcp 端口
transport.tcp.port: 9301
# 指定所有节点的 tcp 通信
discovery.seed_hosts: [;192.168.204.137:9301;, ;192.168.204.137:9302;,;192.168.204.137:9303;]
# 指定可以初始化集群的节点名称
cluster.initial_master_nodes: [;node-1;, ;node-2;,;node-3;]
# 集群最少几个几点可用
gateway.recover_after_nodes: 2
# 解决跨域问题
http.cors.enabled: true
http.cors.allow-origin: ;*;

# node-2 配置文件

# 指定集群名称 3个节点必须一致
cluster.name: es-cluster
# 指定节点名称 每个节点名字唯一
node.name: node-2
# 开放远程链接
network.host: 0.0.0.0
# 指定使用发布地址进行集群间通信
network.publish_host: 192.168.204.137
# 指定 web 端口
http.port: 9202
# 指定 tcp 端口
transport.tcp.port: 9302
# 指定所有节点的 tcp 通信
discovery.seed_hosts: [;192.168.204.137:9301;, ;192.168.204.137:9302;,;192.168.204.137:9303;]
# 指定可以初始化集群的节点名称
cluster.initial_master_nodes: [;node-1;, ;node-2;,;node-3;]
# 集群最少几个几点可用
gateway.recover_after_nodes: 2
# 解决跨域问题
http.cors.enabled: true
http.cors.allow-origin: ;*;

# node-3 配置文件

# 指定集群名称 3个节点必须一致
cluster.name: es-cluster
# 指定节点名称 每个节点名字唯一
node.name: node-2
# 开放远程链接
network.host: 0.0.0.0
# 指定使用发布地址进行集群间通信
network.publish_host: 192.168.204.137.3
# 指定 web 端口
http.port: 9202
# 指定 tcp 端口
transport.tcp.port: 9302
# 指定所有节点的 tcp 通信
discovery.seed_hosts: [;192.168.204.137:9301;, ;192.168.204.137:9302;,;192.168.204.137:9303;]
# 指定可以初始化集群的节点名称
cluster.initial_master_nodes: [;node-1;, ;node-2;,;node-3;]
# 集群最少几个几点可用
gateway.recover_after_nodes: 2
# 解决跨域问题
http.cors.enabled: true
http.cors.allow-origin: ;*;

version: ;3.8;
networks:
  escluster:
services:
  es01:
    image: elasticsearch:7.14.0
    ports:
      - ;9201:9201;
      - ;9301:9301;
    networks:
      - ;escluster;
    volumes:
      - ./node-1/data:/usr/share/elasticsearch/data
      - ./node-1/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml
      - ./node-1/plugins/ik:/usr/share/elasticsearch/plugins/ik
    environment:
      - ;ES_JAVA_OPTS=-Xms512m -Xmx512m;

  es02:
    image: elasticsearch:7.14.0
    ports:
      - ;9202:9202;
      - ;9302:9302;
    networks:
      - ;escluster;
    volumes:
      - ./node-2/data:/usr/share/elasticsearch/data
      - ./node-2/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml
      - ./node-2/plugins/ik:/usr/share/elasticsearch/plugins/ik
    environment:
      - ;ES_JAVA_OPTS=-Xms512m -Xmx512m;

  es03:
    image: elasticsearch:7.14.0
    ports:
      - ;9203:9203;
      - ;9303:9303;
    networks:
      - ;escluster;
    volumes:
      - ./node-3/data:/usr/share/elasticsearch/data
      - ./node-3/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml
      - ./node-3/plugins/ik:/usr/share/elasticsearch/plugins/ik
    environment:
      - ;ES_JAVA_OPTS=-Xms512m -Xmx512m;

  kibana:
    image: kibana:7.14.0
    ports:
      - ;5602:5601;
    networks:
      - ;escluster;
    volumes:
      - ./kibana.yml:/usr/share/kibana/config/kibana.yml

# kibana配置文件 连接到ES
server.host: ;0;
server.shutdownTimeout: ;5s;
elasticsearch.hosts: [ ;http://192.168.204.137:9201; ] #链接任意节点即可
monitoring.ui.container.elasticsearch.enabled: true

http://192.168.204.137:9201/_cat/health?v

1. 访问github网站
	搜索: elasticsearch-head 插件
	
2. 安装git
	yum install git
	
3. 将elasticsearch-head下载到本地
	git clone git://github.com/mobz/elasticsearch-head.git

4. 安装nodejs
	#注意: 没有wget的请先安装 yum install -y wget
	wget http://cdn.npm.taobao.org/dist/node/latest-v8.x/node-v8.1.2-linux-x64.tar.xz
 
5. 解压缩nodejs
	xz -d node-v10.15.3-linux-arm64.tar.xz
	tar -xvf node-v10.15.3-linux-arm64.tar

6. 配置环境变量
	mv node-v10.15.3-linux-arm64 nodejs
	mv nodejs /usr/nodejs
	vim /etc/profile
		export NODE_HOME=/usr/nodejs
		export PATH=$PATH:$JAVA_HOME/bin:$NODE_HOME/bin

7.	进入elasticsearch-head的目录
	npm config set registry https://registry.npm.taobao.org
	npm install
	npm run start


8.  启动访问head插件 默认端口9100
	http://ip:9100  查看集群状态