home | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Lucene example source code file (CachedFilterBuilder.java)

This example Lucene source code file (CachedFilterBuilder.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Java - Lucene tags/keywords

cachedfilterbuilder, cachedfilterbuilder, dom, element, filter, filter, filterbuilderfactory, filterbuilderfactory, lrucache, lrucache, object, override, parserexception, querybuilderfactory, querywrapperfilter

The Lucene CachedFilterBuilder.java source code

 * Created on 25-Jan-2006
package org.apache.lucene.xmlparser.builders;

import java.util.Map.Entry;

import org.apache.lucene.search.CachingWrapperFilter;
import org.apache.lucene.search.Filter;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.QueryWrapperFilter;
import org.apache.lucene.xmlparser.DOMUtils;
import org.apache.lucene.xmlparser.FilterBuilder;
import org.apache.lucene.xmlparser.FilterBuilderFactory;
import org.apache.lucene.xmlparser.ParserException;
import org.apache.lucene.xmlparser.QueryBuilder;
import org.apache.lucene.xmlparser.QueryBuilderFactory;
import org.w3c.dom.Element;
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *     http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * Filters are cached in an LRU Cache keyed on the contained query or filter object. Using this will 
 * speed up overall performance for repeated uses of the same expensive query/filter. The sorts of 
 * queries/filters likely to benefit from caching need not necessarily be complex - e.g. simple 
 * TermQuerys with a large DF (document frequency) can be expensive	on large indexes. 
 * A good example of this might be a term query on a field with only 2 possible	values - 
 * "true" or "false". In a large index, querying or filtering on this field requires reading 
 * millions	of document ids from disk which can more usefully be cached as a filter bitset.
 * For Queries/Filters to be cached and reused the object must implement hashcode and
 * equals methods correctly so that duplicate queries/filters can be detected in the cache.
 * The CoreParser.maxNumCachedFilters property can be used to control the size of the LRU 
 * Cache established during the construction of CoreParser instances.
public class CachedFilterBuilder implements FilterBuilder {

	private QueryBuilderFactory queryFactory;
	private FilterBuilderFactory filterFactory;
    private  LRUCache<Object,Filter> filterCache = null;

	private int cacheSize;

	public CachedFilterBuilder(QueryBuilderFactory queryFactory, 
			FilterBuilderFactory filterFactory,int cacheSize)

	public synchronized Filter getFilter(Element e) throws ParserException

		Element childElement = DOMUtils.getFirstChildOrFail(e);

		if (filterCache == null)
			filterCache = new LRUCache<Object,Filter>(cacheSize);

		// Test to see if child Element is a query or filter that needs to be
		// cached
		QueryBuilder qb = queryFactory.getQueryBuilder(childElement.getNodeName());
		Object cacheKey = null;
		Query q = null;
		Filter f = null;
		if (qb != null)
			q = qb.getQuery(childElement);
			cacheKey = q;
		} else
			f = filterFactory.getFilter(childElement);
			cacheKey = f;
		Filter cachedFilter = filterCache.get(cacheKey);
		if (cachedFilter != null)
			return cachedFilter; // cache hit
		//cache miss
		if (qb != null)
			cachedFilter = new QueryWrapperFilter(q);
		} else
			cachedFilter = new CachingWrapperFilter(f);

		filterCache.put(cacheKey, cachedFilter);
		return cachedFilter;
	static class LRUCache<K,V> extends java.util.LinkedHashMap
	    public LRUCache(int maxsize)
	        super(maxsize * 4 / 3 + 1, 0.75f, true);
	        this.maxsize = maxsize;

	    protected int maxsize;

	    protected boolean removeEldestEntry(Entry<K,V> eldest)
	        return size() > maxsize;



Other Lucene examples (source code examples)

Here is a short list of links related to this Lucene CachedFilterBuilder.java source code file:

my book on functional programming


new blog posts


Copyright 1998-2019 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.