有的应用有些要求，对于某类型的内容即使满足条件了，但是也不能被搜索出来，lucene中提供了过滤器的功能，通过自定义的过滤器继承Filter，从而实现特定的过滤功能。

Filter是一种过滤行为BitSet是一种位集合队列，这个队列中只有两种取值，TRUE或FALSE，LUCENE以这两种取值代表文档是否被过滤，也就是说，LUCENE返回结果时，会首先遍历BITSET，仅将那些对应值为TRUE的文档返回。

过滤器：

package com.filter;

import java.io.IOException;
import java.util.BitSet;

import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.TermDocs;
import org.apache.lucene.search.Filter;

public class AdvancedSecurityFilter extends Filter {

 //安全级别的常量
 public static final int ADVANCED=0;
 @Override
 public BitSet bits(IndexReader reader) throws IOException {
  //首先初始化一个BITSET对象
  final BitSet bits = new BitSet(reader.maxDoc());
  //先将整个集合设置为TRUE,表示当前集合内的所有文档都是可以被检索到的。
  bits.set(0,bits.size()-1);
  //构造一个TERM对象，代表最高安全级别
  Term term = new Term("securitylevel",ADVANCED+"");
  
  //从索引中搜索出所有最高安全级别的文档
  TermDocs termDocs = reader.termDocs(term);
  
  //遍历每个文档，并将其
  while(termDocs.next())
  {
   bits.set(termDocs.doc(),false);
  }
  return bits;
 }

}

过滤器使用实例：

public class FilterDemo {

 /**
  * @param args
  */
 public static final int ADVANCED=0;
 public static final int MIDDLE =1;
 public static final int NORMAL=2;
 public static void main(String[] args) {
  try {
   
   /*File file = new File("d://demo");
   Analyzer luceneAnalyzer = new StandardAnalyzer();
   IndexWriter writer = new IndexWriter(file, luceneAnalyzer, false);
   Document doc1 = new Document();
   Field f1 = new Field("bookNumber","0003",Field.Store.YES,Field.Index.UN_TOKENIZED);
   Field f2 = new Field("bookName","非对称模型",Field.Store.YES,Field.Index.UN_TOKENIZED);
   Field f3 = new Field("securitylevel",ADVANCED+"",Field.Store.YES,Field.Index.UN_TOKENIZED);
   doc1.add(f1);
   doc1.add(f2);
   doc1.add(f3);
   
   Document doc2 = new Document();
   Field f4 = new Field("bookNumber","0001",Field.Store.YES,Field.Index.UN_TOKENIZED);
   Field f5 = new Field("bookName","钢铁战士",Field.Store.YES,Field.Index.TOKENIZED);
   Field f6 = new Field("securitylevel",MIDDLE+"",Field.Store.YES,Field.Index.UN_TOKENIZED);
   doc2.add(f4);
   doc2.add(f5);
   doc2.add(f6);
   
   Document doc3 = new Document();
   Field f7 = new Field("bookNumber","0004",Field.Store.YES,Field.Index.UN_TOKENIZED);
   Field f8 = new Field("bookName","黑猫警长",Field.Store.YES,Field.Index.TOKENIZED);
   Field f9 = new Field("securitylevel",NORMAL+"",Field.Store.YES,Field.Index.UN_TOKENIZED);
   doc3.add(f7);
   doc3.add(f8);
   doc3.add(f9);
   
   writer.addDocument(doc1);
   writer.addDocument(doc2);
   writer.addDocument(doc3);
   
   writer.setUseCompoundFile(true);
   writer.optimize();
   writer.close();*/
   
   Term begin = new Term("bookNumber","0001");
   Term end = new Term("bookNumber","0004");
   RangeQuery q = new RangeQuery(begin,end,true);
   
   IndexSearcher searcher = new IndexSearcher("d://demo");
   System.out.println(q.toString());

//通过将自定义的过滤器配置在search方法中，从而达到过滤的目的。
   Hits hits = searcher.search(q,new AdvancedSecurityFilter());
   for(int i=0;i<hits.length();i++)
   {
    System.out.println(hits.doc(i));
   }
   
  } catch (Exception e) {
   e.printStackTrace();
  }

 }

}

阅读全文……

发表评论

IT瘾于2015年4月15日 上午12时51分00秒发布 #

我们如何应对这样的商业广告呢？基本思路如下：

    1、当管理员发现一篇博文为黑博文时，人工确认。

    2、将人工确认的黑博文保存到黑博文数据库。

    3、当有新博文发表时，和黑博文数据库进行相似度计算，如果相似度超过预设的阈值，则拒绝发表博文。

下面是黑博文判断程序的详细判断过程，先上最终结果：

判定相似性的方式一：简单共有词

阈值=Math.min(339, 340)*0.8=271.2

待发表博文和黑博文共有的词数：339

因为待发表博文和黑博文共有的词数339 大于 阈值：271.2

所以判断为 相似 ，拒绝发表！

判定相似性的方式二：余弦相似度

待发表博文和黑博文的余弦夹角值：0.9977658868305056

因为待发表博文和黑博文的余弦夹角值0.9977658868305056大于或等于阈值：0.8

所以判断为 相似 ，拒绝发表！

阅读全文……

发表评论

IT瘾于2015年4月10日 下午09时44分00秒发布 #

使用Future的特性(推荐)

利用Future.get(long timeout,   TimeUnit unit)方法。

1、新建TaskThread类，实现Callable接口，实现call()方法。

2、线程池调用submit()方法，得到Future对象。

3、调用Future对象的get(long timeout,   TimeUnit unit)方法，该方法的特点：阻塞式线程调用，同时指定了超时时间timeout，get方法执行超时会抛出timeout异常，该异常需要捕获。

示例代码：

[java] view plaincopy

 

1. public class TimeTask implements Callable<String> {  
2.   
3.     @Override  
4.     public String call() throws Exception {  
5.         //执行任务主体,简单示例  
6.         Thread.sleep(1000);  
7.         return "hehe";  
8.     }  
9.   
10. }  

[java] view plaincopy

 

1.               ExecutorService exec = Executors.newCachedThreadPool();  
2. Future<String> f = exec.submit(new TimeTask());  
3. try {  
4.     f.get(200, TimeUnit.MILLISECONDS);  
5. } catch (InterruptedException e) {  
6.     e.printStackTrace();  
7. } catch (ExecutionException e) {  
8.     e.printStackTrace();  
9. } catch (TimeoutException e) {  
10.     //定义超时后的状态修改  
11.     System.out.println("thread time out");  
12.     e.printStackTrace();  
13. }  
14.  

Google Guava已经提供了TimeLimiter的功能，实现更精巧，功能更强大，可参考：

1. import com.google.common.util.concurrent.SimpleTimeLimiter;  
2.   
3. public class TimeLimiterGoogle {  
4.   
5.     /** 
6.      * @param args 
7.      * @throws Exception  
8.      */  
9.     public static void main(String[] args) throws Exception {  
10.         // TODO Auto-generated method stub  
11.         SimpleTimeLimiter st = new SimpleTimeLimiter();  
12.         String r1 = st.callWithTimeout(new Callable<String>(){  
13.   
14.             @Override  
15.             public String call() throws Exception {  
16.                 return "Hello";  
17.             }}, 10, TimeUnit.MILLISECONDS, true);  
18.         System.out.println(r1);  
19.           
20.         String r2 = st.callWithTimeout(new Callable<String>(){  
21.   
22.             @Override  
23.             public String call() throws Exception {  
24.                 Thread.sleep(1000);  
25.                 return "Hello";  
26.             }}, 10, TimeUnit.MILLISECONDS, true);  
27.         System.out.println(r2);   
28.     }  
29.   
30. }  

阅读全文……

发表评论

IT瘾于2015年4月7日 下午09时55分00秒发布 #