Java tutorial
/** * Licensed to Apereo under one or more contributor license * agreements. See the NOTICE file distributed with this work * for additional information regarding copyright ownership. * Apereo 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 the following location: * * 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.apereo.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); } }