全文检索--Lucene

2.1 全文检索和以前高级查询的比较

1.高级查询

缺点：1.like让数据库索引失效

2.每次查询都是查询数据库，如果访问的人比较多，压力也是比较大

2.全文检索框架：Apache - Lucene

优点：

1.可以相关度排序

2.可以对摘要进行截取

3.关键字高亮显示

2.2 Lucene测试

1.引入jar包

lucene-analyzers-common-5.5.0.jar

lucene-core-5.5.0.jar

lucene-queryparser-5.5.0.jar

2.创建索引，搜索索引

package cn.itsource.lucene;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.core.SimpleAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.FSDirectory;
import org.junit.Test;

import java.nio.file.Paths;

public class TestLucene {

    String doc1 = "hello world";
    String doc2 = "hello java world";
    String doc3 = "hello lucene world";
    //用来存放索引文件
    private String path ="D:\\lucene";

    //创建索引
    //步骤：
    //1、把文本内容转换为Document对象
    //2、准备IndexWriter（索引写入器）
    //3、通过IndexWriter，把Document添加到缓冲区并提交
    @Test
    public void testCreateIndex() throws Exception{

        //得到Director目录
        FSDirectory directory = FSDirectory.open(Paths.get(path));
        //(Directory d, IndexWriterConfig conf)
        //得到分词器
        Analyzer analyzer = new SimpleAnalyzer();
        //得到写入器配置对象
        IndexWriterConfig conf = new IndexWriterConfig(analyzer);
        //得到写入器对象
        IndexWriter indexWriter = new IndexWriter(directory,conf);

        //查询所有的Deparmtent 10 数据库的数据 -- 转换成10document
        //把数据存入文档
        Document doc11 = new Document();
        //   public TextField(String name, String value, Store store) {
        //参数：标题名，内容，是否存储
        doc11.add(new TextField("title","doc1", Field.Store.YES));
        doc11.add(new TextField("content",doc1,Field.Store.YES));

        Document doc12 = new Document();
        //   public TextField(String name, String value, Store store) {
        doc12.add(new TextField("title","doc2", Field.Store.YES));
        doc12.add(new TextField("content",doc2,Field.Store.YES));

        Document doc13 = new Document();
        //   public TextField(String name, String value, Store store) {
        doc13.add(new TextField("title","doc3", Field.Store.YES));
        doc13.add(new TextField("content",doc3,Field.Store.YES));



        indexWriter.addDocument(doc11);
        indexWriter.addDocument(doc12);
        indexWriter.addDocument(doc13);
        //提交写的索引
        indexWriter.commit();
        //关闭写的索引
        indexWriter.close();

    }

    //搜索索引
    @Test
    public void testIndexSearch() throws Exception{
        //1.查询索引

        //得到search搜索对象
        FSDirectory directory = FSDirectory.open(Paths.get(path));
        IndexReader r = DirectoryReader.open(directory);
        IndexSearcher searcher = new IndexSearcher(r);

        //搜索 (Query query, int n)
        //String f, Analyzer a  -> 查询的字段，分词对象
        String keyWord = "lucene";
        String f = "content";
        //得到一个分词器
        Analyzer analyzer = new SimpleAnalyzer();
        //得到query对象
        Query query = new QueryParser(f,analyzer).parse("content:"+keyWord);
        TopDocs topDocs = searcher.search(query, 100);
        
        //2.把索引转换为文档
        
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        for (ScoreDoc scoreDoc : scoreDocs) {
            //得到文档编号
            int docId = scoreDoc.doc;
            //通过文档编号得到文档
            Document doc = searcher.doc(docId);

            System.out.println(doc.get("title")+"----"+doc.get("content"));

        }


    }

}

注：需要更改idea的版本：设置 -> Build,Execution,Deployment -> Compiler -> Java Compiler -> Target bytecode version -> 1.8

1.Lucene介绍

Lucene：它是全文检索的工具包

2.Lucene使用场景

需要检索的结构化数据(非结构化数据：如：图片，结构化数据就是非结构化数据外的数据)----> 提高查询效率

3. 全文检索的核心

创建索引和搜索索引

4. 对Lucene的API认识

1. 索引库-Directory

MMapDirectory : 针对64系统，它在维护索引库时，会结合“内存”与硬盘同步来处理索引。

SimpleFSDirectory ：传统的文件系统索引库。 window系统就是使用

RAMDirectory ：内存索引库

2.文档-Document，字段-Field

3.字段-Field

数据库字段有类型有长度

索引库字段有类型其他属性(字段类型是否分词是否索引是否存储)

4.属性设置方式

1.方式一

document3.add(new TextField("title","doc3Title",Field.Store.YES));

2.方式二：对字段单独处理：

Document document = new Document();
FieldType fieldType = new FieldType();
fieldType.setStored(true);//设置是否存储
fieldType.setTokenized(true);//设置是否分词
fieldType.setIndexOptions(IndexOptions.DOCS);//设置是否创建索引
document.add(new Field("name",department.getName(),fieldType));

5.什么时候使用索引、分词、存储?

1.什么时候使用索引？

判断是否需要搜索的字段

2.是否分词？

考虑什么内容需要分词? 比如：模糊查询的内容，like "% keywords %"

3.是否存储?

判断是否把内容存储到索引库(内容比较长的字段不适合放到索引库)

5.分词器

1.分词器是什么

按照一定的

2.使用分词器

1.引入依赖

IKAnalyzer2012_V5.jar

2.测试

public class AnalyzerTest {

    //创建索引的数据 现在写死，以后根据实际应用场景
    private String en = "oh my lady gaga"; // oh my god
    private String cn = "迅雷不及掩耳盗铃儿响叮当仁不让";
    private String str = "源代码教育FullText Search Lucene框架的学习";
        
/**
     * 把特定字符串按特定的分词器来分词
     * @param analyzer：分词对象
     * @param str：需要分词的字符串
     * @throws Exception
     */
    public void testAnalyzer(Analyzer analyzer,String str) throws Exception {
        //把内容转换成流
        TokenStream tokenStream = analyzer.tokenStream("content", new StringReader(str));
        // 在读取词元流后，需要先重置/重加载一次
        tokenStream.reset();
        while(tokenStream.incrementToken()){
            System.out.println(tokenStream);
        }
    }

    //IK分词：从词典中查找
    // 简单使用：拷贝两个配置文件，拷贝一个jar包
    //
    //       扩展词，停止词
    //拷贝两个文件到项目resource中：IKAnalyzer.cfg.xml，stopword.dic
    //在ext.dic文件里面添加自定义的分词内容，实现自定义分词
    //  注意：打开方式，不要使用其他的，直接使用eclipse的text Editor,修改以后要刷新一下让项目重新编译
    
        /**
     * 配置停止词
     * 配置扩展词
     * @throws Exception
     */
    @Test
    public void test()throws Exception{
        //userSmart为true走最大匹配原则,有大不要小的
        //userSmart为false,默认值,细粒度匹配
        testAnalyzer(new IKAnalyzer(false),str);
    }
}

}

6.Lucene中的查询

1.上次的搜索方式，传入keyword

// 先做一个准备工作，提供两个search方法 
//一个传入搜索关键字进行搜索
public void search(String keyWord) throws Exception{

    //封装查询提交为查询对象
    String f = "content";
    SimpleAnalyzer analyzer = new SimpleAnalyzer();
    QueryParser queryParser = new QueryParser(f, analyzer);
    Query query = queryParser.parse(keyWord);
    System.out.println("query生成对象"+query.getClass());
    FSDirectory directory = FSDirectory.open(Paths.get(path));
    //得到IndexReader
    IndexReader indexReader = DirectoryReader.open(directory);

    IndexSearcher indexSearcher = new IndexSearcher(indexReader);
    TopDocs topDocs = indexSearcher.search(query, 1000);
    ScoreDoc[] scoreDocs = topDocs.scoreDocs;
    for (ScoreDoc scoreDoc : scoreDocs) {
        int docId = scoreDoc.doc;
        Document doc = indexSearcher.doc(docId);
        System.out.println("title:"+doc.get("title")+"===========content:"+doc.get("content"));
    }
}

2.可以出入Query对象

public void search(Query query) throws Exception{

     //封装查询提交为查询对象
     //String f = "content";
/*     SimpleAnalyzer analyzer = new SimpleAnalyzer();
     QueryParser queryParser = new QueryParser(f, analyzer);
     Query query = queryParser.parse(keyWord);*/

     FSDirectory directory = FSDirectory.open(Paths.get(path));
     //得到IndexReader
     IndexReader indexReader = DirectoryReader.open(directory);

     IndexSearcher indexSearcher = new IndexSearcher(indexReader);
     TopDocs topDocs = indexSearcher.search(query, 1000);

     ScoreDoc[] scoreDocs = topDocs.scoreDocs;
     for (ScoreDoc scoreDoc : scoreDocs) {
         int docId = scoreDoc.doc;
         Document doc = indexSearcher.doc(docId);
         System.out.println("title:"+doc.get("title")+"===========content:"+doc.get("content"));
     }
 }

//创建Query对象
new TermQuery(new Term("context","java"));

1.查询方式分类

1.单词查询：传入Query对象

2.段落查询：多个单词当做一个整体

//1.使用转义符，把多个单词当做一个整体
String s = "\"hello word"\";

//2.使用builder对象，把多个单词当做一个整体
//静态内部类
PhraseQuery.Builder builder = new PhraseQuery.Builder();
builder.add(new Term("content","hello"));
builder.add(new Term("content","world"));

3.通配符查询：

//通配符查询：
//  *：代表零个或者多个  --> 注意：不能把*放在最前面，必须在*前面放内容，比如：*e不对，e*才对
//  ?：代表一个

4.容错查询：

//容错2个
String s = "lucexx~2";

//也可以用Query对象,名字叫content的字段，容错2个
FuzzyQuery query = new FuzzyQuery(new Term("content","lucexx"),2);

5.临近查询：

在段落查询的基础上用“~”后面跟一个1到正无穷的正整数。代表段落中，单词与单词之间最大的间隔数

//最大间隔2个
String s = "\"hello world\"~2";

//builder对象
PhraseQuery.Builder builder = new PhraseQuery.Builder();
builder.add(new Term("content","hello"));
builder.add(new Term("content","world"));
//设置最大间隔数
builder.setSlop(2);
PhraseQuery query = builder.build();

6.组合查询：

//写法一：
//字段前面带个加号：必须包含的内容
//字段前带个减号：必须不包含
String s1 = "content:java content:lucene";//什么都不加
String s2 = "+content:java +content:lucene";//前面带加号：必须包含
String s3 = "-content:java -content:lucene";//前面带减号：必须不包含

//写法二：使用BooleanQuery.Builer对象
BooleanQuery.Builder builder = new BooleanQuery.Builder();
builder.add(new TermQuery(new Term("content","hello")),Occur.MUST);//必须包含
builder.add(new TermQuery(new Term("content","lucene")),Occur.MUST_NOT);//必须不包含

2.项目里使用全文检索

1.lucene在项目中的使用场景

1.查询的时候：搜索量比较大的地方/数据比较多的地方，比如：日志管理

2 什么时候把数据同步到索引库

1.即时同步，在操作数据库进行crud的时候，同步到索引库

2.自动同步，借助定时器

3.手动同步，页面添加按钮进行同步

3. 项目引入Luence索引库

1.导入依赖

<dependencies>
    <!-- https://mvnrepository.com/artifact/org.apache.lucene/lucene-core -->
    <dependency>
        <groupId>org.apache.lucene</groupId>
        <artifactId>lucene-core</artifactId>
        <version>5.5.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.lucene/lucene-queryparser -->
    <dependency>
        <groupId>org.apache.lucene</groupId>
        <artifactId>lucene-queryparser</artifactId>
        <version>5.5.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.wltea/IKAnalyzer -->
    <dependency>
        <groupId>org.wltea</groupId>
        <artifactId>IKAnalyzer</artifactId>
        <version>2012_V5</version>
    </dependency>


    <dependency>
        <groupId>cn.itsource</groupId>
        <artifactId>itsource_common</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

手动打包IKAnalyzer到maven仓库：

cmd -> mvn install:install-file -Dfile=IKAnalyzer2012_V5.jar -DgroupId=org.wltea -DartifactId=IKAnalyzer -Dversion=2012_V5 -Dpackaging=jar

命令结构：mvn install:install-file -Dfile=jar包名字加后缀名 -Dgroupld=项目名 -DartifactId=组名 -Dversion=版本号 -Dpackaging=打包方式

<- service层要依赖Luence ->
    <dependency>
        <groupId>cn.itsource</groupId>
        <artifactId>itsource_fullTextIndex</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>

2.集成工具类

package cn.itsource.lucene.util;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.*;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.*;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.wltea.analyzer.lucene.IKAnalyzer;

import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

public class LuceneUtil {

    private static final String INDEX_DIRCTORY = "F:/lucene/index";
    private static Directory directory;//存放索引的目录
    private static IndexWriter indexWriter;//索引写对象，线程安全
    private static IndexReader indexReader;//索引读对象，线程安全
    private static IndexSearcher indexSearcher;//索引查询对象，线程安全
    private static Analyzer analyzer;//分词器对象

    static{
        try {
            //如果父目录不存在，先创建父目录
            File file = new File(INDEX_DIRCTORY);
            if(!file.getParentFile().exists()){
                file.getParentFile().mkdirs();
            }
            directory = FSDirectory.open(Paths.get(INDEX_DIRCTORY));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取IndexWriter对象
     * @return
     * @throws IOException
     */
    public static IndexWriter getIndexWriter(){
        try {
            Analyzer analyzer = getAnalyzer();
            IndexWriterConfig conf = new IndexWriterConfig(analyzer);
            return  new IndexWriter(directory,conf);
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取IndexReader
     * @return
     * @throws Exception
     */
    public static IndexReader getIndexReader(){
        try {
            if(indexReader==null){
                indexReader = DirectoryReader.open(directory);
            }else {
                //如果不为空，就使用DirectoryReader打开一个索引变更过的IndexReader类
                DirectoryReader newIndexReader = DirectoryReader.openIfChanged((DirectoryReader) indexReader);
                if(newIndexReader!=null){
                    //把旧的索引读对象关掉
                    indexReader.close();
                    indexReader = newIndexReader;
                }
            }
            return indexReader;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取IndexSearcher对象
     * @return
     * @throws IOException
     */
    public static IndexSearcher getIndexSearcher(){
        if(indexSearcher==null){
            indexSearcher = new IndexSearcher(getIndexReader());
        }
        return indexSearcher;
    }

    /**
     * 获取分词器对象
     * @return
     */
    public static Analyzer getAnalyzer() {
        if(analyzer!=null){
            return analyzer;
        }
        return new IKAnalyzer();
    }

    /**
     * 创建QueryParser对象
     * @param field
     * @return
     */
    public static QueryParser createQueryParser(String field){
        return new QueryParser(field,getAnalyzer());
    }

    /**
     * 创建Query对象
     * @param field
     * @param queryStr
     * @return
     */
    public static BooleanQuery createQuery(String field[],String queryStr){
        BooleanQuery.Builder builder = new BooleanQuery.Builder();
        for (String f : field) {
            builder.add(new TermQuery(new Term(f,queryStr)), BooleanClause.Occur.SHOULD);
        }
        return builder.build();
    }

    /**
     * 分页查询索引
     * @param field
     * @param queryStr
     * @param pageNum
     * @param pageSize
     * @return
     * @throws IOException
     */
    public static List<Document> getHitDocuments(String[] field,String queryStr,int pageNum,int pageSize){

        List<Document> list = new ArrayList<>();

        try {
            IndexSearcher indexSearcher = getIndexSearcher();
            Query query = createQuery(field,queryStr);
            System.out.println(query);

            // 查询数据， 结束页面自前的数据都会查询到，但是只取本页的数据
            TopDocs topDocs = indexSearcher.search(query, pageNum * pageSize);
            ScoreDoc[] scoreDocs = topDocs.scoreDocs;

            //总条目数
            int totalHits = topDocs.totalHits;

            int start = (pageNum-1)*pageSize;
            int end = (pageNum*pageSize)>totalHits?totalHits:(pageNum*pageSize);
            for(int i=start;i<end;i++){
                ScoreDoc scoreDoc = scoreDocs[i];
                Document document = indexSearcher.doc(scoreDoc.doc);
                list.add(document);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 总共命中的条目数
     * @param field
     * @param queryStr
     * @return
     * @throws IOException
     */
    public static long totalHits(String[] field,String queryStr){
        try {
            IndexSearcher indexSearcher = getIndexSearcher();
            Query query = createQuery(field,queryStr);
            TopDocs topDocs = indexSearcher.search(query, 10);
            return topDocs.totalHits;
        } catch (IOException e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 删除索引
     * @param field
     * @param queryStr
     * @throws IOException
     */
    public static void deleteIndex(String[] field,String queryStr){
        try {
            IndexWriter indexWriter = getIndexWriter();
            Query query = createQuery(field,queryStr);
            indexWriter.deleteDocuments(query);
            indexWriter.commit();
            indexWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除所有索引
     * @throws IOException
     */
    public static void deleteAllIndex()throws IOException{
            IndexWriter indexWriter = getIndexWriter();
           indexWriter.deleteAll();
           indexWriter.commit();
           indexWriter.close();
    }

    /**
     * 更新索引文档
     * @param term
     * @param document
     */
    public static void updateIndex(Term term,Document document) {
        try {
            IndexWriter indexWriter = getIndexWriter();
            indexWriter.updateDocument(term, document);
            indexWriter.commit();
            indexWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 更新索引文档
     * @param field
     * @param value
     * @param document
     */
    public static void updateIndex(String field,String value,Document document) {
        updateIndex( new Term(field, value), document);
    }

    /**
     * 添加索引文档
     * @param document
     */
    public static void addIndex(Document document) {
        updateIndex(null, document);
    }


    /**
     * 关闭资源
     */
    public static void closeAll(){
        try {
            if (indexWriter!=null)
                indexWriter.close();
            if(indexReader!=null)
                indexReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

3.IDepartmentIndexHelper接口

package cn.itsource.lucene.index;

import cn.itsource.basic.PageList;
import cn.itsource.domain.Department;
import cn.itsource.query.DepartmentQuery;

import java.util.Map;

/**
 * 对索引库里面Department进行进行crud接口
 */
public interface IDepartmentIndexHelper {
    void save(Department department);
    void remove(Long id);
    void update(Department department);
    PageList<Department> list(DepartmentQuery query);
}

4.刚才接口的实现类：DepartmentIndexHelper类

package cn.itsource.lucene.index.impl;

import cn.itsource.basic.PageList;
import cn.itsource.domain.Department;
import cn.itsource.domain.Employee;
import cn.itsource.domain.Tenant;
import cn.itsource.lucene.index.IDepartmentIndexHelper;
import cn.itsource.lucene.util.LuceneUtil;
import cn.itsource.query.DepartmentQuery;
import org.apache.lucene.document.*;
import org.apache.lucene.index.MergePolicy;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.*;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@Component
public class DepartmentIndexHelper implements IDepartmentIndexHelper {
    @Override
    public void save(Department department) {
        try {
            Document document = department2doc(department);
            LuceneUtil.addIndex(document);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void remove(Long id) {
        try {
            // id字段中存在id就删除
            LuceneUtil.deleteIndex(new String[]{"id"},id+"");
        } catch (Exception e) {
            e.printStackTrace();
        }


    }

    @Override
    public void update(Department department) {
        try{
            Term term = new Term("id", department.getId() + "");
            LuceneUtil.updateIndex(term,department2doc(department));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public PageList<Department> list(DepartmentQuery query) {
       String keywords = query.getKeywords();
        Query indexQuery = null;
        if (StringUtils.isEmpty(keywords)){

            //name中包含*
            indexQuery =  new WildcardQuery(new Term("name","*"));
        }else{
            indexQuery = LuceneUtil.createQuery(
                    new String[]{"name","sn","companyName","pname","username"}, keywords);
        }
        int pageNum = query.getPage().intValue();
        int pageSize = query.getPageSize().intValue();
        try {
            IndexSearcher indexSearcher = LuceneUtil.getIndexSearcher();
            System.out.println(query);

            //pageNum 1  pageSize 10   10(pageNum * pageSize)   1-10 (page-1)*pageSize,pageSize
            //pageNum 2  pageSize 10   20   10-20
            //pageNum 3  pageSize 10   30    20-30
            // 查询数据， 结束页面自前的数据都会查询到，但是只取本页的数据
            TopDocs topDocs = indexSearcher.search(indexQuery, pageNum * pageSize);
            ScoreDoc[] scoreDocs = topDocs.scoreDocs;

            //总条目数
            int totalHits = topDocs.totalHits;
            if (totalHits<1){
                return  new PageList<>();
            }else{
                int start = (pageNum-1)*pageSize;
                int end = (pageNum*pageSize)>totalHits?totalHits:(pageNum*pageSize);
                List<Department> departments = new ArrayList<>();
                for(int i=start;i<end;i++){
                    ScoreDoc scoreDoc = scoreDocs[i];
                    Document document = indexSearcher.doc(scoreDoc.doc);
                    departments.add(document2Department(document));
                }
                return new PageList<Department>(Long.parseLong(totalHits+""),departments);
            }


        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    private Department document2Department(Document document) {
        Department department = new Department();
        department.setId(Long.parseLong(document.get("id")));
        department.setSn(document.get("sn"));
        department.setName(document.get("name"));
        department.setDirPath(document.get("dirPath"));
        department.setState(Integer.parseInt(document.get("state")));
        if (!StringUtils.isEmpty(document.get("mid"))){
            Employee manager = new Employee();                              // 部门经理 员工对象
            manager.setId(Long.parseLong(document.get("mid")));
            manager.setUsername(document.get("username"));
            department.setManager(manager);
        }

        if (!StringUtils.isEmpty(document.get("pid"))){
            Department parent = new Department();                              // 部门经理 员工对象
            parent.setId(Long.parseLong(document.get("pid")));
            parent.setName(document.get("pname"));
            department.setParent(parent);
        }

        if (!StringUtils.isEmpty(document.get("tid"))){
            Tenant tenant = new Tenant();                              // 部门经理 员工对象
            tenant.setId(Long.parseLong(document.get("tid")));
            tenant.setCompanyName(document.get("companyName"));
            department.setTenant(tenant);
        }
        return department;
    }


    private Document department2doc(Department department) {
        Document document = new Document();
        document.add(new LongField("id",department.getId(), Field.Store.YES));
        document.add(new StringField("sn",department.getSn(), Field.Store.YES));
        document.add(new TextField("name",department.getName(), Field.Store.YES));
        if (department.getManager()!=null){

            document.add(new LongField("mid",department.getManager().getId(), Field.Store.YES));
            document.add(new TextField("username",department.getManager().getUsername(), Field.Store.YES));
        }
        if (department.getParent()!=null){
            document.add(new LongField("pid",department.getParent().getId(), Field.Store.YES));
            document.add(new TextField("pname",department.getParent().getName(), Field.Store.YES));
        }
        if (department.getTenant()!=null){
            document.add(new LongField("tid",department.getTenant().getId(), Field.Store.YES));
            document.add(new TextField("companyName",department.getTenant().getCompanyName(), Field.Store.YES));
        }

        document.add(new StringField("dirPath",department.getDirPath(), Field.Store.YES));
        document.add(new IntField("state",department.getState(), Field.Store.YES));
        return document;
    }
}

5.项目中实现类：DepartmentServiceImpl，中做操作数据库CRUD时，修改索引库

package cn.itsource.service.impl;

import cn.itsource.basic.PageList;
import cn.itsource.basic.query.BaseQuery;
import cn.itsource.basic.service.impl.BaseServiceImpl;
import cn.itsource.domain.Department;
import cn.itsource.lucene.index.IDepartmentIndexHelper;
import cn.itsource.mapper.DepartmentMapper;
import cn.itsource.query.DepartmentQuery;
import cn.itsource.service.IDepartmentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.List;

@Service
/**
 * 做增删改的时候同步修改索引库
 */
public class DepartmentServiceImpl extends BaseServiceImpl<Department> implements IDepartmentService {
    @Autowired
    private DepartmentMapper departmentMapper;

    @Autowired
    private IDepartmentIndexHelper indexHelper;
   

    @Override
    public void add(Department department) {

        departmentMapper.save(department);
        indexHelper.save(department);
    }

    @Override
    public void del(Serializable id) {
        departmentMapper.remove(id);
        indexHelper.remove(Long.parseLong(id.toString()));
    }

    @Override
    public void update(Department department) {
        departmentMapper.update(department);
        indexHelper.update(department);
    }

    //不需要到数据库查询,直接到索引库查询
    @Override
    public PageList<Department> query(BaseQuery query) {
        DepartmentQuery departmentQuery = (DepartmentQuery) query;
        return indexHelper.list(departmentQuery);
    }
}

6.测试

测试类：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext-service.xml","classpath:applicationContext-mybatis.xml"})
public class BaseTest {
}

测试方法：放入索引库

@Test
    public void testAddExsitDepartmentIndexs()throws Exception{
        List<Department> departments = departmentService.getAll();

        for (Department department : departments) {
            indexHelper.save(department);
        }
    }

4.高亮显示

1.引入依赖

lucene-highlighter-5.5.0.jar lucene-memory-5.5.0.jar

2.创建高亮器

3.使用高亮器对查询结果进行高亮处理

4.高亮放到项目中

前端代码：

<el-table-column prop="state" label="状态">
   <template slot-scope="scope">
      <span v-if="scope.row.state!=null && scope.row.state==-1" style="color: red">停用</span>
      <span v-else>正常</span>
   </template>
</el-table-column>
<el-table-column prop="manager.username" label="部门经理">
   <template slot-scope="scope">

      <div v-if="scope.row.manager!=null" v-html="scope.row.manager.username"></div>
   </template>
</el-table-column>

2. 全文检索--ElasticSearch(即ES)

2.1 什么是ES

ElasticSearch ：做全文检索的框架，是由Lucene封装的，支持分布式支持集群

索引库管理支持，还是Lucene的索引库

2.1.1 什么是Lucene

Lucene：api比较麻烦，操作全文检索的最底层技术，核心：创建索引，搜索索引

2.1.2 类似框架solr

solr是最流行的企业级搜索引擎，Solr4还增加了NoSQL的支持。

和Solr和ES比较？

Solr利用Zookeeper(注册中心)进行分布式管理，支持更多格式的数据(HTML/PDF/CSV)

ES是轻量级的，只支持json操作格式，在实时搜索方面比solr效率高

2.13 其实类似框架-Katta和HadoopContrib

Katta基于Lucene，支持分布式，可扩展，具有容错功能，准实时的搜索方案，配合Hadoop使用

HadoopContrib跟 Katta 配合使用

2.2 ES的优势

1.做全文检索的Lucene的API操作特别繁琐，用起来不方便，ES可以用来替换Lucene，并优化调用方式

2.ES支持高并发的分布式集群

3.ES通过发送restfull风格就可以完成的数据操作：put/delete/post/get

2.3 ES的特点

1.分布式的实时文件存储，每个字段都被索引并可被搜索

2.分布式的实时分析搜索引擎

3.可以扩展到上百台服务器，处理PB级结构化或非结构化数据

4.高度集成化的服务，应用可以通过简单的RESTfull API、各种语言的客户端甚至命令行与之交互

5.上手ElasticSearch非常容易

2.4 ES和其他全文检索框架的比较

1.ES和Solr的比较：

ES在实时搜索效率高于solr

solr是重量级，用起来做很多配置，但是功能很强大

它们都是注册分布式

2.5 ES安装服务器

1.ES依赖JDK，推荐使用JDK1.7+

2.官方下载安装包：https://www.elastic.co/downloads/elasticsearch，elasticsearch-5.2.2.zip

3.修改内存配置：

elasticsearch-5.2.2\config\jvm.options中更改: -Xms2g 和 -Xmx2g

4.运行ES：bin目录下：elasticsearch.bat

5.验证(ES提供了两个端口，web访问9200，java访问9300)：web访问：http://localhost:9200/ ，java是访问：http://localhost:9300/

2.5.1 集群健康状态

Elasticsearch 中其实有专门的衡量索引健康状况的标志，分为三个等级：

1.green，绿色。这代表所有的主分片(primary shared)和副本分片(从分片replica shared)都已分配。集群是 100% 可用的。

2.yellow，黄色。所有的主分片已经分片了，但至少还有一个副本是缺失的。不会有数据丢失，所以搜索结果依然是完整的。

3.red，红色。至少一个主分片以及它的全部副本都在缺失中。这意味着你在缺少数据：搜索只能返回部分数据，而分配到这个分片上的写入请求会返回一个异常

2.5.2 操作ES的客户端工具

1.Curl命令方式

windows中使用，需要在火狐的“扩展”中搜索“POSTER”，并安装改扩展工具，使用Curl命令

2.Java API

3.Kibana

4.head：可以直接看到shard和replica + postman

2.5.3 Restful认识

2.5.3.1 ES里面的Restful风格

ES里面Restful风格只有：GET,POST,DELETE,PUT操作

2.5.3.2 使用Restful的好处：

透明性，暴露资源存在。

充分利用 HTTP 协议本身语义。

无状态，这点非常重要。在调用一个接口（访问、操作资源）的时候，可以不用考虑上下文，不用考虑当前状态，极大的降低了复杂度。

HTTP 本身提供了丰富的内容协商手段，无论是缓存，还是资源修改的乐观并发控制，都可以以业务无关的中间件来实现。

2.5.3.3 ES里面的Restful风格举例

GET 用来获取资源，

POST 用来新建资源（也可以用于修改资源），

PUT 用来修改资源，

DELETE 用来删除资源。

get -> GET /rest/api/dogs 获取所有小狗狗

post -> POST /rest/api/dogs 添加一个小狗狗

put -> PUT /rest/api/dogs/12 修改一个小狗狗

delete -> DELETE /rest/api/dogs/12 删除一个小狗狗

2.6 辅助管理工具Kibana5安装

① Kibana5.2.2 下载地址：https://www.elastic.co/downloads/kibana ：kibana-5.2.2-windows-x86.zip

② 解压并编辑config/kibana.yml，设置elasticsearch.url的值为已启动的ES

③ 启动 : bin文件夹下：kibana.bat

④ 默认访问地址：http://localhost:5601

Kibana5客户端里面的选项：

1.Discover：可视化查询分析器

2.Visualize：统计分析图表

3.Dashboard：自定义主面板（添加图表）

4.Timelion：Timelion是一个kibana时间序列展示组件（暂时不用）

5.Dev Tools ：Console（同CURL/POSTER，操作ES代码工具，代码提示，很方便）

6.Management：管理索引库(index)、已保存的搜索和可视化结果(save objects)、设置 kibana 服务器属性。

//各行内容的涵义
"_index": ".kibana", //索引库
"_type": "config",  //表名
"_id": "5.2.2", //具体哪条数据
"_score": 1,    //得分
"_source": {    //字段
"buildNum": 14723
}

2.7 head工具的安装

head工具：查看集群信息

进入head页面进行安装

1)安装

下载：

npm install --时间有点久

npm run start

2) 配置：跨域访问

修改 elasticsearch/config/elasticsearch.yml 文件：

增加：

1.http.cors.enabled: true

2.http.cors.allow-origin: "*"

3) 使用：访问：http://localhost:9100

3 ES的操作

传统数据库和ES的对应关系：

关系数据库（MYSQL） -> 数据库DB-> 表TABLE-> 行ROW-> 列Column

Elasticsearch -> 索引库Indices -> 类型Types -> 文档Documents -> 字段Fields

	database数据库	索引库	ES索引库
表(类型)	table	documents	type
字段(某一个数据)	column	document(field)	id

3.2 文档的增删改

语法：

①使用自己的ID创建：

PUT index/type/id  ：自己指定一个id值(id唯一标识)

②ES内置ID创建(id自动生成)：

POST index/type  ：自动生成唯一标识

③ 获取指定ID的文档

GET itsource/employee/123?pretty

返回文档的部分字段：

GET默认返回整个文档，通过GET /itsource/employee/123?_source=fullName,email

只返回文档内容，不要元数据：

GET itsource/employee/123/_source

④ 修改文档

更新整个文档：

同PUT {index}/{type}/{id}

局部更新文档：

接受一个局部文档参数 doc，它会合并到现有文档中，对象合并在一起，存在的标量字段被覆盖，新字段被添加。

POST itsource/employee/123/_update

{

“doc”:{

"email" : ["nixianhua@itsource.cn",](mailto:\) 

"salary": 1000

}

}

⑤删除

DELETE index/type/id

3.3 代码演示

#新增
PUT crm/user/1
{
  "name":"小明",
  "age":18
}

#查询
GET crm/user/1

#修改
POST crm/user/1
{
  "name":"小红",
  "age":28
}

#删除
DELETE crm/user/1

#不指定id的新增，会自动生成id
POST crm/user
{
  "name":"娃哈哈",
  "age":17
}

#查询所有
GET _search

#查询没有指定id的新增
GET crm/user/AW8i3Gt6KOmHoXbO0PFk

#漂亮格式->没有太多变化
GET crm/user/AW8i3Gt6KOmHoXbO0PFk?pretty

#带元数据的查询指定列
GET crm/user/AW8i3Gt6KOmHoXbO0PFk?_source=name,age

#不带元数据的查询指定列
GET crm/user/AW8i3Gt6KOmHoXbO0PFk/_source

#修改覆盖之前的json
#更改一个字段会全部覆盖
POST crm/user/AW8i3Gt6KOmHoXbO0PFk
{
  "name":"爽歪歪"
}

#修改和新增都可以用post
POST crm/user/AW8i3Gt6KOmHoXbO0PFk
{
  "name":"皮皮怪",
  "age":39
}

#局部修改
POST crm/user/AW8i3Gt6KOmHoXbO0PFk/_update
{
  "doc":{
    "age":20
  }
}

#脚本更新---了解
POST crm/user/AW8i3Gt6KOmHoXbO0PFk/_update
{
  "script":"ctx._source.age += 2"
}

#删除文档
DELETE crm/user/AW8i3Gt6KOmHoXbO0PFk

GET _search

#批量插入(不推荐)，不要分行，不然会报错
POST _bulk
{"delete":{"_index":"xinyang","_type":"job","_id":"123"}}
{"create":{"_index":"xinyang","_type":"student","_id":"123"}}
{"title":"我的学生"}
{"index":{"_index":"xinyang","_type":"student","_id":"456"}}
{"title":"我的另一个学生"}

#批量查询
GET xinyang/student/_mget
{
  "ids":["123","456"]
}

GET _search

1.ElasticSearch

1.0 总结ES的语法

1.分页：   size：每页条数，from：从哪一个索引开始
2.模糊查询： wildcard
3.DSL(domian specific language特定领域语言)，DSL查询：query+match_all/match
4.DSL过滤：query+bool+must/must_not

1.1 ES文档的简单查询

1.通过文档ID获取：get index/type/id（index：索引库名，type：表名）

2.批量获取：

1.同一个索引库的，不同表：略

2.同一个索引库的，同一张表：GET index/type/_mget

3.空搜索：查询全部

没有指定任何的查询条件，只返回集群索引中的所有文档： GET _search

4.分页搜索

size : 每页条数，默认 10

from : 跳过开始的结果数，默认 0

GET _search?size=5&from=5

5.查询字符串搜索

条件查询：(年龄为25) GET itsource/employee/_search?q=age:25

条件查询(范围查询：age：20~30)：age[20 TO 30]

## 查询指定索引库
get itsource/blog/_search


## 批量查询(查询同一个库，同一张表)
GET itsource/blog/_mget
{
  "ids":["123","AW0fiJ4ZOy02M7ta5jyb"]
}

## 查询所有数据(空搜索)
GET _search

## 分页查询：size表示每页最大条数，from：从哪一条索引开始
GET itsource/blog/_search?size=2&from=0


PUT crm/employee/1
{
  "id":1,
  "name":"xxx",
  "age":18,
  "sex":false,
  "hobbys":"美女"
}
PUT crm/employee/2
{
  "id":2,
  "name":"xxx",
  "age":28,
  "sex":false,
  "hobbys":"游戏"
}
PUT crm/employee/3
{
  "id":3,
  "name":"xxx",
  "age":38,
  "sex":false,
  "hobbys":"购物"
}

## 查询字符串搜索
GET crm/employee/_search?q=age:18

## 范围查询
GET crm/employee/_search?q=age[20 TO 40]

GET crm/employee/_search?q=age[20 To 40]&from=0&size=2

2.DSL查询与过滤

代码实现：

#分页查询

DELETE xinyang

#先创建几条数据
PUT xinyang/student/1
{
  "name":"wangwamg",
  "age":1
}

PUT xinyang/student/2
{
  "name":"wamgxoap",
  "age":2
}

PUT xinyang/student/3
{
  "name":"wamgxoap12",
  "age":3
}

PUT xinyang/student/4
{
  "name":"wamgxoap33",
  "age":4
}

PUT xinyang/student/5
{
  "name":"wamgxoap44",
  "age":5
}

PUT xinyang/student/6
{
  "name":"wamgxoap13332",
  "age":6
}

PUT xinyang/student/7
{
  "name":"wamgxoap22222",
  "age":7
}

#分页查询实现,不带from默认为0，得到结果是随机的，第1页，每页3条
GET xinyang/student/_search?size=3

#分页查询实现，第4页，每页2条
GET xinyang/student/_search?from=3&size=2

#根据条件查询，如果条件比较多就不适合
#q是指代字符串
GET xinyang/student/_search?q=age:4

#条件查询，先写size，再写条件，用&连接
#查询范围时，必须用TO，而且必须是大写
GET xinyang/student/_search?size=2&q=age[2 TO 5]

#DSL查询
#1.原语句
GET xinyang/student/_search?q=name:3王
#2.DSL查询语句：match:完全匹配
#测试的时候最好不用中文，避免因为分词引起结果不对
#相当于SQL语句：select * from student where name="wamgxoap13332"
GET xinyang/student/_search
{
"query" : {
   "match" : {
        "name" : "wamgxoap13332"
  }
}
}

#wildcard：模糊查询
#相当于SQL：select * from student where name like "*1333*"
GET xinyang/student/_search
{
  "query": {
    "wildcard": {
      "name": "*1333*"
    }
  }
}

#DSL查询+分页+排序，不支持缓存
#相当于SQL：select * from student order by age desc limit 0,3
GET xinyang/student/_search
{
  "query":{
    "match_all": {}
  },
  "from": 0,
  "size": 3,
  "_source": ["name","age"],
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ]
}

#DSL过滤
#相当于SQL：select * from student where age = 7 and name = xinyang
GET xinyang/student/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "wamgxoap22222"
          }
        }
      ],
      "filter": {
        "term": {
          "age": "7"
        }
      }
    }
  }
  , "from": 0,
  "size": 3,
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ]
}

#must_not：必定不存在
GET xinyang/student/_search
{
  "query": {
    "bool": {
      "must_not": [
        {
          "match": {
            "name": "wamg"
          }
        }
      ],
      "filter": {
        "term": {
          "age": "7"
        }
      }
    }
  }
  , "from": 0,
  "size": 3,
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ]
}

2.1 DSL

DSL(Domain Specific Language特定领域语言)以JSON请求体的形式出现

2.1 DSL查询和DSL过滤的区别

DSL=DSL查询+DSL过滤

DSL查询：精确查询

DSL过滤：模糊查询

DSL过滤和DSL查询在性能上的区别：

1.过滤结果可以缓存并应用到后续请求。

2.查询语句同时匹配文档，计算相关性，所以更耗时，且不缓存。

3.过滤语句可有效地配合查询语句完成文档过滤(DSL查询和DSL过滤可以共用起来使用)

DSL查询语法：query+match_all/math

## DSL查询的写法
GET crm/employee/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 3,
  "_source": ["name","age"],
  "sort": [
    {
      "age": "desc"
    }
  ]
}

DSL过滤语法：query+bool+must/must_not

gt:> gte:>= lt:< lte:<=

## DSL过滤的写法
GET crm/employee/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {
          "name": "xxx"
        }}
      ],
      "filter": {
        "term": {
          "age": "18"
        }
      },
      "from": 20, 
      "size": 10,
      "_source": ["fullName", "age", "email"],
      "sort": [{"join_date": "desc"},{"age": "asc"}]
    }
  }
}

3.分词与映射

3.1 IK分词器

① Maven打包IK插件

② 解压target/releases/elasticsearch-analysis-ik-5.2.2.zip文件

并将其内容放置于ES根目录/plugins，把放进去的文件夹改名为：ik

③ 配置插件：

插件配置:plugin-descriptor.properties

④ 分词器（可默认）

词典配置：config/IKAnalyzer.cfg.xml

⑤ 重启ES

⑥ 测试分词器

#这里也可以用GET
POST _analyze
{
  "analyzer":"ik_smart",
  "text":"中国驻洛杉矶领事馆遭亚裔男子枪击 嫌犯已自首"
}

3.2 文档映射Mapper

ES的文档映射(mapping)机制用于进行字段类型确认，将每个字段匹配为一种确定的数据类型

3.2.1 ES字段类型

①基本字段类型

字符串：text(分词),keyword(不分词) StringField(不分词文本),TextFiled(要分词文本)

text默认为全文文本，keyword默认为非全文文本

数字：long,integer,short,double,float

日期：date

逻辑：boolean

② 复杂数据类型

对象类型：object

数组类型：array

地理位置：geo_point,geo_shape

3.2.2 ES默认映射字段类型

GET {indexName}/_mapping/{typeName}

#查询映射类型
GET xinyang/_mapping/student

3.2.3 ES自定义映射

查看系统默认映射类型：

#查询映射类型：
GET shop/goods/_mapping

#修改映射类型
#1.删除库
Delete shop;
#2.创建库
PUT shop;
#3.查询默认映射
POST shop/goods/_mapping
{
"goods": {
"properties": {
"price": {
"type": "integer"
            },
"name": {
"type": "text",
"analyzer": "ik_smart",
"search_analyzer": "ik_smart"
            }
        }
    }
}

#加入数据
put shop/goods/1
{
  "price":88,
  "name": "iphone8"
}

自定义字段映射：

# 删除索引库
DELETE shop;
# 创建索引库
PUT shop;
##　自定义字段映射
POST shop/goods/_mapping
{
  "goods": {
  "properties": {
  "price3": {
    "type": "double"
              },
  "name3": {
  "type": "text",
  "analyzer": "ik_smart",
  "search_analyzer": "ik_smart"
              }
          }
      }
}

3.2.4 ES全局映射

全局映射可以通过动态模板和默认设置两种方式实现。

动态模板：提示把设定属性的规则设定好，加入数据的时候，会按照我们设置的规则映射

#//创建名为global_template的模板
PUT _template/global_template  
{
    #//匹配所有索引库
  "template":   "*",  
    #//匹配到的索引库只创建1个主分片
  "settings": { "number_of_shards": 1 }, 
  "mappings": {
    "_default_": {
      "_all": { 
          #//关闭所有类型的_all字段
        "enabled": false 
      },
      "dynamic_templates": [
        {
          "string_as_text": { 
              #//匹配类型string
            "match_mapping_type": "string",
              #//匹配字段名字以_text结尾
            "match":   "*_text",  
            "mapping": {
                #//将类型为string的字段映射为text类型
              "type": "text",
              "analyzer": "ik_max_word",
              "search_analyzer": "ik_max_word"
            }
          }
        },
        {
          "string_as_keyword": {
            #//匹配类型string
            "match_mapping_type": "string",
            "mapping": {
                #//将类型为string的字段映射为keyword类型
              "type": "keyword"
             }
          }
        }
      ]
    }
  }}

(1) 拷贝上面代码执行

(2) 删除库 delete shop

(3) 创建库 put shop

(4) 指定动态模板

(5) 加入数据,字段类型 ,根据指定类型做相应

(6) 在java创建索引或者添加数据, 分词存起来,查询也会根据分词去查

加入数据测试：

POST shop/goods/5
{
    "id":12,
    "name_text":"iphone x",
    "local":"cnsssss"
}

3.2.5 优先级

优先级：1.自定义 --> 2.全局 ---> 默认

最佳实践：先全局(根据公司规定)，再自己自定义，再使用默认

4.ElasticSearch集群

4.1 为什么需要集群

1.处理高并发，大量数据，提高性能 2.解决单点故障

4.2 elasticsearch集群

4.2.1 ES的节点

ES节点类型Node有三种节点:  
master Node:主节点,维护集群信息 索引库操作
data  node:数据节点,  文档crud
client node:只负责处理用户请求

node.master:true：该节点有资格成为主节点，如果是false，则该节点不能进行选举，不能成为主节点
node.data:true：该节点可以存储数据，如果是false，则该节点不能存储数据

ES默认是：node.master:true ，node.data:true，即：该节点可以成为主节点，可以存储数据

4.2.2 集群主从分片分配机制： shard&replica

主分片和从分片不能在一个节点(单词：primary shard:主分片，replica shard:从分片)

4.2.3 虚拟集群

1.准备3个ES节点：拷贝3个ES文件，分别取名为node1,node2，node3

2.修改配置：jvm.options修改内存配置，并配置elasticsearch.yml

1.jvm.options修改内存配置：

-Xms1g
-Xmx1g

2.配置文件：elasticsearch.yml，有3个节点，都有不同配置

1.node-1配置：

# 统一的集群名
cluster.name: my-ealsticsearch
# 当前节点名
node.name: node-1
# 对外暴露端口使外网访问
network.host: 127.0.0.1
# 对外暴露端口
http.port: 9201
#集群间通讯端口号
transport.tcp.port: 9301
#集群的ip集合，可指定端口，默认为9300
discovery.zen.ping.unicast.hosts: [“127.0.0.1:9301”,”127.0.0.1:9302”,”127.0.0.1:9303”]

注：如果启动后没有从分片，可以在配置文件elasticsearch.yml增加以下配置(3个节点配置文件都要加)

#磁盘的配置
cluster.routing.allocation.disk.threshold_enabled: false

2.node-2配置：

# 统一的集群名
cluster.name: my-ealsticsearch
# 当前节点名
node.name: node-2
# 对外暴露端口使外网访问
network.host: 127.0.0.1
# 对外暴露端口
http.port: 9202
#集群间通讯端口号
transport.tcp.port: 9302
#集群的ip集合，可指定端口，默认为9300
discovery.zen.ping.unicast.hosts: [“127.0.0.1:9301”,”127.0.0.1:9302”,”127.0.0.1:9303”]

3.node-3配置：

# 统一的集群名
cluster.name: my-ealsticsearch
# 当前节点名
node.name: node-3
# 对外暴露端口使外网访问
network.host: 127.0.0.1
# 对外暴露端口
http.port: 9203
#集群间通讯端口号
transport.tcp.port: 9303
#集群的ip集合，可指定端口，默认为9300
discovery.zen.ping.unicast.hosts: [“127.0.0.1:9301”,”127.0.0.1:9302”,”127.0.0.1:9303”]

3.启动elasticSearch-head测试，在安装目录输入命令cdm，再输入npm run start，启动head，在浏览器输入：http://localhost:9100，查看3个节点，主从分片的分配信息(正常的搭配是：同一个节点的主从分片是分开的)

5.ES的javaAPI

5.1需要的jar包

引入maven项目中：

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>transport</artifactId>
    <version>5.2.2</version>
</dependency>
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.7</version>
</dependency>
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.7</version>
</dependency>

5.2 使用ES文档索引增删改查，批量操作，条件查询

public class EsTest {

    //得到一个连接
    public TransportClient GetClient() throws Exception{
        //创建Settings配置对象
        //做嗅的配置
        Settings settings = Settings.builder().put("client.transport.sniff", true).build();

        //创建传输客户端
        //指定集群中的一个节点
        //通过TransportClient来访问时需要使用9300
        TransportClient client = new PreBuiltTransportClient(settings)
                .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("127.0.0.1"),9300));
        System.out.println(client);
        //client.close();
        return client;
    }

    //保存数据
    @Test
    public void testAdd() throws Exception{
        TransportClient client = GetClient();
        //索引库，表名，id
        IndexRequestBuilder builder = client.prepareIndex("test2", "table2", "" + 1);
        Map map = new HashMap();
        map.put("id",1 );
        map.put("name","xxx" );
        IndexResponse response = builder.setSource(map).get();
        client.close();
    }
    //查询数据
    @Test
    public void testQuery() throws Exception{
        TransportClient client = GetClient();
        //索引库，表名，id
        GetResponse response = client.prepareGet("test2", "table2", "1").get();
        System.out.println(response.getSource());
        client.close();
    }
    //修改
    @Test
    public void testUpdate() throws Exception{
        TransportClient client = GetClient();
        IndexRequest indexRequest = new IndexRequest("test2", "table2", "1");
        Map map = new HashMap();
        map.put("id",1 );
        map.put("name", "YYY");
        UpdateRequest upsert = new UpdateRequest("test2", "table2", "1").doc(map).upsert(indexRequest);
        client.update(upsert).get();//发送请求
        client.close();
    }
    //删除
    @Test
    public void testDelete() throws Exception{
        TransportClient client = GetClient();
        DeleteResponse response = client.prepareDelete("test2", "table2", "1").get();
        client.close();
    }
    //批量操作插入数据
    @Test
    public void testBulk() throws Exception{
        TransportClient client = GetClient();
        BulkRequestBuilder BulkRequestBuilder = client.prepareBulk();
        for (int i =1;i<50;i++){
            Map map = new HashMap();
            map.put("id",i );
            map.put("name","dd"+i );
            map.put("age", i+10);
            BulkRequestBuilder.add( );
        }
        BulkResponse response = BulkRequestBuilder.get();
        if (response.hasFailures()){
            System.out.println("出错了");
        }
        client.close();
    }
    //DSL语法
    @Test
    public void testDSLQuery() throws Exception{
        TransportClient client = GetClient();
        SearchRequestBuilder searchRequestBuilder = client.prepareSearch("itsource").setTypes("blog10");
        //获得条件查询对象
        BoolQueryBuilder query = QueryBuilders.boolQuery();
            //添加必须存在的查询条件
        List<QueryBuilder> list = query.must();
        list.add(QueryBuilders.matchAllQuery());
            //添加过滤条件
        query.filter(QueryBuilders.rangeQuery("age").gte(20).lte(50));
        searchRequestBuilder.setQuery(query);
        //排序
        searchRequestBuilder.addSort("age", SortOrder.DESC);
        //分页
        searchRequestBuilder.setFrom(10).setSize(10);
        //截取一些字段
        searchRequestBuilder.setFetchSource(new String[]{"id","name"},null );
        //获取查询响应
        SearchResponse response = searchRequestBuilder.get();

        //从查询响应对象中得到命中的对象
        SearchHits hits = response.getHits();//得到命中的数据
        //从命中对象中获取命中数据的数组
        SearchHit[] hits1 = hits.getHits();
        for (SearchHit hit : hits1) {
            System.out.println(hit.getSource());
        }
        client.close();
    }

}

发表于 2019-12-22 16:24 htq20190427 阅读(565) 评论(0) 编辑收藏举报

全文检索--Lucene & ElasticSearch

全文检索--Lucene

2.1 全文检索和以前高级查询的比较

2.2 Lucene测试

1.引入jar包

1.Lucene介绍

2.Lucene使用场景

3. 全文检索的核心

4. 对Lucene的API认识

1. 索引库-Directory

2.文档-Document，字段-Field

3.字段-Field

4.属性设置方式

5.什么时候使用索引、分词、存储?

5.分词器

1.分词器是什么

2.使用分词器

1.引入依赖

2.测试

6.Lucene中的查询

1.查询方式分类

2.项目里使用全文检索

1.lucene在项目中的使用场景

2 什么时候把数据同步到索引库

3. 项目引入Luence索引库

1.导入依赖

2.集成工具类

3.IDepartmentIndexHelper接口

4.刚才接口的实现类：DepartmentIndexHelper类

5.项目中实现类：DepartmentServiceImpl，中做操作数据库CRUD时，修改索引库

6.测试

4.高亮显示

1.引入依赖

2.创建高亮器

3.使用高亮器对查询结果进行高亮处理

4.高亮放到项目中

2. 全文检索--ElasticSearch(即ES)

2.1 什么是ES

2.1.1 什么是Lucene

2.1.2 类似框架solr

2.13 其实类似框架-Katta和HadoopContrib

2.2 ES的优势

2.3 ES的特点

2.4 ES和其他全文检索框架的比较

2.5 ES安装服务器

2.5.1 集群健康状态

2.5.2 操作ES的客户端工具

2.5.3 Restful认识

2.5.3.1 ES里面的Restful风格

2.5.3.2 使用Restful的好处：

2.5.3.3 ES里面的Restful风格举例

2.6 辅助管理工具Kibana5安装

2.7 head工具的安装

3 ES的操作

3.2 文档的增删改

3.3 代码演示

1.ElasticSearch

1.0 总结ES的语法

1.1 ES文档的简单查询

2.DSL查询与过滤

2.1 DSL

2.1 DSL查询和DSL过滤的区别

3.分词与映射

3.1 IK分词器

3.2 文档映射Mapper

3.2.1 ES字段类型

3.2.2 ES默认映射字段类型

3.2.3 ES自定义映射

3.2.4 ES全局映射

3.2.5 优先级

4.ElasticSearch集群

4.1 为什么需要集群

4.2 elasticsearch集群

4.2.1 ES的节点

4.2.2 集群主从分片分配机制： shard&replica

4.2.3 虚拟集群

5.ES的javaAPI

5.1需要的jar包

5.2 使用ES文档索引增删改查，批量操作，条件查询