lucene全文检索学习记录，附带源码——三种实现，超全超细致

最新推荐文章于 2024-07-04 14:41:08 发布
最新推荐文章于 2024-07-04 14:41:08 发布
阅读量88 收藏
点赞数
原文链接：https://my.oschina.net/u/1433614/blog/189885
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

Lucene学习记录

———三种实现，超全超细致

下载lucene3.6.0.zip http://download.csdn.net/detail/leilovegege/6800405 ，解压，将里边的lucene-core-3.6.0.jar等包拷贝到工程lib中。还需要中文分词器IKAnalyzer3.2.8.jar，ojdbc14.jar

至此环境搭配完成。

 

下面开始实现，只用lava类，没连接web页面，所以在测试时执行java文件，在控制台进行测试。

工程原文件lucene36 http://download.csdn.net/detail/leilovegege/6804669

Test1检索绝对路径上的文件

package test1;  

 

import java.io.BufferedReader;  

import java.io.File;  

import java.io.FileInputStream;  

import java.io.FileReader;  

import java.io.IOException;  

import java.io.InputStreamReader;  

import java.util.Date;  

 

import org.apache.lucene.analysis.Analyzer;  

import org.apache.lucene.analysis.standard.StandardAnalyzer;  

import org.apache.lucene.document.Document;  

import org.apache.lucene.document.Field;  

import org.apache.lucene.document.FieldSelectorResult;  

import org.apache.lucene.document.NumericField;  

import org.apache.lucene.index.IndexWriter;  

import org.apache.lucene.index.IndexWriterConfig;  

import org.apache.lucene.index.IndexWriterConfig.OpenMode;  

import org.apache.lucene.store.Directory;  

import org.apache.lucene.store.FSDirectory;  

import org.apache.lucene.util.Version;  

 

public class TestFileIndexer {  

    public   static   void  main(String[] args)  throws  Exception  {             

        /*  指明要索引文件夹的位置,这里是C盘的source文件夹下  */          

        File fileDir  =   new  File( "E:\\Documents and Settings\\Administrator\\Workspaces\\MyEclipse 8.6\\lucene36\\source" );    

        /*  这里放索引文件的位置  */         

        File indexDir  =   new  File( ".\\index\\test1" );            

        Directory dir=FSDirectory.open(indexDir);//将索引存放在磁盘上  

        Analyzer lucenAnalyzer=new StandardAnalyzer(Version.LUCENE_36);//分析器  

        IndexWriterConfig iwc=new IndexWriterConfig(Version.LUCENE_36,lucenAnalyzer);  

        iwc.setOpenMode(OpenMode.CREATE);//创建新的索引文件create 表示创建或追加到已有索引库  

        IndexWriter indexWriter=new IndexWriter(dir,iwc);//把文档写入到索引库  

        File[] textFiles=fileDir.listFiles();//得到索引文件夹下所有文件  

        long startTime=new Date().getTime();  

        //增加document到检索去  

        for (int i = 0; i < textFiles.length; i++) {  

//          if (textFiles[i].isFile()&& textFiles[i].getName().endsWith(".txt")) {  

                System.out.println(":;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;");  

                System.out.println("File"+textFiles[i].getCanonicalPath()+"正在被索引...");  

                String temp=FileReaderAll(textFiles[i].getCanonicalPath(),"GBK");  

                System.out.println(temp);  

                Document document=new Document();  

                Field FieldPath=new Field("path",textFiles[i].getPath(),Field.Store.YES,Field.Index.NO);  

                Field FieldBody=new Field("body",temp,Field.Store.YES,Field.Index.ANALYZED,Field.TermVector.WITH_POSITIONS_OFFSETS);  

                NumericField modifiField=new NumericField("modified");//所以key为modified  

                modifiField.setLongValue(fileDir.lastModified());  

                document.add(FieldPath);  

                document.add(FieldBody);  

                document.add(modifiField);  

                indexWriter.addDocument(document);  

                  

//          }  

        }  

        indexWriter.close();  

        //计算一下索引的时间  

        long endTime=new Date().getTime();  

        System.out.println("花了"+(endTime-startTime)+"毫秒把文档添加到索引里面去"+fileDir.getPath());  

    }  

    public static String FileReaderAll(String FileName,String charset)throws IOException{  

        BufferedReader reader=new BufferedReader(new InputStreamReader(new FileInputStream(FileName),charset));  

        String line=new String();   

        String temp=new String();  

        while ((line=reader.readLine())!=null) {  

            temp+=line;  

        }  

        reader.close();  

        return temp;  

    }     

} 

 

package test1;

import java.io.BufferedReader;

import java.io.File;  

import java.io.IOException;  

import java.io.InputStreamReader;

import java.util.Scanner;

 

import org.apache.lucene.analysis.Analyzer;  

import org.apache.lucene.analysis.standard.StandardAnalyzer;  

import org.apache.lucene.document.Document;  

import org.apache.lucene.index.IndexReader;  

import org.apache.lucene.queryParser.ParseException;  

import org.apache.lucene.queryParser.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.apache.lucene.util.Version;  

 

public class TestQuery {  

 

 

    public static void main(String[] args) throws ParseException, IOException {  

        String index="./index/test1";//搜索的索引路径  

        IndexReader reader=IndexReader.open(FSDirectory.open(new File(index)));  

        IndexSearcher searcher=new IndexSearcher(reader);//检索工具  

        ScoreDoc[] hits=null;

//        BufferedReader reader1=new BufferedReader(new InputStreamReader(System.in));

//        String queryString=reader1.readLine().toString();  //搜索关键字 

//        Scanner sca=new Scanner(System.in);

//        String queryString=sca.next().toString();

        String queryString="测试";

        Query query=null;  

        Analyzer analyzer=new StandardAnalyzer(Version.LUCENE_36);  

        try {  

            QueryParser qp=new QueryParser(Version.LUCENE_36,"body",analyzer);//用于解析用户输入的工具  

            query=qp.parse(queryString);  

        } catch (Exception e) {  

            // TODO: handle exception  

       }  

        if (searcher!=null) {  

            TopDocs results=searcher.search(query, 10);//只取排名前十的搜索结果  

            hits=results.scoreDocs;  

            Document document=null;

            if (hits.length>0) {  

                System.out.println("找到"+hits.length+"条结果");

                for (int i = 0; i < hits.length; i++) {  

                  document=searcher.doc(hits[i].doc);  

                  String body=document.get("body");  

                  String path=document.get("path");  

                  String modifiedtime=document.get("modifiField");  

                  System.out.print(body+"        ");   

                  System.out.println(path);   

              }  

            }else

              System.out.println("没查到结果");

            searcher.close();  

            reader.close();  

        }else

         System.out.println("没查找到索引");  

 

    }  

      

}

 

 

Test2检索相对路径上的文件

package test2;

 

import java.io.*;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Set;

 

import org.apache.lucene.analysis.Analyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.IndexReader;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.IndexWriterConfig;

import org.apache.lucene.index.IndexWriterConfig.OpenMode;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.Query;

import org.apache.lucene.search.ScoreDoc;

import org.apache.lucene.search.TopScoreDocCollector;

import org.apache.lucene.store.FSDirectory;

import org.apache.lucene.util.Version;

import org.wltea.analyzer.lucene.IKAnalyzer;

import org.wltea.analyzer.lucene.IKQueryParser;

 

public class MyLucene {

         private static final File INDEX_PATH = new File(".\\index\\test2");             // 索引文件位置, 当前路径下的index文件

         private static final  String filePath = ".\\luceneDataSource\\test.txt";// 索引数据源文件位置，当前路径下的luceneDataSource\test.txt文件

         private static final Analyzer ANALYZER = new IKAnalyzer();                   // 中文分词器

        

         public static void main(String[] args){

                   /**

                    * 创建索引

                    */

                   File readFile = new File(filePath);                                                                             // 获取数据源文件

                   HashMap<String, String> words = readFile(readFile);

 

                   Document doc = null;

                   if (words != null) {

                                     try {

                                                        IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_36, ANALYZER);

                                                        iwc.setOpenMode(OpenMode.CREATE);//创建新的索引文件create 表示创建或追加到已有索引库，没有这句话索引库会有重复的

                                                        IndexWriter writer = new IndexWriter(FSDirectory.open(INDEX_PATH), iwc);

                                                        Set<String> keys = words.keySet();

                  

                                                        for (Iterator<String> it = keys.iterator(); it.hasNext();) {

                                                                 String key = it.next();

                                                                 doc = new Document();

                                                                 Field index = new Field("index", key, Field.Store.YES,Field.Index.ANALYZED,Field.TermVector.WITH_POSITIONS_OFFSETS);

                                                                 Field contents = new Field("contents", words.get(key),Field.Store.YES, Field.Index.NO);

                                                                 doc.add(index);

                                                                 doc.add(contents);

                                                                 writer.addDocument(doc);

                                                        }

                                                        writer.close();      // 这里不关闭，建立索引会失败

                                     } catch (Exception e) {

                                                        e.printStackTrace();

                                     }

                   }

                   else

                                     System.out.println("文件读取错误");

                  

                  

         }

        

        

 

         /**

          * 判断索引库是已否创建

          */

         public boolean noIndex() {

                            File[] indexs = INDEX_PATH.listFiles();

                            if (indexs.length == 0) {

                                     return true;

                            } else {

                                     return false;

                            }

         }

        

         /**

          * 读取文件

          * @param file

          */

         public static HashMap<String, String> readFile(File file) {

                   InputStream in = null;

                   InputStreamReader inR = null;

                   BufferedReader br = null;

                   HashMap<String, String> wordsMap = new HashMap<String, String>();

                   try {

                                     in = new FileInputStream(file);

                                     inR = new InputStreamReader(in, "GBK");   //utf-8

                                     br = new BufferedReader(inR);

                                     String line;

                                     while ((line = br.readLine()) != null) {

                                               System.out.println(line);

                                               wordsMap.put(line.trim(), line.trim());

                                     }

                                     return wordsMap;

 

                   } catch (Exception e) {

                                     e.printStackTrace();

                                     return null;

                   } finally {

                            try {

                                     if (in != null)

                                               in.close();

                                     if (inR != null)

                                               inR.close();

                                     if (br != null)

                                               br.close();

                            } catch (Exception e) {

                                     e.printStackTrace();

                                     return null;

                            }

                   }

         }

        

         /**

          * 检索

          * @param queryStr

          * @param hitsPerPage

          */

         public void search(String queryStr) {

                  

                   try {

                            IndexReader reader = IndexReader.open(FSDirectory.open(INDEX_PATH));// 得到索引的目录

                            IndexSearcher searcher = new IndexSearcher(reader);

 

                            Query query = IKQueryParser.parse("index", queryStr);

                            TopScoreDocCollector collector = TopScoreDocCollector.create(100, true);

                            searcher.search(query, collector);

                            ScoreDoc[] hits = collector.topDocs().scoreDocs;

 

                            if(hits.length > 0){

                                     System.out.println("检索词："+queryStr+"\t共找到 "+hits.length+"条记录");

                                     for (int i = 0; i < hits.length; i++) {

                                               Document result = searcher.doc(hits[i].doc);

                                               System.out.println((i+1) +")" + "\n  index:" + result.get("index") + "\n  contents:" + result.get("contents"));

                                     }

                            }else{

                                     System.out.println("未找到结果");

                            }

                   } catch (Exception e) {

                            System.out.println("Exception");

                   }

         }

}

 

package test2;

 

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

 

public class TestMyLucene {

         public static void main(String[] args) throws IOException {

                   MyLucene myLucene = new MyLucene();

                   // 索引库是已否创建,如果没有则创建

                   if(myLucene.noIndex()){              

                            System.out.println("索引库还没有创建");

                   }else{

                             BufferedReader reader1=new BufferedReader(new InputStreamReader(System.in));

                        String queryString=reader1.readLine().toString();  //搜索关键字

                        myLucene.search(queryString);

                   }

         }

}

 

 

Test3检索数据库中的数据（本例为oracle）

package test3;

 

import java.io.File;

import java.io.IOException;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.text.DateFormat;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.List;

 

import org.apache.lucene.analysis.Analyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.IndexWriterConfig;

import org.apache.lucene.index.IndexWriterConfig.OpenMode;

import org.apache.lucene.store.Directory;

import org.apache.lucene.store.FSDirectory;

import org.apache.lucene.util.Version;

import org.wltea.analyzer.lucene.IKAnalyzer;

 

public class IndexCreateUtill {

 

    private List<NewsItem> list;

 

    public void createIndexForMynews() throws IOException, ClassNotFoundException{

        //存放索引的文件夹

        File indxeFile = new File(".\\index\\test3");

        //创建Directory对象

        Directory directory =FSDirectory.open(indxeFile);

        //使用IKAnalyzer分词器

        Analyzer analyzer = new IKAnalyzer();

        //创建IndexWriterConfig

        IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_36, analyzer);

        //创建IndexWriter

        indexWriterConfig.setOpenMode(OpenMode.CREATE);

        IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);

        //从数据库中读取出所有的新闻记录以便进行索引的创建

        try {

//            DBSource dbSource =DBSource.getInstance();

//            Connection conn = dbSource.getConnection();

           Connection conn=Utils.getConnection();

            Statement stmt = null;

            ResultSet rs = null;

            String sql = "select * from t_newsitem";

            stmt = conn.createStatement();

            rs = stmt.executeQuery(sql);

 

            list = new ArrayList<NewsItem>();

            while(rs.next()){

                NewsItem newsItem = new NewsItem();

                newsItem.setId(rs.getInt("id"));

                newsItem.setNewsTitle(rs.getString("newsTitle"));

                newsItem.setNewsContent(rs.getString("newsContent"));

                newsItem.setPublishTime(rs.getTimestamp("publishTime"));

                newsItem.setResource(rs.getString("resourcer"));

                newsItem.setT_newsType_id(rs.getInt("t_newsType_id"));

                newsItem.setEditor(rs.getString("editor"));

                list.add(newsItem);

            }

            DateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");

            for (int i=0;i<list.size();i++) {

                //建立一个lucene文档

                Document doc = new Document();

                //得到新闻标题

                String newsTitle = list.get(i).getNewsTitle();

                //得到新闻内容

                String newsContent = list.get(i).getNewsContent();

                //得到新闻事件

                String publishDate = dateFormat.format(list.get(i).getPublishTime());

                //得到新闻主键id

                String id = list.get(i).getId() + "";

                //将新闻标题加入文档，因为要搜索和高亮，所以index是tokennized，TermVector是WITH_POSITIONS_OFFSETS

                doc.add(new Field("title" , newsTitle , Field.Store.YES , Field.Index.ANALYZED , Field.TermVector.WITH_POSITIONS_OFFSETS));

                //添加新闻内容至文档，与标题相似

                doc.add(new Field("content" , newsContent , Field.Store.YES , Field.Index.ANALYZED , Field.TermVector.WITH_POSITIONS_OFFSETS));

                //添加时间至文档，因为要按照此字段降序排列排序，所以tokenzied,不用高亮所以TermVector是no就行了

                doc.add(new Field("date" , publishDate , Field.Store.YES , Field.Index.ANALYZED , Field.TermVector.NO));

                //添加主键至文档，不分词，不高亮。

                doc.add(new Field("id" , id , Field.Store.YES , Field.Index.NO , Field.TermVector.NO));

                indexWriter.addDocument(doc);

            }

            indexWriter.close();

            Utils.closeAll(rs, stmt, conn);

        } catch (SQLException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

    public static void main(String[] args) throws Exception {

        IndexCreateUtill util  = new IndexCreateUtill();

        util.createIndexForMynews();

    }

}

 

package test3;

 

import java.io.Serializable;

import java.util.Date;

 

public class NewsItem implements Serializable{

 

    private static final long serialVersionUID = 1L;

 

    private Integer id ;

 

    private String newsTitle ;

 

    private String newsContent;

 

    private Date publishTime;

 

    private String resource;

 

    private Integer t_newsType_id;

 

    private String editor;

 

    public NewsItem() {

 

    }

 

    public NewsItem(Integer id, String newsTitle, String newsContent,

            Date publishTime, String resource, Integer t_newsType_id, String editor) {

        super();

        this.id = id;

        this.newsTitle = newsTitle;

        this.newsContent = newsContent;

        this.publishTime = publishTime;

        this.resource = resource;

        this.t_newsType_id = t_newsType_id;

        this.editor = editor;

    }

 

    public Integer getId() {

        return id;

    }

 

    public void setId(Integer id) {

        this.id = id;

    }

 

    public String getNewsTitle() {

        return newsTitle;

    }

 

    public void setNewsTitle(String newsTitle) {

        this.newsTitle = newsTitle;

    }

 

    public String getNewsContent() {

        return newsContent;

    }

 

    public void setNewsContent(String newsContent) {

        this.newsContent = newsContent;

    }

 

    public Date getPublishTime() {

        return publishTime;

    }

 

    public void setPublishTime(Date publishTime) {

        this.publishTime = publishTime;

    }

 

    public String getResource() {

        return resource;

    }

 

    public void setResource(String resource) {

        this.resource = resource;

    }

 

    public Integer getT_newsType_id() {

        return t_newsType_id;

    }

 

    public void setT_newsType_id(Integer t_newsType_id) {

        this.t_newsType_id = t_newsType_id;

    }

 

    public String getEditor() {

        return editor;

    }

 

    public void setEditor(String editor) {

        this.editor = editor;

    }

 

}

 

package test3;

import java.io.File;  

import java.io.IOException;  

import java.util.Scanner;

 

import org.apache.lucene.analysis.Analyzer;  

import org.apache.lucene.analysis.standard.StandardAnalyzer;  

import org.apache.lucene.document.Document;  

import org.apache.lucene.index.IndexReader;  

import org.apache.lucene.queryParser.ParseException;  

import org.apache.lucene.queryParser.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.apache.lucene.util.Version;  

 

public class TestQuery {  

 

 

    public static void main(String[] args) throws ParseException, IOException {  

        String index=".\\index\\test3";//搜索的索引路径  

        IndexReader reader=IndexReader.open(FSDirectory.open(new File(index)));  

        IndexSearcher searcher=new IndexSearcher(reader);//检索工具  

        ScoreDoc[] hits=null;

//        BufferedReader reader1=new BufferedReader(new InputStreamReader(System.in));

//        String queryString=reader1.readLine().toString();  //搜索关键字 

        Scanner sca=new Scanner(System.in);

        String queryString=sca.next().toString();

        System.out.print("搜索关键词为"+queryString+",");

        Query query=null;  

        Analyzer analyzer=new StandardAnalyzer(Version.LUCENE_36);  

        try {  

            QueryParser qp=new QueryParser(Version.LUCENE_36,"content",analyzer);//用于解析用户输入的工具  

            query=qp.parse(queryString);  

        } catch (Exception e) {  

            // TODO: handle exception  

       }  

        if (searcher!=null) {  

            TopDocs results=searcher.search(query, 10);//只取排名前十的搜索结果  

            hits=results.scoreDocs;  

            Document document=null;

            if (hits.length>0) {  

                System.out.println("找到"+hits.length+"条结果");

                for (int i = 0; i < hits.length; i++) {  

                     document=searcher.doc(hits[i].doc);  

                     String title=document.get("title");

                     String content=document.get("content");

                     String date=document.get("date"); 

                     String id=document.get("id");

                     System.out.println("标题："+title);

                     System.out.println("内容："+content);

                     System.out.println("日期："+date);

                     System.out.println("ID:"+id);   

                }  

            }else

                System.out.println("没查到结果");

            searcher.close();  

            reader.close();  

        }else

           System.out.println("没查找到索引");  

 

    }  

      

}

 

package test3;

 

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

 

public class Utils {

         public static Connection getConnection() {

                   Connection con = null;

                  

                   try {

                            Class.forName("oracle.jdbc.driver.OracleDriver");

                            con = DriverManager.getConnection("jdbc:oracle:thin:@localhost :1521:orcl", "hr", "orcl");

                  

                  

                   }catch (ClassNotFoundException e) {

                            // TODO Auto-generated catch block

                            e.printStackTrace();

                   }

                  

                   catch (SQLException e) {

                            // TODO Auto-generated catch block

                            e.printStackTrace();

                   }

                  

                   return con;

         }

         public static void closeAll(ResultSet rs, Statement ps,Connection conn) throws SQLException{

        closeResultSet(rs);

        closeStatement(ps);

        closeConnection(conn);

    }

    public static void closeConnection(Connection con) {

        try {

          if (con != null) {

            con.close();

          }

        }catch (SQLException ex) {

            ex.printStackTrace();

        }

      }

 

    public static void closeStatement(Statement st) {

        try {

          if (st != null) {

            st.close();

          }

        }catch (SQLException ex) {

            ex.printStackTrace();

        }

      }

 

    public static void closeResultSet(ResultSet rs) {

        try {

          if (rs != null) {

            rs.close();

          }

        }catch (SQLException ex) {

            ex.printStackTrace();

        }

      }

 

}


转载于:https://my.oschina.net/u/1433614/blog/189885

weixin_34355559
关注
Lucene—全文检索工具包
许久
01-15 1193
一、Lucene简介 Lucene是Apache Jakarta家族中的⼀个开源项目，是⼀个开放源代码的全文检索引擎工具包，但它不是⼀个 完整的 全文检索引擎，而是⼀个全文检索引擎的架构，提供了完整的查询引擎、索引引擎和部分文本分析引擎。 Lucene提供了⼀个简单却强大的应用程式接口，能够做全文索引和搜寻。在Java开发环境⾥Lucene是⼀个成熟的免费开源工具，是⽬前最为流行的基于 Java 开源全文检索工具包。 数据总体分为两种： 结构化数据：指具有固定格式或有限长度的数据，如数据库、元数据等
使用Lucene对doc、docx、pdf、txt文档进行全文检索功能的实现 - 干勾鱼的CSDN博客 - CSDN博客1
08-03
Apache Lucene 是一个开源的全文检索库，它提供了一种高效、可扩展的方式来构建全文搜索引擎。在Java开发中，Lucene被广泛用于实现文件的全文检索功能，包括对doc、docx、pdf、txt等常见格式文档的文本内容检索。在...
用 Lucene 构建文档数据库
weixin_33835103的博客
01-19 135
说到“档案”系统，选文档数据库再合适不过了。谈到文档数据库一般想到的是 MongoDB、CouchDB 之类的，可这里要说的不是这些，而是另一个 NoSQL “文档数据库” —— Lucene。之所以要打引号，是因为暂时还没听到别人这样说。 需求 最近公司要弄一个内部搜索，对比各种方案后，决定用 Lucene。当做出第一个原型后，考虑到公...
Lucene构建索引的原理及源代码分析
u013978512的博客
06-26 2890
​ Lucene是apache软件基金会 jakarta项目组的一个子项目，是一个开放源代码的全文检索引擎工具包，但它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎（英文与德文两种西方语言）。Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能，或者是以此为基础建立起完整的全文检索引擎。​ 在讲全文检索之前，我们先聊下数据的分类。那么什么是数据呢？提起数据，大家可能会说数据库里存的就是数据。.....
Lucene 自定义索引文件的存取
tmj_159的专栏
02-04 371
前面介绍了Lucene的关于索引文件存取的API和一些接口，通过这些接口我们知道了，其实索引文件的读取也是通过流的方式来处理的。有了这个认识就可以通过接口做我们自己的实现。   先简单说下为什么要学习Lucene吧，目前我们项目组在做公司自己的分布式缓存的项目，使用缓存是很好，大大加快了常用数据的访问速度，这对增加系统IO是很有帮助的，缓存大都基于HASH 和TREE的索引结构，这两种结构基...
springboot+lucene实现全文检索
ldcaws的专栏
06-01 5272
Lucene是一个基于Java的全文信息检索工具包，它不是一个完整的搜索应用程序，而是为你的应用程序提供索引和搜索功能。Lucene 目前是 Apache Jakarta 家族中的一个开源项目，也是目前最为流行的基于 Java 开源全文检索工具包。 Lucene提供了一个简单却强大的应用程序接口（API），能够做全文索引和搜寻，在Java开发环境里Lucene是一个成熟的免费开放源代码工具。Lucene全文检索就是对文档中全部内容进行分词，然后对所有单词建立倒排索引的过程。 主要操作是使用Lucene的AP
全文检索功能（Lucene）
you4580的专栏
07-04 1374
Lucene是一个基于java开发全文检索工具包，提供了查询引擎和索引引擎如何实现全文检索：可以使用Lucene实现全文检索。Lucene是apache下的一个开放源代码的全文检索引擎工具包。提供了完整的查询引擎和索引引擎，部分文本分析引擎。Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能。
Lucene源码(三)：全文检索的底层原理
sgyuanshi的博客
04-13 1120
文章目录IndexSearchersearchAfterCollectorManagersearchcreateNormalizedWeightcreateWeightTermQuerycreateWeightTermWeightTFIDFSimilarityBooleanScorer Lucene源码(一)：分词器的底层原理 Lucene源码(二)：文本相似度TF-IDF原理 IndexRead...
SpringBoot整合Lucene实现全文检索【详细步骤】【附源码】
笑小枫
12-14 3827
SpringBoot集成Lucene，一步步介绍集成使用步骤，解决和IK分词器冲突的问题。实现多字段检索，高亮返回结果，分页查询等功能。
全文检索篇——Lucene
蔡茂的博客
06-26 884
全文检查篇——Lucene Lucene核心原理图解 收集数据、写入索引、用户输入关键字、对索引进行查询、返回查询结果. 全文检索引擎就是一个搜索引擎，要进行搜索必须有一个数据源。在①处可以看到，我们的数据源可以来自下面四个地方： 文件系统：我们的操作系统搜索是通过顺序搜索速度相当的慢，在这也可以通过全文检索来提高搜索速度； 数据库：数据库对于文本字段的内容不能建立索引，在以后应用中也...
超系统学习Lucene全文检索技术视频教程
03-21
视频详细讲解，需要的小伙伴自行网盘下载，链接见附件，永久有效。 目前业界流行的ElasticSearch和Solr搜索...系统的学习Lucene全文检索技术，全面掌握搜索原理和底层知识，为学习其他应用层面搜索技术打下坚实的基础。
人工智能-项目实践-检索系统-基于lucene全文检索引擎实现的短文本匹配系统
02-27
基于lucene全文检索引擎实现的短文本匹配系统 ajax什么时候执行success，什么时候执行error 简单的说Ajax请求通过XMLHttpRequest对象发送请求，该对象有四个状态（readyState）： 0-未初始化、1-正在初始化、2-发送...
基于EntityFrameworkCore和Lucene.NET的全文检索搜索引擎设计源码
09-25
该项目是一款基于EntityFrameworkCore和Lucene.NET技术的全文检索搜索引擎设计源码，包含54个文件，涵盖了37个C#源代码文件、4个JSON配置文件、3个用户配置文件、2个项目文件、2个Markdown文档、1个Git忽略文件、1个...
全文检索技术学习(三)——Lucene支持中文分词 - 李阿昀的博客 - CSDN博客1
08-03
在全文检索技术中，Lucene 是一个非常重要的开源搜索引擎库，它提供了强大的文本分析和索引功能。...理解 Analyzer 的工作原理以及如何定制和使用 Analyzer 是深入学习 Lucene 全文检索技术的关键。
SpringBoot整合Lucene实现全文检索
lovely960823的博客
11-24 5108
记录一下Lucene的简单使用，首先我的boot是2.x版本的。Lucene依赖如下： <!-- lucene核心库 --> <dependency> <groupId>org.apache.lucene</groupId> <artifactId>lucene-core</artifactId> <version>7.6.0</version>
基于asp.net的工作流程审批系统设计与实现.docx
09-30
基于asp.net的工作流程审批系统设计与实现.docx
这是各种对象检测数据集的预处理相关工具脚本的集合.zip
最新发布
09-30
这是各种对象检测数据集的预处理相关工具脚本的集合
基于asp.net的驾校理论考试网上模拟系统设计与实现.docx
09-30
基于asp.net的驾校理论考试网上模拟系统设计与实现.docx
Lucene全文检索解析：原理与源码深度剖析
"Lucene 原理与代码分析完整版(全文检索)" Lucene是一个开源的全文搜索引擎库，由Apache软件基金会开发。它提供了一个可扩展的、高性能的搜索功能，使得开发者能够在Java应用程序中轻松地实现全文检索。本文将深入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值