Lucene——索引删改

最新推荐文章于 2025-06-13 16:04:09 发布
最新推荐文章于 2025-06-13 16:04:09 发布
阅读量541 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Lucene
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jingtian_xiaozhi/article/details/8452029

还是那两个java文件

IndexUtil.java

Reader就是一根输入的管道，Writer就是一个输出的管道

IndexWriter.deleteDocument()//可以删除Query也可以删除Term

IndexReader.undeleteAll()

IndexWriter.forceMergeDelere()

IdexWriter.updateDocument()

通过IndexReader.numDocs()、maxDoc()、numDeletedDocs()查看删除情况

 

package org.itat.index;

//创建索引
import java.io.File;
import java.io.IOException;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.util.Version;

public class IndexUtil {
		private String[] ids={"1","2","3","4","5","6"};
		private String[] emails={"aa@aa.org","bb@bb.org","cc@cc.org","dd@@dd.org","ee@ee.org","ff@ff.org"};
		private String[] contents={"helloaa","helloboy","hellocc","hellodog","helloegg","hellofox"};
		private int[] attachs={1,2,3,4,5,6};
		private String[] names={"zhangsan","lisi","wangwu","zhaoliu","wuba","chenjiu"};
		private Directory directory=null;
		
		public IndexUtil()
		{
			try {
				directory=FSDirectory.open(new File("e:/lucene/index02"));
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		public void query()
		{
			try {
				IndexReader reader=IndexReader.open(directory);
				System.out.println("numdocs:"+reader.numDocs());
				System.out.println("maxDocs:"+reader.maxDoc());
				System.out.println("detelemaxDocs:"+reader.numDeletedDocs());
				reader.close();
				
			} catch (CorruptIndexException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
		
		public void index()
		{
			   IndexWriter writer=null;
			   Document doc=null;
			   try {
//				   writer.deleteAll(); 
				writer =new IndexWriter(directory,new IndexWriterConfig(Version.LUCENE_35, 
						   new StandardAnalyzer(Version.LUCENE_35)));
				for(int i=0;i<ids.length;i++)
				{
					doc=new Document();
			    	doc.add(new Field("id",ids[i],Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
			    	doc.add(new Field("emails",emails[i],Field.Store.YES,Field.Index.NOT_ANALYZED));
			    	doc.add(new Field("contents",contents[i],Field.Store.NO,Field.Index.ANALYZED));
			    	//谷歌搜索前面那个简介就是权值
			    	doc.add(new Field("name",names[i],Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
			    	writer.addDocument(doc); 
				}
			} catch (CorruptIndexException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (LockObtainFailedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			   finally{
				   if(writer!=null)
				   {
					  try {
						writer.close();
					} catch (CorruptIndexException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}   
				   }
			   }
		}
		//删除
		public void delete()  
        {  
            IndexWriter writer=null;  
            try {  
                writer=new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35,  
                        new StandardAnalyzer(Version.LUCENE_35)));  
                //参数是一个选项.可以是一个query，也可以是一个term  term就是一个精确查找的值   
                //此时删除的文档并未完全删除，而是存储在回收站中，可以恢复的   
                writer.deleteDocuments(new Term("id","1"));  
            } catch (CorruptIndexException e) {  
                e.printStackTrace();  
            } catch (LockObtainFailedException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
            finally{  
                if (writer!=null) {  
                    try {  
                        writer.close();  
                    } catch (CorruptIndexException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    } catch (IOException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    }  
                }  
            }  
        } 
		//恢复
		public void undelete()  
        {  
            try {  
                //恢复时必须把reader的只读设为false   
                IndexReader reader=IndexReader.open(directory,false);  
                reader.undeleteAll();  
                
                reader.close();  
            } catch (CorruptIndexException e) {  
                // TODO Auto-generated catch block   
                e.printStackTrace();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block   
                e.printStackTrace();  
            }  
              
        }
		
		 //清空回收站，强制优化   
        public void forceDelete()  
        {  
            IndexWriter writer=null;  
            try {  
                writer=new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35,  
                        new StandardAnalyzer(Version.LUCENE_35)));  
                writer.forceMergeDeletes(); 
            } catch (CorruptIndexException e) {  
                e.printStackTrace();  
            } catch (LockObtainFailedException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
            finally{  
                if (writer!=null) {  
                    try {  
                        writer.close();  
                    } catch (CorruptIndexException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    } catch (IOException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    }  
                }  
            }  
        }  

        public void merge()  
        {  
            IndexWriter writer=null;  
            try {  
                writer=new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35,  
                        new StandardAnalyzer(Version.LUCENE_35)));  
                //将索引合并为两段，建议不实用，开销太大
                writer.forceMerge(2);  
            } catch (CorruptIndexException e) {  
                e.printStackTrace();  
            } catch (LockObtainFailedException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
            finally{  
                if (writer!=null) {  
                    try {  
                        writer.close();  
                    } catch (CorruptIndexException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    } catch (IOException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    }  
                }  
            }  
        }  


        //更新索引   
        public void update()  
        {  
//            lucene本身不支持更新 
//            通过删除索引然后再建立索引来更新 
              
              IndexWriter writer=null;  
               Document doc=null;  
               try {  
                writer =new IndexWriter(directory,new IndexWriterConfig(Version.LUCENE_35,   
                           new StandardAnalyzer(Version.LUCENE_35)));  
                 
                  
                    doc=new Document();  
                    doc.add(new Field("id","111",Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));  
                    doc.add(new Field("emails",emails[0],Field.Store.YES,Field.Index.NOT_ANALYZED));  
                    doc.add(new Field("contents",contents[0],Field.Store.NO,Field.Index.ANALYZED));  
                    doc.add(new Field("name",names[0],Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));  
                    writer.updateDocument(new Term("id","1"), doc);   
                  
            } catch (CorruptIndexException e) {  
                // TODO Auto-generated catch block   
                e.printStackTrace();  
            } catch (LockObtainFailedException e) {  
                // TODO Auto-generated catch block   
                e.printStackTrace();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block   
                e.printStackTrace();  
            }  
               finally{  
                   if(writer!=null)  
                   {  
                      try {  
                        writer.close();  
                    } catch (CorruptIndexException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    } catch (IOException e) {  
                        // TODO Auto-generated catch block   
                        e.printStackTrace();  
                    }     
                   }  
               }      
        }  
  

}


测试类

package org.itat.test;

import org.itat.index.IndexUtil;
import org.junit.Test;

public class TestIndex {

	@Test
	public void testIndex()
	{
		IndexUtil index=new IndexUtil();
		index.index();
    }
	@Test
	
	public void testQuery()
	{
		IndexUtil index=new IndexUtil();
		index.query();
	}

	@Test
	public void testDelete()
	{
		IndexUtil index=new IndexUtil();
		index.delete();
	}
	
	@Test
	public void testUnDelete()
	{
		IndexUtil index=new IndexUtil();
		index.undelete();
	}
	
	@Test
	public void testForceDelete()
	{
		IndexUtil index=new IndexUtil();
		index.forceDelete();
	}
	
	@Test
	public void testUpdate()
	{
		IndexUtil index=new IndexUtil();
		index.update();
	}
}


 


 

【springboot微服务】Lucence实现Mysql全文检索
congge
04-10 8751
Lucence实现Mysql全文检索
【MySQL-24】万字全面解析＜索引＞——【介绍＆语法＆性能分析＆使用规则】
YYDsis的博客
08-30 1939
1.查看SQL执行频次【1】为什么要关注执行频率【2】查看SQL执行频次语法＆演示2.慢查询日志【1】慢查询日志机理机理＆作用＆语法【2】演示：查看慢查询日志开关是否开启【2】演示：Linux中配置慢查询日志【3】演示：实时监测慢查询日志 3.profiles详情——（解决慢查询日志--自定义问题）【1】慢查询日志机理机理＆作用＆语法【2】演示：打开profiles开关前后对比【3】演示：执行一系列的业务SQL的操作，然后通过profile查看指令的执行耗时/各个阶段耗时/CPU使用情况:4.explain
lucene的第九篇——索引的增删改
码上学习
01-05 410
索引的增删改查，因为查询有几种情况，不想代码太长，就将查分离出来了，下一篇写查 //创建索引 @Test public void creatIndex() throws IOException{ Directory directory = FSDirectory.open(new File("G:\\a\\v")); Analyzer ikAnalyzer = new IKA
SpringBoot+Lucene第六篇——索引的增删改查
K One
02-19 1551
Springboot+Lucene第六篇，索引的增删改查
MySQL数据库——索引
最新发布
BRJ_123456789的博客
06-13 961
MySQL索引优化指南摘要 索引是帮助MySQL高效获取数据的有序数据结构，常见类型包括B+Tree、Hash、R-tree和Full-text。B+Tree因其层级少、效率高且支持范围查询，成为InnoDB引擎的首选索引结构。 核心知识点： 索引分类：主键、唯一、常规、全文索引 存储形式：聚集索引（存数据）和二级索引（存指针） 使用原则：遵循最左匹配法则，避免索引失效场景 优化技巧：优先使用覆盖索引，合理设计前缀索引和联合索引 设计原则：高频查询字段优先，区分度高字段优先，控制索引数量
（三）Lucene——Field域和索引的增删改
weixin_34032792的博客
10-08 132
      1. Field域 1.1  Field的属性 是否分词（Tokenized） 是：对该field存储的内容进行分词，分词的目的，就是为了索引。 　　比如：商品名称、商品描述、商品价格 否：不需要对field存储的内容进行分词，不分词，不代表不索引，而是将整个内容进行索引。 　　比如：商品id 是否索引（Indexed） 是：将分好的词进行索引，索引的...
MySQL——索引
qq_56086076的博客
03-18 1041
MySQL——索引
MySQL进阶——索引
MADAO的博客
03-23 1590
介绍索引（Index）是帮助MySQL高效获取数据的数据结构（有序）。在数据之外，数据库系统还维护着满足特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据，这样就可以在这些数据结构上实现高级查找算法，这种数据结构就是索引。优缺点分析优点提高数据检索的效率，降低数据库IO成本通过索引列对数据进行排序，降低数据排序的成本，降低CPU的消耗缺点索引列需要占用空间。索引大大提高了查询效率，同时也降低了更新表的速度。如：对表进行Insert、update、delete时，效率降低。索引概述。
数据库进阶教学——索引
计算机硕士的博客
11-15 190
数据库进阶教学——索引。索引概述：介绍、演示、优缺点；索引结构：B+树、Hash；索引分类；索引语法：语法、示例；SQL性能分析：SQL执行频率、慢查询日志、profile详情、explain执行计划；索引使用；索引设计原则。
Lucene第二讲——索引与搜索
weixin_30576827的博客
09-06 111
一、Feild域 　　1.Field域的属性 　　　　是否分词：Tokenized　　　　 　　　　　　是：对该field存储的内容进行分词，分词的目的，就是为了索引。 　　　　　　否：不需要对field存储的内容进行分词，不分词，不代表不索引，而是将整个内容进行索引。 　　　　是否索引：Indexed　　　　 　　　　　　是：将分好的词进行索引，索引的目的，就是为了搜索。 　　　　...
Lucene应用实战(二)——Field域的使用及索引库的维护
程序员资料站
01-24 573
Field域的使用及索引库的维护 前言 在前面我们对Lucene的使用进行了简单的demo实战，本文我们详细来说明下Lucene中的Field域的使用及索引库维护的相关操作。 Fileld域的使用 简介 Lucene存储对象是以Document为存储单元，对象中相关的属性值则存放到Field中。 Field是文档中的域，包括Field名和Field值两部分，一个文档可以包括多个Field，Document只是Field 的一个承载体，Field值即为要索引的内容，也是要搜索的内容。 Field有三大属性：
Lucene——IndexReader单例化
jingtianxiaozhi的专栏
12-31 1402
IndexReader单例化来提高效率 如果Reader为空，初始化 如果Reader发生改变，关闭原来的reader，用openIfChange()重新赋值， 若不为空并且未发生改变，直接发返回Searcer IndexReader.deleteDocuments()也可可以删除Document，reader.close()关闭的 时候自动提交  package org.itat.in
Lucene——QueryParse搜索
jingtianxiaozhi的专栏
01-03 882
在主类中增加下面这样的代码 public void searchByQueryParse(Query query,int num) { try { IndexSearcher searcher = getSearcher(); TopDocs tds = searcher.search(query, num); System.out.println("一共查询了:"
Lucene——数字日期
jingtianxiaozhi的专栏
12-30 813
为时间增加索引，增加的是NumericField域 //存储数字    doc.add(new NumericField("attach",Field.Store.YES,true).setIntValue(attachs[i]));   //存储日期    doc.add(new NumericField("date",Field.Store.YES,true).setLongValue
Lucene——加权成功
jingtianxiaozhi的专栏
12-30 805
其实加权挺简单的无非就是在writer增加Document对象之前给Document.setBoost()   package org.itat.index; //创建索引 import java.io.File; import java.io.IOException; import java.util.HashMap; import java.util.Map; impo
【Lucene最终总结】
jingtianxiaozhi的专栏
05-08 718
package org.itat.test; import java.io.File; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; import org.apache.lucene.
Lucene——八种搜索
jingtianxiaozhi的专栏
01-03 685
//词语查找//范围查找 //数字范围查找//前缀查找//通配符查找//Boolean查询//短语查询//模糊查询 一看测试类什么都明白了 package org.itat.test; import org.itat.index.SearcherUtil; import org.junit.Before; import org.junit.Test; public class
Lucene——搜索部分
jingtianxiaozhi的专栏
01-03 611
构造方法：索引建在内存里，掉用初始化方法index（） IndexReader是单例的 搜索：调用getSearcher（） searchByTerm(String field,String name,int num)词语查找 searchByTermRange(String field,String start,String end,int num) 范围查找 searchByNumr
NLuke：Lucene.net索引文件查看工具解析
### Lucene索引文件查看器知识点 #### Lucene.net版本 Lucene是一个开源的全文检索引擎库，由Apache软件基金会支持，用Java编写，能够为应用程序提供强大的索引和搜索功能。Lucene.net是其.NET平台的移植版本，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值