SpringBoot 整合 ElasticSearch（转存记录）

安装教程

1. springboot 使用

   1.1 首先 pom 引用

      <!-- 搜索引擎 -->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
      </dependency>

      <!-- GetSet插件，@Get@Set -->
      <dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
          <version>1.16.10</version>
      </dependency>

1.2 yml 配置文件配置

spring:
  data:
    elasticsearch:
      # 集群名
      cluster-name: elasticsearch
      # 连接节点,注意在集群中通信都是9300端口，否则会报错无法连接上！
      cluster-nodes: localhost:9300
      # 是否本地连接
      local: false
      repositories:
        # 仓库中数据存储
        enabled: true

1.3 创建对应ES 的实体对象

ackage com.example.demo.bean;

import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Getter
@Setter
@ToString
//设置对应ES库中的  index 和 type 以及分片等
@Document(indexName = "yonghu", type = "user", shards = 1,replicas = 0, refreshInterval = "-1")
public class User {

    @Id
    private String id;
    @Field
    private String name;
    @Field
    private String age;
}

1.4 然后就是 Dao层 直接用于操作 ES数据库类似于

package com.example.demo.dao;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import com.example.demo.bean.User;
import java.lang.String;
import java.util.List;
//主要是继承这个类 ，<>前面参数对应的是映射对象就行了
public interface UserRepository extends ElasticsearchRepository<User,String>{

    //特定格式的 这个是对应 id 和 age  但是默认好像是 10个 再多就需要分页 或者 findAll 方法
    List<User> findByIdAndAge(String id,String age);
    List<User> findByAge(String age);
}

1.5 然后调用层 直接自动注入这个类 

package com.example.demo.controller;

import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.functionscore.FunctionScoreQueryBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.SearchQuery;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.example.demo.bean.User;
import com.example.demo.dao.UserRepository;

@RestController
@RequestMapping("/one")
public class ControllerOne {

    @Autowired
    private UserRepository ur;

    @GetMapping("/si/{id}/{age}")
    public String si(@PathVariable String id,@PathVariable String age) throws Exception {
        User user = new User();
        user.setId(id);
        user.setAge(age);
        user.setName("张三");
        //增加 或者 更改
//      ur.save(user);
        //删除
        ur.delete(user);
        return "插入用户";
    }

    /**
     * 多条件 分页查询 0 为第一页
     * @param ye
     * @param sa
     * @return
     */
    @GetMapping("/qi/{ye}/{sa}")
    public String qi(@PathVariable Integer ye,@PathVariable Integer sa) {
                     //页数 ， 每页多少数据
        Pageable pageable = PageRequest.of(ye, sa);
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
         queryBuilder.must(QueryBuilders.matchQuery("name", "张三"));
//      queryBuilder.must(QueryBuilders.matchQuery("age", "30"));
        FunctionScoreQueryBuilder functionScoreQueryBuilder = QueryBuilders.functionScoreQuery(queryBuilder);
        SearchQuery searchQuery = new NativeSearchQueryBuilder().withPageable(pageable)
                .withQuery(functionScoreQueryBuilder).build();
        Iterable<User> search = ur.search(searchQuery);
        for (User user : search) {
            System.out.println(user);
        }
        return "多条件查询";
    }
}

参考网站

widnows 安装 启动教程

1. ES 笔记保存

linux下安装jdk
vim /etc/profile 文件夹新增下面代码

#set java environment
JAVA_HOME=/usr/local/java/jdk1.8.0_171
JRE_HOME=/usr/local/java/jdk1.8.0_171/jre
CLASS_PATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib
PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin
export JAVA_HOME JRE_HOME CLASS_PATH PATH

重启即可
source /etc/profile

java -version


es配置文件
# 增加新的参数，这样head插件可以访问es
http.cors.enabled: true
http.cors.allow-origin: "*"

# 配置集群 分别是集群名称, master起名字, 告诉这个es他就是master
cluster.name: luqi
node.name: master
node.master: true

network.host: 0.0.0.0
http.port: 9200

ES优点


ES基础概念
集群和节点  一个集群是由多个节点组成的

索引 含有相同属性的文档集合    // 相当于一个database 也就是数据库

类型  索引可以定义一个或多个类型,文档必须属于一个类型   // 相当于数据库中的表

文档  文档是可以被索引的基本数据单位  // 相当于数据库中的具体字段

分片  每一个索引都有多个分片, 每一个分片是一个Lucene索引

备份 拷贝一份分分片就完成了分片的备份   当主分片不干活了,会替代分片

索引分片的好处在于当数据量比较大的时候硬盘压力会很大, 搜索速度就会降低, 就可以将索引分成多个分片,从而分摊压力,


ES创建索引的时候会默认创建5个分片一个备份



aggs 表示聚合查询

{
  "aggs": {

  }
}

高级查询

子条件查询   特定字段查询所制定值
  Query Context
  在查询中,除了判断文档是否满足查询条件外,ES还会计算一个<_score>来标识匹配的程度,旨在判断目标文档和查询条件匹配的<有多好>
    常用的查询有
    全文本查询 针对文本类型数据

    query 表示查询, match 表示模糊匹配(会自动分词,有一个查询分数 _score)   match_phrase 表示习语匹配, 就是匹配 "ElasticSearch入门" 的
    multi_match  表示多个字段的模糊查询    fields 表示查询哪些字段

    {
        "query" : {
            "match": {
                "title": "ElasticSearch入门"
            }
        }
    }

    query_string 表示语法查询 可以查询满足条件的所有内容   fields 表示查询哪些字段

    {
        "query" : {
            "query_string": {
                "query": "(ElasticSearch AND 入门) OR Python "
                "fields": ["title", "outhor"]
            }
        }
    }

    字段级别查询 针对结构化数据, 比如数字 日期等
    {
        "query" : {
            "term": {
                "word_count": 1000                      // 查询字数1000的
            }
        }
    }

    range 表示范围
    {
        "query" : {
            "range": {
                "word_count": {
                    范围查询
                    "gte": 1000,   gte把 e去掉 表是小于, e表示等于
                    "lte":2000     2000     改成  now 表示当前日期
                }
            }
        }
    }

    Filter Context 查询
    在查询过程中,只判断该文档是否满足条件, 只有Yes或No

复合条件查询  以一定的逻辑组合子条件查询

    固定分数查询   会把查询的分数固定下来 _score
    {
        "query" : {
            "constant_score": {
                "filter": {    固定分数查询不支持match, 也就是这一行不能去掉
                    "match": {
                        "title": "ElasticSearch"
                    }
                },
                "boost": 2   指定分数
            }
        }
    }

    布尔查询

    || 的逻辑
    {
        "query" : {
            "bool": {
                "should": {    应当满足
                    "match": {
                        "title": "ElasticSearch"
                    }
                },
                {
                    "match": {
                        "author": "卢奇"   可用支持多条件查询,只要满足两个条件中的一个就都可以查询到
                    }
                }
            }
        }
    }


    &&的逻辑
    {
        "query" : {
            "bool": {
                "must": {    必须满足条件                 (可以换成must_not 表示非必须)
                    "match": {
                        "title": "ElasticSearch"
                    }
                },
                {
                    "match": {
                        "author": "卢奇"   支持多条件查询,需要同时满足两个条件才能查询到
                    }
                }
            }
        }
    }
    ...more


SpringBoot集成ES

    <!-- 添加ES依赖 -->
    <dependency>
      <groupId>org.elasticsearch.client</groupId>
      <artifactId>transport</artifactId>
      <version>5.5.2</version>
    </dependency>

    <!-- ES依赖着log4j  版本要小于等于2.7版本 -->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <version>2.7</version>
    </dependency>

package com.imooc.miaosha.config;

import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * Created by luQi
 * 2018-05-05 22:55.
 */
@Configuration
public class MyConfig {

    // 如果是多个节点, 可以new多个对象addTransportAddress到 client中
    @Bean
    public TransportClient client() throws UnknownHostException {

        InetSocketTransportAddress node = new InetSocketTransportAddress(
                InetAddress.getByName("localhost"),
                9300
        );

        // 初始化自定义配置
        Settings settings = Settings.builder()
                .put("cluster.name", "luqi")
                .build();

        TransportClient client = new PreBuiltTransportClient(Settings.EMPTY);
        client.addTransportAddress(node);
        return client;
    }
}