Apache Lucene 示例讲解全文搜索

最新推荐文章于 2024-09-03 07:10:39 发布
最新推荐文章于 2024-09-03 07:10:39 发布
阅读量1.6k 收藏
点赞数 1
分类专栏： # Elasticsearch/Lucene/Solr 文章标签： apache lucene java

文章出处：http://blog.csdn.net/xiaoyao880609/article/details/51011652

Lucene是apache软件基金会4 jakarta项目组的一个子项目，是一个开放源代码的全文检索引擎工具包，但它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎。Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能，或者是以此为基础建立起完整的全文检索引擎。(这里博主只是在系统中实现全文检索的功能)

Lucene是一套用于全文检索和搜寻的开源程式库，由Apache软件基金会支持和提供。Lucene提供了一个简单却强大的应用程式接口，能够做全文索引和搜寻。在Java开发环境里Lucene是一个成熟的免费开源工具。就其本身而言，Lucene是当前以及最近几年最受欢迎的免费Java信息检索程序库。人们经常提到信息检索程序库，虽然与搜索引擎有关，但不应该将信息检索程序库与搜索引擎相混淆。

（参考图）
首先需要导入lucene相关包 maven如下(博主用的是当初最新版本，因为新版本对索引库进行了优化，可以相对来讲减少磁盘的开销。) 
    <span style="white-space:pre">    </span>   <!-- Lucene -->  
    <span style="white-space:pre">    </span>   <dependency>  
                <groupId>org.apache.lucene</groupId>  
                <artifactId>lucene-core</artifactId>  
                <version>4.9.0</version>  
            </dependency>  
            <dependency>  
                <groupId>org.apache.lucene</groupId>  
                <artifactId>lucene-queryparser</artifactId>  
                <version>4.9.0</version>  
            </dependency>  
            <dependency>  
                <groupId>org.apache.lucene</groupId>  
                <artifactId>lucene-highlighter</artifactId>  
                <version>4.9.0</version>  
            </dependency>  
            <dependency>  
                <groupId>org.apache.lucene</groupId>  
                <artifactId>lucene-analyzers-common</artifactId>  
                <version>4.9.0</version>  
            </dependency>  
            <dependency>  
                <groupId>org.apache.lucene</groupId>  
                <artifactId>lucene-queryparser</artifactId>  
                <version>4.9.0</version>  
            </dependency>


首先需要指定lucene的索引库路径(推荐将Lucene索引库路径配置在配置文件中) 
# lucene index path  
batch.lucene.index.path=/home1/irteam/owfs/lucene_index

创建索引时候需要将数据库中取出的javabean对象转换为lucene的document对象，因此我做了工具类将基本的lucene相关方法封装好服用。
在这里就把关键代码贴出来提供参考 
    @Service  
    public class IndexUtil {  
      
        @Value("${batch.lucene.index.path}")  
        private String indexPath;  

    <span style="white-space:pre">    </span>//将java对象转换为lucene元素  

    public Document toDocument(IndexMstr index, Document oldDoc) {  
        Document doc = new Document();  
        if (StringUtils.isNotBlank(index.getTaskId())) {//对应字符串类型(常用)  
            doc.add(new StringField("taskId", index.getTaskId(), Store.YES));  
        } else if (StringUtils.isNotBlank(oldDoc.get("taskId"))) {  
            doc.add(new StringField("taskId", oldDoc.get("taskId"), Store.YES));  
        }  
        if (StringUtils.isNotBlank(index.getSummary())) {//对应text类型  
            doc.add(new TextField("summary", index.getSummary(), Store.YES));  
        } else if (StringUtils.isNotBlank(oldDoc.get("summary"))) {  
            doc.add(new TextField("summary", oldDoc.get("summary"), Store.YES));  
        }  
        if (index.getRegistDate() != null) {//对应date类型，由于lucene不支持date所以我保存了时间戳，显示时候需要转换  
            doc.add(new LongField("registDate", index.getRegistDate().getTime(), Store.YES));  
        } else if (StringUtils.isNotBlank(oldDoc.get("registDate"))) {  
            doc.add(new LongField("registDate", new Long(oldDoc.get("registDate")), Store.YES));  
        }  
        if (StringUtils.isNotBlank(index.getSyncIndexType())) {//由于lucene不支持一对多等关系，但是项目需要多表中对应字段作为检索条件，所以我将对应多数据用空格分隔保存(注：由于该字段只需要作为检索条件所以为了省事这样处理，如需要检索可以将LIST转为json存储)  
            if (StringUtils.isNotBlank(index.getAnalysisNmArr())) {  
                doc.add(new StringField("analysisNmArr", index.getAnalysisNmArr(), Store.YES));  
            }  
            if (StringUtils.isNotBlank(index.getAnalysisConArr())) {  
                doc.add(new StringField("analysisConArr", index.getAnalysisConArr(), Store.YES));  
            }  
        } else {  
            List<AnalysisIndexMstr> analysisIndexList = index.getAnalysisIndexList();  
            if (CollectionUtils.isNotEmpty(analysisIndexList)) {//심화분석 analysisNmArr,analysisConArr  
                StringBuffer analysisNmSB = new StringBuffer();  
                StringBuffer analysisConSB = new StringBuffer();  
                for (AnalysisIndexMstr analysisIndex : analysisIndexList) {  
                    if (analysisIndex != null) {  
                        if (StringUtils.isNotBlank(analysisIndex.getAnalysisNm())) {  
                            analysisNmSB.append(SOCUtil.html2Text(analysisIndex.getAnalysisNm().trim()) + " ");  
                        }  
                        if (StringUtils.isNotBlank(analysisIndex.getAnalysisCon())) {  
                            analysisConSB.append(SOCUtil.html2Text(analysisIndex.getAnalysisCon()) + " ");  
                        }  
                    }  
                }  
                if (StringUtils.isNotBlank(analysisNmSB.toString())) {  
                    doc.add(new StringField("analysisNmArr", SOCUtil.html2Text(analysisNmSB.toString().trim()), Store.YES));  
                }  
                if (StringUtils.isNotBlank(analysisConSB.toString())) {  
                    doc.add(new TextField("analysisConArr", SOCUtil.html2Text(analysisConSB.toString().trim()), Store.YES));  
                }  
            }  
        }  
        return doc;  
    }  

    //批量将java对象转换为lucene元素  
        public List<Document> toDocuments(List<IndexMstr> indexMstrList) {  
            List<Document> docList = new ArrayList<Document>();  
            for (IndexMstr index : indexMstrList) {  
                docList.add(toDocument(index, new Document()));  
            }  
            return docList;  
        }  

    //lucene分页查询，并且批量将lucene元素转换为java对象  
        public List<IndexMstr> toObjectByPage(IndexSearcher indexSearcher, TopFieldDocs topDocs, PagerInfo pagerInfo, IndexParam indexParam) throws IOException {  
            if (StringUtils.isEmpty(indexParam.getPage())) {  
                indexParam.setPage(SocConstant.PAGE_ONE);  
            }  
            if (StringUtils.isEmpty(indexParam.getPageSize())) {  
                indexParam.setPageSize(String.valueOf(SocConstant.PAGE_SIZE));  
            }  
            SimpleDateFormat sdf = new SimpleDateFormat(DateUtil.DATE_FULL_PATTERN_DB_KOREAN);  
            List<IndexMstr> indexMstrList = new ArrayList<IndexMstr>();  
            ScoreDoc[] scoreDocs = topDocs.scoreDocs;  
            pagerInfo.setPage(Integer.parseInt(indexParam.getPage()));  
            pagerInfo.init(SocConstant.PAGE_AJAX_DEFAULT_TYPE, scoreDocs.length,  
                Integer.parseInt(indexParam.getPageSize()),  
                SocConstant.INDEX_SIZE);  
            indexParam.setStart(pagerInfo.getStartRownum() - 1);  
            indexParam.setEnd(pagerInfo.getEndRownum());  
            for(int i = indexParam.getStart(); i < indexParam.getEnd(); i++) {  
                int docId = scoreDocs[i].doc;  
                Document doc = indexSearcher.doc(docId);  
                IndexMstr indexMstr = new IndexMstr();  
                indexMstr.setTaskId(doc.get("taskId"));  
                indexMstr.setTicketId(doc.get("ticketId"));  
                //use highlighter for ticketNm  
                String ticketNm = StringUtils.isBlank(indexParam.getSearch()) ? doc.get("ticketNm") : toHighlighter(indexParam.getSearch(), doc.get("ticketNm"));  
                indexMstr.setTicketNm(ticketNm);  
                //use highlighter for taskNm  
                String taskNm = StringUtils.isBlank(indexParam.getSearch()) ? doc.get("taskNm") : toHighlighter(indexParam.getSearch(), doc.get("taskNm"));  
                indexMstr.setTaskNm(taskNm);  
                indexMstr.setEmpNm(doc.get("empNm"));  
                indexMstr.setCorpNm(doc.get("corpNm"));  
                indexMstr.setTaskIndexType(TaskIndexType.instanceOf(doc.get("taskTypeId")));  
                if (StringUtils.isNotBlank(doc.get("registDate"))) {  
                    indexMstr.setRegistDateStr(sdf.format(new Date(Long.parseLong(doc.get("registDate")))));  
                }  
                indexMstrList.add(indexMstr);  
            }  
            return indexMstrList;  
        }  
    <span style="white-space:pre">    </span>//实现高亮(由于lucene高亮是作用于分词后的结果，项目中需要将整体匹配高亮所以自己实现了，如果有兴趣看源码你会发现，源码也是类似这样实现的)  
        private String toHighlighter(String search, String fieldValue) {  
            if (StringUtils.isBlank(fieldValue)) {  
                return fieldValue;  
            }  
            return fieldValue.replaceAll("(?i)" + search, "<font color='#FF0000'>" + search + "</font>");  
        }  
      
    }


参考图中init sync batch实现如下：

  1. 将积存的数据批量创建索引,由于是积存的数据，所以为了防止查询DB超时这里分批次创建索引。  
  1. （如果创建多个<span style="font-family: Arial, Helvetica, sans-serif;">indexWriter实例同时对索引库操作会报错，最好将IndexWriter交于spring管理</span><span style="font-family: Arial, Helvetica, sans-serif;">）</span>  
    @Override  
    public void execute(ExtendedMap jobDataMap) {  
        log.info("[IndexRsyncJob] create lucene index job start........");  
        File indexFile = new File(indexPath);  
        initIndexFile(indexFile);  
        CJKAnalyzer analyzer = new CJKAnalyzer(Version.LUCENE_4_9);  
        IndexWriterConfig conf = new IndexWriterConfig(Version.LUCENE_4_9, analyzer);  
        try {  
            FSDirectory directory = FSDirectory.open(indexFile);  
            IndexWriter indexWriter = new IndexWriter(directory, conf);  
            System.err.println("create lucene index start...................." + DateUtil.getFullDate());  
            taskIndexBO.createTaskIndex(TaskIndexType.TASK_INTRUSION.getCode(), 200, indexFile, indexWriter);//create intrusion task lucene index  
            taskIndexBO.createTaskIndex(TaskIndexType.TASK_INCIDENT.getCode(), 200, indexFile, indexWriter);//create incident task lucene index  
            taskIndexBO.createTaskIndex(TaskIndexType.TASK_REQUEST.getCode(), 200, indexFile, indexWriter);//create request task lucene index  
            System.err.println("create lucene index end...................." + DateUtil.getFullDate());  
        } catch (IOException e) {  
            log.error("[IndexRsyncJob] create lucene index error:" + e.getMessage());  
        } finally {  
            try {  
                indexWriter.close();  
            } catch (IOException e) {  
                log.error("[IndexRsyncJob] close lucene IndexWriter error:" + e.getMessage());  
            }  
        }  
    }  
   public void createTaskIndex(String taskTypeId, int synCnt, File indexFile, IndexWriter indexWriter) {  
        int num = 0;  
        try{  
            IndexParam indexParam = new IndexParam();  
            indexParam.setTaskTypeId(taskTypeId);  
            int taskTotal = taskIndexDAO.selectTaskCnt(indexParam);  
            for (int i = num; i < taskTotal; i += synCnt) {  
                num = i;  
                indexParam.setStart(i);  
                indexParam.setEnd(synCnt);  
                List<IndexMstr> taskIndexList = taskIndexDAO.selectTaskList(indexParam);  
                List<Document> docList = new IndexUtil().toDocuments(taskIndexList);  
                indexWriter.addDocuments(docList);  
                indexWriter.commit();  
                log.info("[task(total:" + taskTotal + ")] create end by count >>>>>>>>> " + i);  
            }  
        } catch (Exception e) {  
            log.error("[TaskIndexBO] create lucene index error:" + e.getMessage());  
            createTaskIndex(taskTypeId, synCnt, indexFile, indexWriter);  
        }  
    }


参考图中incremental sync batch实现如下：

索引表中的数据是系统每次对关联表操作时候将变动的数据存储临时索引表中，再通过10分钟一次的batch实现增量同步的。

    public void execute(ExtendedMap jobDataMap) {  
        log.info("[IndexRsyncDBJob] create lucene index job start........");  
        File indexFile = new File(indexPath);  
        indexBO.createIndex(indexFile);  
        log.info("[IndexRsyncDBJob] create lucene index job end........");  
    }  
    public void createIndex(File indexFile) {  
        List<Integer> indexIdList = new ArrayList<Integer>();  
        List<IndexMstr> indexList = indexDAO.selectIndexList();  
        CJKAnalyzer analyzer = new CJKAnalyzer(Version.LUCENE_4_9);  
        IndexWriterConfig conf = new IndexWriterConfig(Version.LUCENE_4_9, analyzer);  
        try {  
            FSDirectory directory = FSDirectory.open(indexFile);  
            indexWriter = new IndexWriter(directory, conf);  
            for (IndexMstr indexMstr : indexList) {  
                try {  
                    indexReader = DirectoryReader.open(directory);  
                    IndexSearcher indexSearcher = new IndexSearcher(indexReader);  
                    if ("A".equalsIgnoreCase(indexMstr.getSyncIndexType())) {  
                        TopDocs topDocs = indexSearcher.search(new TermQuery(new Term("taskId", indexMstr.getTaskId())), Integer.MAX_VALUE);  
                        if (topDocs.totalHits == 0) {  
                            Document doc = indexUtil.toDocument(indexMstr, new Document());  
                            indexWriter.addDocument(doc);  
                        }  
                    } else if ("D".equalsIgnoreCase(indexMstr.getSyncIndexType())) {  
                        indexWriter.deleteDocuments(new Term("taskId", indexMstr.getTaskId()));  
                    } else if ("U".equalsIgnoreCase(indexMstr.getSyncIndexType())) {  
                        TopDocs topDocs = indexSearcher.search(new TermQuery(new Term("taskId", indexMstr.getTaskId())), Integer.MAX_VALUE);  
                        if (topDocs.totalHits > 0) {  
                            Document oldDoc = indexSearcher.doc(topDocs.scoreDocs[0].doc);  
                            Document doc = indexUtil.toDocument(indexMstr, oldDoc);  
                            indexWriter.updateDocument(new Term("taskId", indexMstr.getTaskId()), doc);  
                        }  
                    }  
                    indexWriter.commit();  
                    indexIdList.add(indexMstr.getIndexId());  
                } catch (IOException e) {  
                    log.error("[IndexBO] before create lucene index for db error:" + e.getMessage());  
                } finally {  
                    try {  
                        indexReader.close();  
                    } catch (IOException e) {  
                        log.error("[IndexBO] close IndexReader error : " + e.getMessage());  
                    }  
                }  
            }  
        } catch (Exception e) {  
            log.error("[IndexBO] after create lucene index for db error:" + e.getMessage());  
        } finally {  
            try {  
                indexWriter.close();  
            } catch (IOException e) {  
                log.error("[IndexBO] close IndexWriter error : " + e.getMessage());  
            }  
        }  
        if (CollectionUtils.isNotEmpty(indexIdList)) {  
            indexDAO.deleteIndexs(indexIdList);  
        }  
    }


到这里就把最麻烦的创建索引和数据库和索引库同步部分做完了。

下面说一下查询部分。查询时可以定义多个query对象用Occur逻辑实现复杂查询。

而且lucene也支持使用通配符做查询条件。

Occur.SHOULD，或的意思
Occur.MUST_NOT，非的意思

Occur.MUST， 与的意

    private void doSearch(Model model, PagerInfo pagerInfo,IndexParam indexParam, boolean isInit) {  
        File indexFile = new File(indexPath);     
        try {  
            dir = FSDirectory.open(indexFile);  
            reader= DirectoryReader.open(dir);  
            BooleanQuery query = new BooleanQuery();  
            BooleanQuery searchQuery = new BooleanQuery();  
            searchQuery.add(new WildcardQuery(new Term("ticketNm", "*" + indexParam.getSearch() + "*")), Occur.SHOULD);  
            searchQuery.add(new WildcardQuery(new Term("taskNm", "*" + indexParam.getSearch() + "*")), Occur.SHOULD);  
            searchQuery.add(new WildcardQuery(new Term("summary", "*" + indexParam.getSearch() + "*")), Occur.SHOULD);  
            searchQuery.add(new WildcardQuery(new Term("detectionLog", "*" + indexParam.getSearch() + "*")), Occur.SHOULD);  
            searchQuery.add(new WildcardQuery(new Term("analysisNmArr", "*" + indexParam.getSearch() + "*")), Occur.SHOULD);  
            searchQuery.add(new WildcardQuery(new Term("analysisConArr", "*" + indexParam.getSearch() + "*")), Occur.SHOULD);  
            query.add(searchQuery, Occur.MUST);  
            if(StringUtils.isNotEmpty(indexParam.getTaskTypeIds())) {  
                BooleanQuery taskTypeQuery = new BooleanQuery();  
                String[] taskTypeIdArr = indexParam.getTaskTypeIds().split(",");  
                for (int i = 0; i < taskTypeIdArr.length; i++) {  
                    taskTypeQuery.add(new TermQuery(new Term("taskTypeId", taskTypeIdArr[i])), Occur.SHOULD);  
                }  
                query.add(taskTypeQuery, Occur.MUST);  
            }  
            if(StringUtils.isNotEmpty(indexParam.getCorpId())) {  
                query.add(new WildcardQuery(new Term("corpId", indexParam.getCorpId())), Occur.MUST);  
            }  
            if(StringUtils.isNotEmpty(indexParam.getEmpNm())) {  
                query.add(new WildcardQuery(new Term("empNm", "*" + indexParam.getEmpNm() + "*")), Occur.MUST);  
            }  
            if(StringUtils.isNotEmpty(indexParam.getStartDt()) || StringUtils.isNotEmpty(indexParam.getEndDt())) {  
                Long startDtLong = StringUtils.isNotEmpty(indexParam.getStartDt()) ? DateUtil.stringTODate(indexParam.getStartDt(), DateUtil.DATE_FULL_PATTERN_DB_KOREAN).getTime() : null;  
                Long endDtLong = StringUtils.isNotEmpty(indexParam.getEndDt()) ? DateUtil.stringTODate(indexParam.getEndDt(), DateUtil.DATE_FULL_PATTERN_DB_KOREAN).getTime() : null;  
                  
                query.add(NumericRangeQuery.newLongRange("registDate", startDtLong, endDtLong, true, true) , Occur.MUST);  
            }  
            IndexSearcher indexSearcher = new IndexSearcher(reader);  
            TopFieldDocs topDocs = indexSearcher.search(query, 100, new Sort(new SortField("registDate", SortField.Type.LONG, true)));  
            List<IndexMstr> indexList = new IndexUtil().toObjectByPage(indexSearcher, topDocs, pagerInfo, indexParam);  
            model.addAttribute("indexList", indexList);  
            model.addAttribute("indexParam", indexParam);  
            if(isInit) {  
                model.addAttribute("page", pagerInfo.getPage());  
                initTaskCount(indexSearcher, model);  
            }  
        } catch (IOException e) {  
            log.error("[PublicSearchController] doSearch error : " + e.getMessage());  
        } finally {  
            try {  
                if(reader != null) {  
                    reader.close();  
                }  
            } catch (IOException e) {  
                log.error("[PublicSearchController] close IndexReader for doSearch error : " + e.getMessage());  
            }  
        }  
    }  
  
    private void initTaskCount(IndexSearcher indexSearcher, Model model) throws IOException {  
        TermQuery query_I = new TermQuery(new Term("taskTypeId", TaskIndexType.TASK_INTRUSION.getCode()));  
        TermQuery query_D = new TermQuery(new Term("taskTypeId", TaskIndexType.TASK_DDos.getCode()));  
        TermQuery query_A = new TermQuery(new Term("taskTypeId", TaskIndexType.TASK_INCIDENT.getCode()));  
        TermQuery query_T = new TermQuery(new Term("taskTypeId", TaskIndexType.TASK_REQUEST.getCode()));  
        TermQuery query_P = new TermQuery(new Term("taskTypeId", TaskIndexType.POLICY_DEVELOP.getCode()));  
        TermQuery query_R = new TermQuery(new Term("taskTypeId", TaskIndexType.POLICY_VENDOR.getCode()));  
        TermQuery query_M = new TermQuery(new Term("taskTypeId", TaskIndexType.POLICY_ESM.getCode()));  
        TermQuery query_N = new TermQuery(new Term("taskTypeId", TaskIndexType.POLICY_EXCEPTION.getCode()));  
        int total_I = indexSearcher.search(query_I, Integer.MAX_VALUE).totalHits;  
        model.addAttribute("total_I", total_I);  
        int total_A = indexSearcher.search(query_A, Integer.MAX_VALUE).totalHits;  
        model.addAttribute("total_A", total_A);  
        int total_T = indexSearcher.search(query_T, Integer.MAX_VALUE).totalHits;  
        model.addAttribute("total_T", total_T);  
        int total_D = indexSearcher.search(query_D, Integer.MAX_VALUE).totalHits;  
        model.addAttribute("total_D", total_D);  
        int total_P = indexSearcher.search(query_P, Integer.MAX_VALUE).totalHits;  
        model.addAttribute("total_P", total_P);  
        int total_R = indexSearcher.search(query_R, Integer.MAX_VALUE).totalHits;  
        model.addAttribute("total_R", total_R);  
        int total_M = indexSearcher.search(query_M, Integer.MAX_VALUE).totalHits;  
        model.addAttribute("total_M", total_M);  
        int total_N = indexSearcher.search(query_N, Integer.MAX_VALUE).totalHits;  
        model.addAttribute("total_N", total_N);  
    }


由于博主应用系统中数据量不是很大所以直接对磁盘进行检索。如果数据量大的话可以通过RAMDirectory缓存来优化创建索引，和查询功能。

博主经测试几百万级以下的数据量可以直接对磁盘进行检索，相反如果数据量不大时候用缓存反而起反效果。
如有不了解地方,或不对的地方，欢迎提出，互相探讨~

boonya
关注
专栏目录
Apache Lucene 详解及示例
微笑听雨
07-15 698
Apache Lucene 是一个功能强大的搜索引擎库，通过灵活的配置和优化，可以处理各种复杂的搜索需求。以上示例展示了如何创建、查询、更新和删除索引，以及如何优化 Lucene 的性能。
Apache Lucene3.0 入门实例介绍
07-31
Apache Lucene是一个高性能、全文本搜索库，由Java编写，被广泛应用于各种搜索引擎的开发中。这个入门实例将引导我们了解如何使用Lucene 3.0版本进行基本的索引和搜索操作。以下是对Lucene 3.0关键知识点的详细讲解...
apache lucence文档
03-05
（文档部分）Lucene是apache软件基金会4 jakarta项目组的一个子项目，是一个开放源代码的全文检索引擎工具包，即它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎（英文与德文两种西方语言）。Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能，或者是以此为基础建立起完整的全文检索引擎。
Apache Lucene 实战
有刁民想害朕的博客
03-30 2974
博主在工作中项目需要lucene做全文搜索功能，所以博主看了一遍lucene in action(分词器实现部分没有看，因为大多数情况下不需要自己实现分词器，而且有很多开源分词器)运用到了lucene，而且已上线，在这里将使用心得分享给大家，供有需要的小伙伴参考~ 首先 简单描述一下lucene是什么。 Lucene是apache软件基金会4 jakarta项目组的一个子项目，是一个开放源代码...
Apache Lucene 项目教程
最新发布
gitblog_00711的博客
09-03 327
Apache Lucene 项目教程 luceneApache Lucene: 是一个开源的信息检索库，主要用于全文搜索和索引。适合Java开发者、搜索引擎开发者和需要构建高效信息检索系统的开发者。特点包括强大的索引和搜索功能、高度可扩展和可定制、支持多种查询解析器和评分模型以及丰富的文档和社区支持。项目地址:https://gitcode.com/gh_mirrors/lu/lucene 1....
Lucene使用指南
Angelo Lee's Blog
10-17 564
Lucene简介 Lucene是一个基于Java的、高性能的全文检索工具包，它目前是著名的 Apache Jakarta 家族中的一个开源项目，也是目前最为流行的基于 Java 开源全文检索工具包。但它不是一个完整的搜索应用程序，而是为应用程序提供索引和搜索功能。   Lucene 是为文本类型的数据建立索引的，所以只要能把需要索引的数据格式转化的文本的，Lucene 就能对文档进行索引和搜
使用 Apache Lucene 搜索文本
沈颖的家
10-08 763
本文将探讨 Apache Lucene —— 性能卓越、功能全面的文本搜索引擎库。我们将学习 Lucene 架构及其核心 API。学习如何使用 Lucene 进行跨平台全文本搜索、建立索引、显示结果，以及如何扩展搜索。简介Lucene是一个开源、高度可扩展的搜索引擎库，可以从 Apache Software Foundation 获取。您可以将 Lucene
精通Lucene全文检索技术：代码示例与实战答疑
资源摘要信息:"Lucene全文检索从入门到精通（精细讲解含代码笔记答疑服务）课程详细介绍了Lucene这一开源的全文检索引擎工具包。课程内容覆盖了从Lucene的基础概念、安装配置，到深入学习其提供的索引引擎、查询引擎...
Apache Lucene权威指南：Java搜索引擎实战教程
Apache Lucene是一款强大的全文搜索引擎库，它在Java编程语言中被广泛使用，尤其适合于构建高效、可扩展的搜索功能。本教程旨在提供对Lucene核心原理和实践操作的深入指南，帮助读者掌握这一开源项目的最新技术和...
Apache Lucene入门：原理与实战指南
Lucene起源于2001年，由一位资深的全文索引/检索专家创建，最初发布在其个人主页，后来被Apache基金会采纳，成为了Jakarta项目的子项目。如今，Lucene已成为业界广泛使用的全文检索解决方案，其核心理念是通过索引...
Apache Lucene 3.0 深入解析：第二版
Apache Lucene是一个高性能、可扩展的信息检索库，被广泛用于构建全文搜索功能。本书深入浅出地介绍了Lucene的相关知识，包括其API的详细使用方法，通过丰富的代码示例和清晰的解释，帮助读者理解如何利用Lucene进行...
lucene org.apache
08-26
org.apache.lucene.analysis.cjk.CJKAnalyzer .......
lucene介绍
AgileLoveNanaForever的专栏
12-15 168
什么是lucene Apache Lucene是一个开放源程序的搜寻器引擎，利用它可以轻易地为Java软件加入全文搜寻功能。Lucene的最主要工作是替文件的每一个字作索引，索引让搜寻的效率比传统的逐字比较大大提高，Lucen提供一组解读，过滤，分析文件，编排和使用索引的API，它的强大之处除了高效和简单外，是最重要的是使使用者可以随时应自已需要自订其功能。 Lucene是apache软件基金会...
Apache Lucene基础教程
最佳 Java 编程
05-30 386
课程大纲 Apache Lucene是一个免费/开源信息检索软件库，它提供基于Java的索引和搜索技术，以及拼写检查，命中突出显示和高级分析/令牌化功能。 Lucene是完全用Java编写的高性能，功能齐全的文本搜索引擎库。 它是一项适用于几乎所有需要全文搜索的应用程序的技术，尤其是跨平台的应用程序。 在本课程中，您将了解Lucene。 您将了解为什么这样的库很重要，然后了解Luce...
apache lucene_使用Apache Lucene搜索文本
cusi77914的博客
07-01 335
Lucene是可从Apache Software Foundation获得的开源，高度可扩展的文本搜索引擎库。 您可以在商业和开源应用程序中使用Lucene。 Lucene强大的API主要集中在文本索引和搜索上。 它可用于为诸如电子邮件客户端，邮件列表，Web搜索，数据库搜索等应用程序构建搜索功能。Wikipedia，TheServerSide，jGuru和LinkedIn等网站已由Lucen...
Apache Lucene 简介
lzx1104的专栏
08-14 851
Apache Lucene (TM) 项目开发开源搜索软件，包括： . Lucene Core, 旗舰子项目，提供基于Java的索引和搜索技术，以及拼写检查(spellchecking)，命中高亮(hit highlighting)和高级分析/分词(analysis/tokenization)功能等。 . Solr (TM) 是一个基于Lucene Core构建的高性能搜索服务器，
Apache Lucene介绍与使用
z_ssyy的博客
03-31 5731
Lucene介绍 lucene官方使用手册：https://lucene.apache.org/core/8_5_0/index.html 1. Lucene简介 　　最受欢迎的java开源全文搜索引擎开发工具包。提供了完整的查询引擎和索引引擎，部分文本分词引擎（英文与德文两种西方语言）。Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便在目标系统中实现全文检索功能，或者是...
Lucene系列之全局搜索引擎入门教程
热门推荐
Nicky's blog
04-19 1万+
Lucene简介 Lucent：Apache软件基金会Jakarta项目组的一个子项目，Lucene提供了一个简单却强大的应用程式接口，能够做全文索引和搜寻。在Java开发环境里Lucene是一个成熟的免费开源工具。就其本身而言，Lucene是当前以及最近几年最受欢迎的免费Java信息检索程序库。 —— [ 百度百科 ] 数据库索引和Lucene检索对比 比较项 Lu...
Lucene的全文搜索及高亮显示
天真吖的博客
07-05 735
【代码】Lucene的全文搜索及高亮显示。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值