/**
* Licensed to Jasig under one or more contributor license
* agreements. See the NOTICE file distributed with this work
* for additional information regarding copyright ownership.
* Jasig 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, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.jasig.portal.xml.xpath;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import javax.xml.namespace.NamespaceContext;
import javax.xml.namespace.QName;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathExpressionException;
import org.apache.commons.pool.impl.GenericKeyedObjectPool;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.stereotype.Service;
import com.google.common.base.Function;
/**
* Implementation of {@link XPathOperations} that uses a {@link GenericKeyedObjectPool} to pool compiled {@link XPathExpression}
* instances.
*
* @author Eric Dalquist
* @version $Revision$
*/
@Service
public class XPathPoolImpl implements XPathOperations, DisposableBean {
protected final Logger logger = LoggerFactory.getLogger(getClass());
private final ThreadLocalXPathVariableResolver variableResolver = new ThreadLocalXPathVariableResolver();
private final XPathExpressionFactory xpathExpressionfactory;
private final NamespaceContext namespaceContext;
private final GenericKeyedObjectPool pool;
public XPathPoolImpl() {
this(null);
}
public XPathPoolImpl(NamespaceContext namespaceContext) {
this.namespaceContext = namespaceContext;
this.xpathExpressionfactory = new XPathExpressionFactory(this.namespaceContext, variableResolver);
this.pool = new GenericKeyedObjectPool(xpathExpressionfactory);
this.pool.setMaxActive(500);
this.pool.setMaxIdle(500);
this.pool.setTimeBetweenEvictionRunsMillis(TimeUnit.SECONDS.toMillis(60));
this.pool.setMinEvictableIdleTimeMillis(TimeUnit.MINUTES.toMillis(5));
this.pool.setNumTestsPerEvictionRun(this.pool.getMaxIdle() / 9);
this.pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL);
}
@Override
public void destroy() throws Exception {
this.pool.close();
}
@Override
public <T> T doWithExpression(String expression, Function<XPathExpression, T> callback) {
return this.<T>doWithExpression(expression, null, callback);
}
@Override
public <T> T doWithExpression(String expression, Map<String, ?> variables, Function<XPathExpression, T> callback) {
try {
final XPathExpression xPathExpression = (XPathExpression)this.pool.borrowObject(expression);
try {
this.variableResolver.setVariables(variables);
return callback.apply(xPathExpression);
}
finally {
this.variableResolver.clearVariables();
this.pool.returnObject(expression, xPathExpression);
}
}
catch (RuntimeException e) {
throw e;
}
catch (Exception e) {
throw new IllegalStateException("Exception of type " + e.getClass().getName() + " is not expected", e);
}
}
@Override
public <T> T evaluate(String expression, final Object item, final QName returnType) {
return this.<T>evaluate(expression, null, item, returnType);
}
@Override
public <T> T evaluate(String expression, Map<String, ?> variables, final Object item, final QName returnType) {
return this.doWithExpression(expression, variables, new Function<XPathExpression, T>() {
/* (non-Javadoc)
* @see com.google.common.base.Function#apply(java.lang.Object)
*/
@SuppressWarnings("unchecked")
@Override
public T apply(XPathExpression xpathExpression) {
try {
return (T)xpathExpression.evaluate(item, returnType);
}
catch (XPathExpressionException e) {
throw new RuntimeException("Failed to execute XPathExpression '" + xpathExpression + "'", e);
}
}
});
}
public void clear() {
pool.clear();
}
public void clearOldest() {
pool.clearOldest();
}
public void close() throws Exception {
pool.close();
}
public void evict() throws Exception {
pool.evict();
}
public boolean getLifo() {
return pool.getLifo();
}
public int getMaxActive() {
return pool.getMaxActive();
}
public int getMaxIdle() {
return pool.getMaxIdle();
}
public int getMaxTotal() {
return pool.getMaxTotal();
}
public long getMaxWait() {
return pool.getMaxWait();
}
public long getMinEvictableIdleTimeMillis() {
return pool.getMinEvictableIdleTimeMillis();
}
public int getMinIdle() {
return pool.getMinIdle();
}
public int getNumActive() {
return pool.getNumActive();
}
public int getNumIdle() {
return pool.getNumIdle();
}
public int getNumTestsPerEvictionRun() {
return pool.getNumTestsPerEvictionRun();
}
public boolean getTestOnBorrow() {
return pool.getTestOnBorrow();
}
public boolean getTestOnReturn() {
return pool.getTestOnReturn();
}
public boolean getTestWhileIdle() {
return pool.getTestWhileIdle();
}
public long getTimeBetweenEvictionRunsMillis() {
return pool.getTimeBetweenEvictionRunsMillis();
}
public byte getWhenExhaustedAction() {
return pool.getWhenExhaustedAction();
}
public void setLifo(boolean lifo) {
pool.setLifo(lifo);
}
public void setMaxActive(int maxActive) {
pool.setMaxActive(maxActive);
}
public void setMaxIdle(int maxIdle) {
pool.setMaxIdle(maxIdle);
}
public void setMaxTotal(int maxTotal) {
pool.setMaxTotal(maxTotal);
}
public void setMaxWait(long maxWait) {
pool.setMaxWait(maxWait);
}
public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) {
pool.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
}
public void setMinIdle(int poolSize) {
pool.setMinIdle(poolSize);
}
public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun) {
pool.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
}
public void setTestOnBorrow(boolean testOnBorrow) {
pool.setTestOnBorrow(testOnBorrow);
}
public void setTestOnReturn(boolean testOnReturn) {
pool.setTestOnReturn(testOnReturn);
}
public void setTestWhileIdle(boolean testWhileIdle) {
pool.setTestWhileIdle(testWhileIdle);
}
public void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis) {
pool.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
}
public void setWhenExhaustedAction(byte whenExhaustedAction) {
pool.setWhenExhaustedAction(whenExhaustedAction);
}
}