09-自定义filter_合理的设计方式

最新推荐文章于 2024-04-23 20:40:52 发布
最新推荐文章于 2024-04-23 20:40:52 发布
阅读量487 收藏
点赞数
分类专栏： lucene
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuangrenyu1234/article/details/45172725
版权

TestCustomFilter.java

package org.itat.lucene.test;

import org.itat.lucene.util.CustomFilter;
import org.junit.Test;

/**
 * @ProjectName:lucene_advance_search03
 * @ClassName:TestCustomFilter
 * @Description:自定义filter_合理的设计方式
 * @date: 2015-4-20下午06:05:03
 * @author: 半仙儿
 * @version: V1.0
 * @date:2015-4-20下午06:05:03
 */
public class TestCustomFilter {
	/**
	 * 
	 *@MethodName:test01
	 *@Description:过滤filename为RUNNING.aaaaa、server.xml的文件
	 *@author:半仙儿
	 *@return void
	 *@date:2015-4-20下午05:51:31
	 */
	@Test
	public void test01() {
		CustomFilter cf = new CustomFilter();
		cf.searchByCustomFilter();
	}
}

TestSearch.java 

package org.itat.lucene.test;

import org.apache.lucene.index.Term;
import org.apache.lucene.search.Filter;
import org.apache.lucene.search.NumericRangeFilter;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.QueryWrapperFilter;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.SortField;
import org.apache.lucene.search.TermRangeFilter;
import org.apache.lucene.search.WildcardQuery;
import org.itat.lucene.util.FileIndexUtil;
import org.itat.lucene.util.SearchTest;
import org.junit.Before;
import org.junit.Test;

public class TestSearch {
	private SearchTest st;

	@Before
	public void init() {
		st = new SearchTest();
	}

	@Test
	public void index() {
		FileIndexUtil.index(true);
	}

	@Test
	public void test01() {
		// 不进行排序
		st.searcherBySort("java", Sort.INDEXORDER);
		// 以Doc的Id进行排序
		// st.searcherBySort("java", Sort.INDEXORDER);
		// 通过评分进行排序--设置了排序，就不能看到评分了。
		// st.searcherBySort("java", Sort.RELEVANCE);
		// 根据文件的大小进行排序
		// st.searcherBySort("java", new Sort(new SortField("size",
		// SortField.INT)));
		// 通过日期进行排序
		// st.searcherBySort("java", new Sort(new SortField("date",
		// SortField.LONG)));
		// 通过文件名进行排序
		// st.searcherBySort("java", new Sort(
		// new SortField("filename", SortField.STRING)));
		// 使用降序进行排序(通过设置SortField的最后的一个参数设置降序排序)
		// st.searcherBySort("java", new Sort(new SortField("filename",
		// SortField.STRING, true)));
		// 根据文件的大小和评分进行排序
		st.searcherBySort("java", new Sort(
				new SortField("size", SortField.INT), SortField.FIELD_SCORE));

	}

	@Test
	public void test02() {
		Filter tr = new TermRangeFilter("filename", "java.hhh", "java.ttt",
				true, true);
		tr = NumericRangeFilter.newIntRange("size", 500, 4900, true, true);
		//通过query进行过滤
		tr = new QueryWrapperFilter(new WildcardQuery(new Term("filename",
				"*.ff")));
		st.searcherByFilter("java", tr);
	}

	@Test
	public void test03() {
		Query query = new WildcardQuery(new Term("filename", "c*"));
		st.searcherByQuery(query);
	}
}<span style="font-family:Arial, Helvetica, sans-serif;"><span style="white-space: normal;">
</span></span>
CustomFilter.java 

package org.itat.lucene.util;

import java.text.SimpleDateFormat;

import org.apache.lucene.document.Document;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;

public class CustomFilter {
	public void searchByCustomFilter() {
		try {
			IndexSearcher searcher = new IndexSearcher(IndexReader
					.open(FileIndexUtil.getDirectory()));
			Query q = new TermQuery(new Term("content", "java"));
			TopDocs tds = null;
			tds = searcher.search(q, new MyIDFilter(new FilterAccessor() {

				@Override
				public String[] values() {
					// return new String[] { "10", "20", "30" };
					return new String[]{"RUNNING.aaaaa","server.xml"};
				}

				@Override
				public boolean set() {
					return true;
				}

				@Override
				public String getField() {
					// return "id";
					return "filename";
				}
			}), 200);
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			for (ScoreDoc sd : tds.scoreDocs) {
				Document d = searcher.doc(sd.doc);
				System.out.println(sd.doc + ":(" + sd.score + ")["
						+ d.get("filename") + "[" + d.get("path") + "]-->"
						+ d.get("size") + "----------->" + d.get("id"));
			}
			searcher.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}


FileIndexUtil.java 

package org.itat.lucene.util;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Random;

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.NumericField;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;

public class FileIndexUtil {
	private static Directory directory = null;
	static {
		try {
			directory = FSDirectory.open(new File("d:/lucene/files"));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static Directory getDirectory() {
		return directory;
	}

	/**
	 *@MethodName:index
	 *@Description:创建索引
	 *@param hasNew是否要新建索引
	 *@author:半仙儿
	 *@return void
	 *@date:2015-4-15下午04:05:04
	 */
	public static void index(boolean hasNew) {
		IndexWriter writer = null;
		try {
			writer = new IndexWriter(directory, new IndexWriterConfig(
					Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
			if (hasNew) {
				writer.deleteAll();
			}
			File file = new File("d:/lucene/example");
			Document doc = null;
			
			//定义一个随机数
			Random ran=new Random();
			int index=0;
			for (File f : file.listFiles()) {
				//分数
				int score=ran.nextInt(600);
				
				doc = new Document();
				doc.add(new Field("id", String.valueOf(index++),Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
				doc.add(new Field("content", new FileReader(f)));
				doc.add(new Field("filename", f.getName(), Field.Store.YES,
						Field.Index.NOT_ANALYZED));
				doc.add(new Field("path", f.getAbsolutePath(), Field.Store.YES,
						Field.Index.NOT_ANALYZED));
				doc.add(new NumericField("date", Field.Store.YES, true)
						.setLongValue(f.lastModified()));
				doc.add(new NumericField("size", Field.Store.YES, true)
						.setIntValue((int) f.length()));
				doc.add(new NumericField("score",Field.Store.NO,true).setIntValue(score));
				writer.addDocument(doc);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (writer != null)
					writer.close();
			} catch (CorruptIndexException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

FilterAccessor.java 

package org.itat.lucene.util;

public interface FilterAccessor {
	public String [] values();
	public String getField();
	public boolean set();
}<span style="font-family:Arial, Helvetica, sans-serif;"><span style="white-space: normal;">
</span></span>
MyIDFilter.java 
package org.itat.lucene.util;

import java.io.IOException;

import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.TermDocs;
import org.apache.lucene.search.DocIdSet;
import org.apache.lucene.search.Filter;
import org.apache.lucene.util.OpenBitSet;
import org.omg.CORBA.FREE_MEM;

/**
 * @ProjectName:lucene_advance_search
 * @ClassName:MyIDFilter
 * @Description:自定义过滤器，网站做促销商品搜索的时候需要用到
 * @date: 2015-4-20下午04:26:58
 * @author: 半仙儿
 * @version: V1.0
 * @date:2015-4-20下午04:26:58
 */
public class MyIDFilter extends Filter {
	// 要过滤的ID
	private FilterAccessor accessor;

	public MyIDFilter(FilterAccessor accessor) {
		this.accessor = accessor;
	}

	@Override
	public DocIdSet getDocIdSet(IndexReader reader) throws IOException {
		// 创建一个openBitSet
		OpenBitSet obs = new OpenBitSet(reader.maxDoc());

		if (accessor.set()) {
			set(reader, obs);
		} else {
			clear(reader, obs);
		}
		return obs;
	}

	private void set(IndexReader reader, OpenBitSet obs) {
		try {
			// 先把元素填满
			int[] docs = new int[1];
			int[] freqs = new int[1];
			// 获取ID所在的DOC的位置，并将其设置为0
			for (String delId : accessor.values()) {
				// 获取TermDocs
				TermDocs tds = reader.termDocs(new Term(accessor.getField(),
						delId));
				// 会将查询出来的对象的位置存储到docs中，出现的频率存储到freqs，返回查询出来的条数
				int count = tds.read(docs, freqs);
				if (count == 1) {
					// 将这个位置的元素删除
					obs.set(docs[0]);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@SuppressWarnings("unused")
	private void clear(IndexReader reader, OpenBitSet obs) {
		try {
			// 先把元素填满
			obs.set(0, reader.maxDoc());
			int[] docs = new int[1];
			int[] freqs = new int[1];
			// 获取ID所在的DOC的位置，并将其设置为0
			for (String delId : accessor.values()) {
				// 获取TermDocs
				TermDocs tds = reader.termDocs(new Term(accessor.getField(),
						delId));
				// 会将查询出来的对象的位置存储到docs中，出现的频率存储到freqs，返回查询出来的条数
				int count = tds.read(docs, freqs);
				if (count == 1) {
					// 将这个位置的元素删除
					obs.clear(docs[0]);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

SearchTest.java 

package org.itat.lucene.util;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.Filter;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.util.Version;

public class SearchTest {
	// 高效获取indexReader
	private static IndexReader reader = null;
	static {
		try {
			reader = IndexReader.open(FileIndexUtil.getDirectory());
		} catch (CorruptIndexException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public IndexSearcher getSeacher() {
		try {
			if (reader == null) {
				reader = IndexReader.open(FileIndexUtil.getDirectory());
			} else {
				IndexReader tr = IndexReader.openIfChanged(reader);
				if (tr != null) {
					reader.close();
					reader = tr;
				}
			}
			return new IndexSearcher(reader);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	public void searcherByFilter(String queryStr, Filter filter) {
		try {
			IndexSearcher searcher = getSeacher();
			QueryParser parser = new QueryParser(Version.LUCENE_35, "content",
					new StandardAnalyzer(Version.LUCENE_35));
			Query query = parser.parse(queryStr);
			TopDocs tds = null;
			if (filter != null) {
				tds = searcher.search(query, filter, 50);
			} else {
				tds = searcher.search(query, 50);
			}
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			for (ScoreDoc sd : tds.scoreDocs) {
				Document d = searcher.doc(sd.doc);
				System.out.println(sd.doc + ":(" + sd.score + ")["
						+ d.get("filename") + "[" + d.get("path") + "]-->"
						+ d.get("size") + "----"
						+ sdf.format(new Date(Long.valueOf(d.get("date"))))
						+ "]");
			}
			searcher.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void searcherByQuery(Query queryStr) {
		try {
			IndexSearcher searcher = getSeacher();
			TopDocs tds = null;
			tds = searcher.search(queryStr, 50);
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			for (ScoreDoc sd : tds.scoreDocs) {
				Document d = searcher.doc(sd.doc);
				System.out.println(sd.doc + ":(" + sd.score + ")["
						+ d.get("filename") + "[" + d.get("path") + "]-->"
						+ d.get("size") + "----"
						+ sdf.format(new Date(Long.valueOf(d.get("date"))))
						+ "]");
			}
			searcher.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void searcherBySort(String queryStr, Sort sort) {
		try {
			IndexSearcher searcher = getSeacher();
			QueryParser parser = new QueryParser(Version.LUCENE_35, "content",
					new StandardAnalyzer(Version.LUCENE_35));
			Query query = parser.parse(queryStr);
			TopDocs tds = null;
			if (sort != null) {
				tds = searcher.search(query, 50, sort);
			} else {
				tds = searcher.search(query, 50);
			}
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			for (ScoreDoc sd : tds.scoreDocs) {
				Document d = searcher.doc(sd.doc);
				System.out.println(sd.doc + ":(" + sd.score + ")["
						+ d.get("filename") + "[" + d.get("path") + "]-"+d.get("score")+"->"
						+ d.get("size") + "----"
						+ sdf.format(new Date(Long.valueOf(d.get("date"))))
						+ "]");
			}
			searcher.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}


会编程的阿强
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
FilterPro滤波器设计软件
07-23
德州仪器开发的滤波器设计软件，可以根据几个简单的参数设计出MFB或Sallen-Key滤波器，非常强的
Filter 设计
funkidd的博客
08-26 186
双二阶滤波器 https://blog.csdn.net/hunterhuang2013/article/details/62043972/ 介绍了 什么是 direct transpose form// 咋用 Filter介绍。 https://zhuanlan.zhihu.com/p/51097798 Python b,a = signal.butter(2,0.125, btype='low', output='ba') ...
设计模式之过滤器模式
最新发布
Rcain_R的博客
04-23 1056
过滤器模式（Filter Pattern）是一种行为型设计模式，它允许用户使用不同的标准（过滤条件）对一组对象进行过滤操作，得到满足特定条件的对象子集。这种模式通过定义一系列可重用的过滤器，实现了对数据集合的动态过滤，且过滤逻辑可以方便地添加、修改或组合。
设计模式：Filter过滤器
Mask_V的博客
04-13 456
原文地址：https://blog.csdn.net/u011697278/article/details/53729830场景1： 每种Filter进行某种处理，将各个Filter连在一起形成一个FilterChain。当需要往FilterChain中加入新的Filter，或者改变各个Filter的处理顺序时，可以方便的扩展。1个接口：public interface Filter { ...
Filter过滤器，责任链设计模式
m0_53881899的博客
08-22 310
Filter过滤器，责任链设计模式
最新版linux logstash-7.17.0-linux-x86_64.tar.gz
02-07
这个最新版的 logstash-7.17.0-linux-x86_64.tar.gz 压缩包是为64位 Linux 系统设计的，包含了所有必要的文件和库，方便用户在Linux环境下部署和运行。 1. **Logstash 架构**：Logstash 分为输入（Inputs）、过滤...
css3-cheat-sheet_IDEAL_cheatsheet_css_
10-02
5. **自定义字体**：`@font-face`规则引入自定义字体。 6. **Flexbox和Grid中的间距调整**：`gap`属性在Flexbox和Grid布局中设定元素间的间距。 ### 四、浏览器兼容性 CSS3的各个部分在不同浏览器上的兼容性各异...
holbertonschool-higher_level_programming
03-18
9. **性能优化**：虽然Python不是一种速度最快的编程语言，但通过合理的设计和使用内置数据结构，以及使用Cython或PyPy等工具，可以提高代码执行效率。 10. **单元测试和调试**：编写测试用例以确保代码的正确性，...
suoxianghuan.rar_锁相环_锁相环 MATLAB_锁相环设计
09-23
此外，我们还可以自定义每个组件，如使用`vco`函数生成VCO，`pd`函数创建相位检波器，然后通过`filter`函数设计低通滤波器。通过设置不同的参数，可以模拟各种锁相环应用场景，如频率捕捉、跟踪和锁定时间分析等。 ...
【JavaWeb】Filter系列——过滤器有什么用，如何编写？Filter过滤器的设计模式
胖虎虎
07-04 330
当前的OA项目存在什么缺陷？第一步：编写一个Java类实现一个接口：jarkata.servlet.Filter。并且实现这个接口当中所有的方法。第二步：在web.xml文件中对Filter进行配置。这个配置和Servlet很像。 或者使用注解：@WebFilter({“*.do”})注意： 执行下一个过滤器，如果下面没有过滤器了，执行最终的Servlet。注意：Filter的优先级，天生的就比Servlet优先级高。目标Servlet是否执行，取决于两个条件：依靠filter-mapping标签的配置
springsecurity2 自定义filter实现
03-16
NULL 博文链接：https://jiawu.iteye.com/blog/400351
django 自定义过滤器(filter)处理较为复杂的变量方法
01-01
简述：django 在views中有数据需要通过字典（dict）的方式传递给template，该字典中又包含了字典，而且字典中的键值还是一个对象，在template中处理传递过来的数据的时候，字典不能通过键值的方式取出原有数据，对象不能通过(.)的方式直接取出数据，通过大量地查阅资料，最终通过过滤器（filter）的方式解决！ 1、需要传递到template的数据，在 views.py 中的index函数中 latest_article_list 是一个Article对象的列表，包含文章ID、作者、发布时间、分类等各种信息 dic[‘tag_list’] 为一个列表（文章标签列表） artic
Filter 设计模式编码实践
苦瓜君
09-24 615
什么是 Filter Filter 在设计模式里面被称为责任链设计模式，顾名思义，我们可以在这条责任链上对一组数据做不同的处理。这种类型的设计模式属于结构型模式，它结合多个标准来获得单一标准。UML见下图，Filter设计模式 为什么要使用 Filter 好处是显而易见的，它使我们的代码将请求和处理分开。请求者可以不知道是谁处理的，处理者可以不用知道请求的全貌，两者解耦，提高系统的灵活性。从...
Lucene使用Filter搜索过滤
screensky的专栏
10-10 8643
/**       * 排序查询       *       * @param querystr       *            查找匹配的字符串       * @param domain       *            查找内容的域       * @param filter       *            过滤器       */      publi
MyBatisPlus-QueryWrapper多条件查询以及修改
w710537643的博客
04-26 1万+
gt、ge、lt、le、isNull、isNotNull 大于 > 例: gt("age", 18) → age > 18 ge 大于等于 >= 例: ge("age", 18) → age >= 18 lt 小于 < 例: lt("age", 18) → age < 18 le 小于等于 <= 例: le("age", 18) → age <= 18 isNUll 字段 IS NULL 例: isNull("name") → name is null is
QueryWrapper高级使用示例
绊脚石
06-08 6万+
QueryWrapper queryWrapper = new QueryWrapper<>(); 查询指定字段 通过select()查询指定字段，同时可对字段进行Mysql函数处理 queryWrapper.select("service_code as serviceCode", "sum(num) as num"); 设置limit 通过last(),效果等同于limit queryWrapper.last("limit 0,5"); 查询条件中使用函数 例如，在查询IP时，想使用IN
mybatis-plus QueryWrapper自定义查询条件
热门推荐
路人甲的博客
08-16 17万+
mybatis-plus框架功能很强大，把很多功能都集成了，比如自动生成代码结构，mybatis crud封装，分页，动态数据源等等，附上官网链接https://mp.baomidou.com/，github上有代码例子，国内小伙伴推荐码云https://gitee.com/baomidou/mybatis-plus。 但是，其中还是有些小坑，文档也没有涉及的很全面，碰到问题，百度或者发issu...
druid 的filter设计原理
ry的专栏
07-21 4903
druid是优秀的开源数据库连接池，据称性能很好，尤其以统计监控著称。 其统计功能实际就是利用它提供的filter实现，通过扩展filter我们可以监控 connection,(Prepared)Statement,resultSet 的任何方法。 1、首先java数据库操作过程 datasource->connection->(Prepared)Statement->result
Dubbo框架设计原则与实战
1. **模块分包原则**：模块化是框架设计的核心，合理的分包策略可以提高代码的可读性和可维护性。通常，我们按照功能或者职责将模块进行分类，如将网络通信相关的代码放在一个包下，服务暴露和服务引用放在另一个包...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

会编程的阿强

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值