Lucene介绍与应用

栏目: 数据库 · 发布时间: 4年前

内容简介:Lucene介绍与应用一、全文检索介绍1.数据结构

Lucene介绍与应用

一、全文检索介绍

1.数据结构

结构化数据:

指具有“固定格式” 或“限定长度”的数据; 

例如:数据库中的数据、元数据……

非结构化数据

指不定长度或无固定格式的数据;

例如:文本、图片、视频、图表……

2.数据的搜索

顺序扫描法

从第一个文件扫描到最后一个文件,把每一个文件内容从开头扫到结尾,直到扫完所有的文件。

全文检索法

将非结构化数据中的一部分信息提取出来,重新组织,建立索引,使其变得有一定结构,然后对此有一定结构的数据进行搜索,从而达到搜索相对较快的目的。

3.全文检索

例如:新华字典。字典的拼音表和部首检字表就相当于字典的索引,我们可以通过查找索引从而找到具体的字解释。如果没有创建索引,就要从字典的首页一页页地去查找。

这种先建立索引,再对索引进行搜索的过程就叫全文检索(Full-text Search) 。

全文检索的核心

创建索引:将从所有的结构化和非结构化数据提取信息,创建索引的过程。

搜索索引:就是得到用户的查询请求,搜索创建的索引,然后返回结果的过程。

4.倒排索引

倒排索引(英文:InvertedIndex),也称为反向索引,是一种索引方法,实现“单词-文档矩阵”的一种具体存储形式,常被用于存储在全文搜索下某个单词与文档的存储位置的映射,通过倒排索引,可以根据单词快速获取包含这个单词的文档列表。

倒排索引的结构主要由两个部分组成:“单词词典”和“倒排表”。

索引方法例子

3个文档内容为:

    1.php是过去最流行的语言。

    2.java是现在最流行的语言。

    3. Python是未来流行的语言。

Lucene介绍与应用

倒排索引的创建

1.使用分词系统将文档切分成单词序列,每个文档就成了由由单词序列构成的数据流;

2.给不同的单词赋予唯一的单词id,记录下对应的单词;

3.同时记录单词出现的文档,形成倒排列表。每个单词都指向了文档(Document)链表。

Lucene介绍与应用

倒排索引的查询

假如说用户需要查询:   “现在流行”

1.将用户输入进行分词,分为”现在”和”流行”;

2.取出包含字符串“现在”的文档链表;

3.取出包含字符串“流行”的文档链表;

4.通过合并链表,找出包含有”现在”或者”流行”的链表。

倒排索引原理

当然倒排索引的结构也不是上面说的那么简单,索引系统还可以记录除此之外的更多信息。词对应的倒排列表不仅记录了文档编号还记录了单词频率信息。词频信息在搜索结果时,是重要的 排序 依据。这里先了解下,后面的评分计算就要用到这个。

索引和搜索流程图

Lucene介绍与应用

二、Lucene入门

• Lucene是一套用于全文检索和搜寻的开源程序库,由Apache软件基金会支持和提供;

• 基于 java 的全文检索 工具 包, Lucene并不是现成的搜索引擎产品,但可以用来制作搜索引擎产品;

• 官网: http://lucene.apache.org/

1.Lucene的总体结构

Lucene介绍与应用

从lucene的总体架构图可以看出:

1.Lucene库提供了创建索引和搜索索引的API。

 2.应用程序需要做的就是收集文档数据,创建索引;通过用户输入查询索引的得到返回结果。

2.Lucene的几个基本概念

Index(索引):类似数据库的表的概念,但它完全没有约束,可以修改和添加里面的文档,文档里的内容可以任意定义。

Document(文档):类似数据库内的行的概念,一个Index内会包含多个Document。

Field(字段):一个Document会由一个或多个Field组成,分词就是对Field 分词。

Term(词语)和Term Dictionary(词典):Lucene中索引和搜索的最小单位,一个Field会由一个或多个Term组成,Term是由Field经过Analyzer(分词)产生。Term Dictionary即Term词典,是根据条件查找Term的基本索引。

Lucene介绍与应用

3.Lucene创建索引过程

Lucene创建索引过程如下:

1.创建一个IndexWriter用来写索引文件,它有几个参数,INDEX_DIR就是索引文件所存放的位置,Analyzer便是用来 对文档进行词法分析和语言处理的。

2.创建一个Document代表我们要索引的文档。将不同的Field加入到文档中。不同类型的信息用不同的Field来表示

3.IndexWriter调用函数addDocument将索引写到索引文件夹中。

4.Lucene搜索过程

搜索过程如下:

1.IndexReader将磁盘上的索引信息读入到内存,INDEX_DIR就是索引文件存放的位置。

2.创建IndexSearcher准备进行搜索。

3.创建Analyer用来对查询语句进行词法分析和语言处理。

4.创建QueryParser用来对查询语句进行语法分析。

5.QueryParser调用parser进行语法分析,形成查询语法树,放到Query中。

6.IndexSearcher调用search对查询语法树Query进行搜索,得到结果TopScoreDocCollector。

三、Lucene入门案例一

1.案例一代码

引入lucene的jar包

public class LuceneTest {

    public static void main(String[] args) throws Exception {
        // 1. 准备中文分词器
        IKAnalyzer analyzer = new IKAnalyzer();
        // 2. 创建索引
        List<String> productNames = new ArrayList<>();
        productNames.add("小天鹅TG100-1420WDXG");
        productNames.add("小天鹅TB80-easy60W 洗漂脱时间自由可调,京东微联智能APP手机控制");
        productNames.add("小天鹅TG90-1411DG 洗涤容量:9kg 脱水容量:9kg 显示屏:LED数码屏显示");
        productNames.add("小天鹅TP75-V602 流线蝶形波轮,超强喷淋漂洗");
        productNames.add("小天鹅TG100V20WDG 大件洗,无旋钮外观,智能WiFi");
        productNames.add("小天鹅TD80-1411DG 洗涤容量:8kg 脱水容量:8kg 显示屏:LED数码屏显示");
        productNames.add("海尔XQB90-BZ828 洗涤容量:9kg 脱水容量:9kg 显示屏:LED数码屏显示");
        productNames.add("海尔G100818HBG 极简智控面板,V6蒸汽烘干,深层洁净");
        productNames.add("海尔G100678HB14SU1 洗涤容量:10kg 脱水容量:10kg 显示屏:LED数码屏显");
        productNames.add("海尔XQB80-KM12688 智能自由洗,超净洗");
        productNames.add("海尔EG8014HB39GU1 手机智能,一键免熨烫,空气净化洗");
        productNames.add("海尔G100818BG 琥珀金机身,深层洁净,轻柔雪纺洗");
        productNames.add("海尔G100728BX12G 安全磁锁,健康下排水");
        productNames.add("西门子XQG80-WD12G4C01W 衣干即停,热风除菌,低噪音");
        productNames.add("西门子XQG80-WD12G4681W 智能烘干,变速节能,无刷电机");
        productNames.add("西门子XQG100-WM14U568LW 洗涤容量:10kg 脱水容量:10kg 显示屏:LED");
        productNames.add("西门子XQG80-WM10N1C80W 除菌、洗涤分离,防过敏程序");
        productNames.add("西门子XQG100-WM14U561HW 洗涤容量:10kg 脱水容量:10kg 显示屏:LED");
        productNames.add("西门子XQG80-WM12L2E88W 洗涤容量:8kg 脱水容量:8kg 显示屏:LED触摸");
        Directory index = createIndex(analyzer, productNames);

        // 3. 查询器
        String keyword = "西门子 LED";
        Query query = new QueryParser("name", analyzer).parse(keyword);
        // 4. 搜索
        IndexReader reader = DirectoryReader.open(index);
        IndexSearcher searcher = new IndexSearcher(reader);
        int numberPerPage = 1000;
        System.out.printf("当前一共有%d条数据%n"+"<br>", productNames.size());
        System.out.printf("查询关键字是:\"%s\"%n"+"<br>", keyword);
        ScoreDoc[] hits = searcher.search(query, numberPerPage).scoreDocs;
        // 5. 显示查询结果
        showSearchResults(searcher, hits, query, analyzer);
        // 6. 关闭查询
        reader.close();
    }

    private static void showSearchResults(IndexSearcher searcher, ScoreDoc[] hits, Query query, IKAnalyzer analyzer)
            throws Exception {
        System.out.println("找到 " + hits.length + " 个命中.  <br>");
        System.out.println("序号\t匹配度得分\t结果  <br>");

        SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter("<span style='color:red'>", "</span>");
        Highlighter highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(query));

        for (int i = 0; i < hits.length; ++i) {
            ScoreDoc scoreDoc= hits[i];
            int docId = scoreDoc.doc;
            Document d = searcher.doc(docId);
            List<IndexableField> fields = d.getFields();
            System.out.print((i + 1));
            System.out.print("\t" + scoreDoc.score);
            for (IndexableField f : fields) {
                TokenStream tokenStream = analyzer.tokenStream(f.name(), new StringReader(d.get(f.name())));
                String fieldContent = highlighter.getBestFragment(tokenStream, d.get(f.name()));                
                System.out.print("\t" + fieldContent);
            }
            System.out.println("<br>");
        }
    }


    private static Directory createIndex(IKAnalyzer analyzer, List<String> products) throws IOException {
        //存在内存中,新建一个词典
        Directory index = new RAMDirectory();
        IndexWriterConfig config = new IndexWriterConfig(analyzer);
        IndexWriter writer = new IndexWriter(index, config);
        for (String name : products) {
            addDoc(writer, name);
        }
        writer.close();
        return index;
    }
    
    /**
     * 添加文档内容
     * @param w
     * @param name
     * @throws IOException
     */
    private static void addDoc(IndexWriter w, String name) throws IOException {
        //创建一个文档
        Document doc = new Document();
        doc.add(new TextField("name", name, Field.Store.YES));
        w.addDocument(doc);
    }
}

2.代码解析

创建索引

private static Directory createIndex(IKAnalyzer analyzer, List<String> products) throws IOException {
    //存在内存中,新建一个词典
    Directory index = new RAMDirectory();
    IndexWriterConfig config = new IndexWriterConfig(analyzer);
    IndexWriter writer = new IndexWriter(index, config);
    for (String name : products) {
        addDoc(writer, name);
    }
    writer.close();
    return index;
}

private static void addDoc(IndexWriter w, String name) throws IOException {
    //创建一个文档
    Document doc = new Document();
    doc.add(new TextField("name", name, Field.Store.YES));
    w.addDocument(doc);
}

上面代码是将List中的内容保存在文档中,使用analyzer分词器分词,创建索引,索引保存在内存中。 IndexWriter 对象用来写索引的。

查询索引

// 3. 查询器
String keyword = "西门子 智能";
Query query = new QueryParser("name", analyzer).parse(keyword);
// 4. 搜索
IndexReader reader = DirectoryReader.open(index);
IndexSearcher searcher = new IndexSearcher(reader);
int numberPerPage = 1000;
System.out.printf("当前一共有%d条数据%n", productNames.size());
System.out.printf("查询关键字是:\"%s\"%n", keyword);
ScoreDoc[] hits = searcher.search(query, numberPerPage).scoreDocs;
// 5. 显示查询结果
showSearchResults(searcher, hits, query, analyzer);
// 6. 关闭查询
reader.close();

上面代码是查询代码,首先对构建查询条件Query对象,读取索引,创建IndexSearcher 查询对象,传入查询条件,得到查询结果,将结果解析出来,返回。

分词器

创建索引和查询都要用到分词器,在Lucene中分词主要依靠Analyzer类解析实现。Analyzer类是一个抽象类,分词的具体规则是由子类实现的,不同的语言规则,要有不同的分词器, Lucene默认的StandardAnalyzer是不支持中文的分词。

代码中用到了IKAnalyzer分词器,IKAnalyzer是第三方实现的分词器,继承自Lucene的Analyzer类,针对中文文本进行处理的分词器。

打分机制

从案例返回结果来看,有一列匹配度得分,得分越高的排在越前面,排在前面的查询结果也越准确。

打分公式:

Lucene介绍与应用

Lucene库也实现了上面的打分算法,查询结果也会根据分数进行排序。

高亮显示

SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter("<span style='color:red'>", "</span>");
Highlighter highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(query));

将查询结果放到html页面,就会发现查询结果里关键字被标记为红色。在 Lucene库的org.apache.lucene.search.highlight包中提供了关于高亮显示检索关键字的方法,可以对返回的结果中出现了的关键字进行标记。

四、Lucene入门案例二

1.案例介绍

1.将14万条商品详细信息到 mysql 数据库;

2.使用Lucene库创建索引;

3.使用Luncene查询索引,并做分页操作,得到返回查询到的数据,并记录查询时长;

4.使用JDBC连接mysql数据库,采用like查询,对商品进行分页操作,返回查询到的数据,记录查询时长;

5.比较mysql的模糊查询与Lucene全文检索查询。

2.案例二代码

引入lucene的jar包,和mysql的驱动包,创建数据库product表,插入数据.

/**
 * 商品bean类
 * @author yizl
 *
 */
public class Product {
    /**
     * 商品id
     */
    private int id;
    /**
     * 商品名称
     */
    private String name;
    /**
     * 商品类型
     */
    private String category;
    /**
     * 商品价格
     */
    private float price;
    /**
     * 商品产地
     */
    private String place;
    /**
     * 商品条形码
     */
    private String code;
    
    ......    
    
}


public class TestLucene {

    private static ProductDao dao = new ProductDao();

    public static void main(String[] args) throws Exception {
        // 1. 准备中文分词器
        IKAnalyzer analyzer = new IKAnalyzer();
        // 2. 索引
        Directory index = createIndex(analyzer);
        // 3. 查询器
        Scanner s = new Scanner(System.in);

        while (true) {
            System.out.print("请输入查询关键字:");
            String keyword = s.nextLine();
            System.out.println("当前关键字是:" + keyword);
            long start = System.currentTimeMillis();
            // 查询名字字段
            Query query = new QueryParser("name", analyzer).parse(keyword);
            // 4. 搜索
            IndexReader reader = DirectoryReader.open(index);
            IndexSearcher searcher = new IndexSearcher(reader);
            ScoreDoc[] hits = pageSearch(query, searcher, 1, 10);
            // 5. 显示查询结果
            showSearchResults(searcher, hits, query, analyzer);
            // 6. 关闭查询
            reader.close();
            System.out.println("使用Lucene查询索引,耗时:" + (System.currentTimeMillis() - start) + "毫秒");

            System.out.println("-----------------------分割线-------------------------------");
            // 7.通过数据库进行模糊查询
            selectProductOfName(keyword);
        }
    }

    /**
     * 通过mysql商品名查询
     */
    private static void selectProductOfName(String str) {
        long start = System.currentTimeMillis();
        ResultBean<List<Product>> resultBean = dao.selectProductOfName(str, 1, 10);
        PageBean pageBean = resultBean.getPageBean();
        List<Product> products = resultBean.getData();
        System.out.println("查询出的总条数\t:" + pageBean.getTotal() + "条");
        System.out.println("当前第" + pageBean.getPageNow() + "页,每页显示" + pageBean.getPageSize() + "条数据");
        System.out.println("序号\t结果");
        for (int i = 0; i < products.size(); i++) {
            Product product = products.get(i);
            System.out.print((i + 1));
            System.out.print("\t" + product.getId());
            System.out.print("\t" + product.getName());
            System.out.print("\t" + product.getPrice());
            System.out.print("\t" + product.getPlace());
            System.out.print("\t" + product.getCode());
            System.out.println("<br>");
        }

        System.out.println("使用mysql查询,耗时:" + (System.currentTimeMillis() - start) + "毫秒");
    }

    /**
     * 显示找到的结果
     * 
     * @param searcher
     * @param hits
     * @param query
     * @param analyzer
     * @throws Exception
     */
    private static void showSearchResults(IndexSearcher searcher, ScoreDoc[] hits, Query query, IKAnalyzer analyzer)
            throws Exception {
        System.out.println("序号\t匹配度得分\t结果");
        for (int i = 0; i < hits.length; ++i) {
            ScoreDoc scoreDoc = hits[i];
            int docId = scoreDoc.doc;
            Document d = searcher.doc(docId);
            List<IndexableField> fields = d.getFields();
            System.out.print((i + 1));
            System.out.print("\t" + scoreDoc.score);
            for (IndexableField f : fields) {
                System.out.print("\t" + d.get(f.name()));
            }
            System.out.println("<br>");
        }
    }

    /**
     * 分页查询
     * 
     * @param query
     * @param searcher
     * @param pageNow
     *            当前第几页
     * @param pageSize
     *            每页显示条数
     * @return
     * @throws IOException
     */
    private static ScoreDoc[] pageSearch(Query query, IndexSearcher searcher, int pageNow, int pageSize)
            throws IOException {
        TopDocs topDocs = searcher.search(query, pageNow * pageSize);
        System.out.println("查询到的总条数\t" + topDocs.totalHits);
        System.out.println("当前第" + pageNow + "页,每页显示" + pageSize + "条数据");
        ScoreDoc[] alllScores = topDocs.scoreDocs;
        List<ScoreDoc> hitScores = new ArrayList<>();

        int start = (pageNow - 1) * pageSize;
        int end = pageSize * pageNow;
        for (int i = start; i < end; i++)
            hitScores.add(alllScores[i]);

        ScoreDoc[] hits = hitScores.toArray(new ScoreDoc[] {});
        return hits;
    }

    /**
     * 创建Index,将数据存入内存中
     * 
     * @param analyzer
     * @return
     * @throws IOException
     */
    private static Directory createIndex(IKAnalyzer analyzer) throws IOException {
        long start = System.currentTimeMillis();
        Directory index = new RAMDirectory();
        IndexWriterConfig config = new IndexWriterConfig(analyzer);
        IndexWriter writer = new IndexWriter(index, config);
        List<Product> products = dao.selectAllProduct();
        int total = products.size();
        int count = 0;
        int per = 0;
        int oldPer = 0;
        for (Product p : products) {
            addDoc(writer, p);
            count++;
            per = count * 100 / total;
            if (per != oldPer) {
                oldPer = per;
                System.out.printf("索引中,总共要添加 %d 条记录,当前添加进度是: %d%% %n", total, per);
            }

        }
        System.out.println("索引创建耗时:" + (System.currentTimeMillis() - start) + "毫秒");
        writer.close();
        return index;
    }

    /**
     * 往lucene中添加字段
     * 
     * @param w
     * @param p
     * @throws IOException
     */
    private static void addDoc(IndexWriter w, Product p) throws IOException {
        Document doc = new Document();
        doc.add(new TextField("id", String.valueOf(p.getId()), Field.Store.YES));
        doc.add(new TextField("name", p.getName(), Field.Store.YES));
        doc.add(new TextField("category", p.getCategory(), Field.Store.YES));
        doc.add(new TextField("price", String.valueOf(p.getPrice()), Field.Store.YES));
        doc.add(new TextField("place", p.getPlace(), Field.Store.YES));
        doc.add(new TextField("code", p.getCode(), Field.Store.YES));
        w.addDocument(doc);
    }
}



public class ProductDao {

    private static String url = "jdbc:mysql://localhost:3306/lucene?useUnicode=true&characterEncoding=utf8";
    private static String user = "root";
    private static String password = "root";
    
    public static Connection getConnection() throws ClassNotFoundException, SQLException {
        Connection conn = null;
        // 通过工具类获取连接对象
        Class.forName("com.mysql.jdbc.Driver");
        conn = DriverManager.getConnection(url, user, password);
        return conn;
    }

    /**
     * 批量增加商品
     * @param pList
     */
    public void insertProduct(List<Product> pList) {
        String insertProductTop="INSERT INTO `product` (`id`, `name`, "
                + "`category`, `price`, `place`, `code`) VALUES ";
        Connection conn = null;
        Statement stmt = null;
        try {
            conn = getConnection();
            // 3.创建Statement对象
            stmt = conn.createStatement();
            int count=0;
            // 4.sql语句
            StringBuffer sb = new StringBuffer();
            for (int i = 0,len=pList.size(); i < len; i++) {
                Product product = pList.get(i);
                sb.append("(" + product.getId() + ",'" + product.getName() 
                + "','" + product.getCategory()+ "'," + product.getPrice()
                + ",'" + product.getPlace() + "','" + product.getCode() + "')");
                if (i==len-1) {
                    sb.append(";");
                    break;
                }else {
                    sb.append(",");
                }
                //数据量太大会导致一次执行不了,一次最多执行20000条
                if(i%20000==0&&i!=0) {
                    sb.deleteCharAt(sb.length()-1);
                    sb.append(";");
                    String sql = insertProductTop+sb;
                    count += stmt.executeUpdate(sql);
                    //将sb清空
                    sb.delete(0, sb.length());
                }
            }
            
            String sql = insertProductTop+sb;
            // 5.执行sql
            count += stmt.executeUpdate(sql);
            System.out.println("影响了" + count + "行");
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            close(conn, stmt);
        }
    }
    
    /**
     * 关闭资源
     * @param conn
     * @param stmt
     */
    private void close(Connection conn, Statement stmt) {
        // 关闭资源
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }
    }

    // 
    public void deleteAllProduct() {
        Connection conn = null;
        Statement stmt = null;
        try {
            conn = getConnection();
            // 3.创建Statement对象
            stmt = conn.createStatement();
            // 4.sql语句
            String sql = "delete from product";
            // 5.执行sql
            int count = stmt.executeUpdate(sql);
            System.out.println("影响了" + count + "行");

        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            // 关闭资源
            close(conn, stmt);
        }
    }

    /**
     * 查询所有商品
     */
    public List<Product> selectAllProduct() {
        List<Product> pList=new ArrayList<>();
        Connection conn = null;
        Statement stmt = null;
        try {
            conn = getConnection();
            // 3.创建Statement对象
            stmt = conn.createStatement();
            // 4.sql语句
            String sql = "select * from product";
            // 5.执行sql
            ResultSet rs = stmt.executeQuery(sql);
            while (rs.next()) {
                Product product=new Product();
                product.setId(rs.getInt("id"));
                product.setName(rs.getString("name"));
                product.setCategory(rs.getString("category"));
                product.setPlace(rs.getString("place"));
                product.setPrice(rs.getFloat("price"));
                product.setCode(rs.getString("code"));
                pList.add(product);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            // 关闭资源
            close(conn, stmt);
        }
        return pList;
    }
    /**
     * 通过商品名模糊匹配商品
     * @param strName
     * @param pageNow
     * @param pageSize
     * @return
     */
    public ResultBean<List<Product>> selectProductOfName(String strName, int pageNow, int pageSize) {
        ResultBean<List<Product>> resultBean=new ResultBean<List<Product>>();
        PageBean pageBean =new PageBean();
        pageBean.setPageNow(pageNow);
        pageBean.setPageSize(pageSize);
        List<Product> pList=new ArrayList<>();
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = getConnection();
            // sql语句
            String sql = "SELECT id,name,category,place,price,code FROM product"
                    + " where name like ? limit "+(pageNow-1)*pageSize+","+pageSize; 
            // 3.创建PreparedStatement对象,sql预编译
            pstmt = conn.prepareStatement(sql);
            // 4.设定参数
            pstmt.setString(1, "%" + strName + "%" );                  
            // 5.执行sql,获取查询的结果集  
            ResultSet rs = pstmt.executeQuery();
            while (rs.next()) {
                Product product=new Product();
                product.setId(rs.getInt("id"));
                product.setName(rs.getString("name"));
                product.setCategory(rs.getString("category"));
                product.setPlace(rs.getString("place"));
                product.setPrice(rs.getFloat("price"));
                product.setCode(rs.getString("code"));
                pList.add(product);
            }
            
            String selectCount = "SELECT count(1) c FROM product"
                    + " where name like ? ";
            pstmt = conn.prepareStatement(selectCount);
            pstmt.setString(1, "%" + strName + "%" ); 
            ResultSet rs1 = pstmt.executeQuery();
            int count=0;
            while (rs1.next()) {
                count = rs1.getInt("c");
            }
            pageBean.setTotal(count);
            resultBean.setPageBean(pageBean);
            resultBean.setData(pList);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            // 关闭资源
            if (pstmt != null) {
                try {
                    pstmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
        }
        return resultBean;
    
    }
}

/**
 * 返回结果bean
 * @author yizl
 *
 * @param <T>
 */
public class ResultBean<T> {
    
    /**
     * 分页信息
     */
    private PageBean pageBean;
    
    /**
     * 状态码
     */
    private Integer code;
    /**
     * 提示信息
     */
    private String msg;
    /**
     * 返回数据
     */
    private T data;
    

/**
 * 分页bean
 * @author yizl
 *
 */
public class PageBean {
    /**
     * 当前页数
     */
    private Integer pageNow;

    /**
     * 每页条数
     */
    private Integer pageSize;
    /**
     * 总数
     */
    private Integer total;

4.Lucene的分页查询

private static ScoreDoc[] pageSearch(Query query, IndexSearcher searcher, int pageNow, int pageSize)
throws IOException {
TopDocs topDocs = searcher.search(query, pageNow * pageSize);
System.out.println("查询到的总条数\t" + topDocs.totalHits);
System.out.println("当前第" + pageNow + "页,每页显示" + pageSize + "条数据");
ScoreDoc[] alllScores = topDocs.scoreDocs;
List<ScoreDoc> hitScores = new ArrayList<>();

int start = (pageNow - 1) * pageSize;
int end = pageSize * pageNow;
for (int i = start; i < end; i++)
hitScores.add(alllScores[i]);
ScoreDoc[] hits = hitScores.toArray(new ScoreDoc[] {});
return hits;
}

先把所有的命中数查询出来,在进行分页,有点是查询快,缺点是内存消耗大。

5.结果比较分析

1.14万条数据,从创建lucene索引耗时:11678毫秒,创建索引还是比较耗时的,但是索引只用创建一次,后面都查询都可以使用;

2.从查询时间来看,使用Lucene查询,基本都在10ms左右,mysql查询耗时在150ms以上,查询速度方面有很大的提升,特别是数据量大的时候更加明显;

3.从查询精准度来说,输入单个的词语可能都能查询到结果,输入组合词语,mysql可以匹配不了,Lucene依然可以查询出来,将匹配度高的结果排在前面,更精准。

6.Lucene索引与mysql数据库对比

<IMG src="file:///C:UsersyizlAppDataRoamingfeiqRichOle3864897237.bmp">

Lucene介绍与应用

五、总结

首先我们了解全文检索方法,全文检索搜索非结构化数据速度快等优点,倒排索引是现在最常用的全文检索方法,索引的核心就是怎么创建索引和查询索引。至于怎么实现创建和查询,Apache软件基金会很贴心的为我们Java程序员提供了Lucene开源库,它为我们提供了创建和查询索引的api,这就是我们学习Lucene的目的。


以上就是本文的全部内容,希望本文的内容对大家的学习或者工作能带来一定的帮助,也希望大家多多支持 码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们

数据科学入门

数据科学入门

[美] Joel Grus / 高蓉、韩波 / 人民邮电出版社 / 2016-3 / 69.00元

数据科学是一个蓬勃发展、前途无限的行业,有人将数据科学家称为“21世纪头号性感职业”。本书从零开始讲解数据科学工作,教授数据科学工作所必需的黑客技能,并带领读者熟悉数据科学的核心知识——数学和统计学。 作者选择了功能强大、简单易学的Python语言环境,亲手搭建工具和实现算法,并精心挑选了注释良好、简洁易读的实现范例。书中涵盖的所有代码和数据都可以在GitHub上下载。 通过阅读本书,......一起来看看 《数据科学入门》 这本书的介绍吧!

图片转BASE64编码
图片转BASE64编码

在线图片转Base64编码工具

随机密码生成器
随机密码生成器

多种字符组合密码

HEX CMYK 转换工具
HEX CMYK 转换工具

HEX CMYK 互转工具