net.sf.ehcache.config.ConfigurationFactory Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of ehcache Show documentation
Show all versions of ehcache Show documentation
Ehcache is an open source, standards-based cache used to boost performance,
offload the database and simplify scalability. Ehcache is robust, proven and full-featured and
this has made it the most widely-used Java-based cache.
/**
* Copyright Terracotta, Inc.
*
* Licensed 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 net.sf.ehcache.config;
import net.sf.ehcache.CacheException;
import net.sf.ehcache.util.ClassLoaderUtil;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringReader;
import java.net.URL;
import java.util.HashSet;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.InputSource;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import net.sf.ehcache.config.generator.ConfigurationSource;
/**
* A utility class which configures beans from XML, using reflection.
*
* @author Greg Luck
* @version $Id: ConfigurationFactory.java 8764 2014-02-18 23:08:43Z teck $
*/
public final class ConfigurationFactory {
private static final Logger LOG = LoggerFactory.getLogger(ConfigurationFactory.class.getName());
private static final String DEFAULT_CLASSPATH_CONFIGURATION_FILE = "/ehcache.xml";
private static final String FAILSAFE_CLASSPATH_CONFIGURATION_FILE = "/ehcache-failsafe.xml";
/**
* Constructor.
*/
private ConfigurationFactory() {
}
/**
* Configures a bean from an XML file.
*/
public static Configuration parseConfiguration(final File file) throws CacheException {
if (file == null) {
throw new CacheException("Attempt to configure ehcache from null file.");
}
LOG.debug("Configuring ehcache from file: {}", file);
Configuration configuration = null;
InputStream input = null;
try {
input = new BufferedInputStream(new FileInputStream(file));
configuration = parseConfiguration(input);
} catch (Exception e) {
throw new CacheException("Error configuring from " + file + ". Initial cause was " + e.getMessage(), e);
} finally {
try {
if (input != null) {
input.close();
}
} catch (IOException e) {
LOG.error("IOException while closing configuration input stream. Error was " + e.getMessage());
}
}
configuration.setSource(ConfigurationSource.getConfigurationSource(file));
return configuration;
}
/**
* Configures a bean from an XML file available as an URL.
*/
public static Configuration parseConfiguration(final URL url) throws CacheException {
LOG.debug("Configuring ehcache from URL: {}", url);
Configuration configuration;
InputStream input = null;
try {
input = url.openStream();
configuration = parseConfiguration(input);
} catch (Exception e) {
throw new CacheException("Error configuring from " + url + ". Initial cause was " + e.getMessage(), e);
} finally {
try {
if (input != null) {
input.close();
}
} catch (IOException e) {
LOG.error("IOException while closing configuration input stream. Error was " + e.getMessage());
}
}
configuration.setSource(ConfigurationSource.getConfigurationSource(url));
return configuration;
}
/**
* Configures a bean from an XML file in the classpath.
*/
public static Configuration parseConfiguration() throws CacheException {
ClassLoader standardClassloader = Thread.currentThread().getContextClassLoader();
URL url = null;
if (standardClassloader != null) {
url = standardClassloader.getResource(DEFAULT_CLASSPATH_CONFIGURATION_FILE);
}
if (url == null) {
url = ConfigurationFactory.class.getResource(DEFAULT_CLASSPATH_CONFIGURATION_FILE);
}
if (url != null) {
LOG.debug("Configuring ehcache from ehcache.xml found in the classpath: " + url);
} else {
url = ConfigurationFactory.class.getResource(FAILSAFE_CLASSPATH_CONFIGURATION_FILE);
LOG.warn("No configuration found. Configuring ehcache from ehcache-failsafe.xml "
+ " found in the classpath: {}", url);
}
Configuration configuration = parseConfiguration(url);
configuration.setSource(ConfigurationSource.getConfigurationSource());
return configuration;
}
/**
* Configures a bean from an XML input stream.
*/
public static Configuration parseConfiguration(final InputStream inputStream) throws CacheException {
LOG.debug("Configuring ehcache from InputStream");
Configuration configuration = new Configuration();
try {
InputStream translatedInputStream = translateSystemProperties(inputStream);
final SAXParser parser = SAXParserFactory.newInstance().newSAXParser();
final BeanHandler handler = new BeanHandler(configuration);
parser.parse(translatedInputStream, handler);
} catch (Exception e) {
throw new CacheException("Error configuring from input stream. Initial cause was " + e.getMessage(), e);
}
configuration.setSource(ConfigurationSource.getConfigurationSource(inputStream));
return configuration;
}
/**
* Configures a cache bean from a string of XML.
*/
public static CacheConfiguration parseCacheConfiguration(String xmlString) throws CacheException {
CacheConfiguration cacheConfiguration = new CacheConfiguration();
try {
InputSource source = new InputSource(new StringReader(xmlString));
final SAXParser parser = SAXParserFactory.newInstance().newSAXParser();
final BeanHandler handler = new BeanHandler(cacheConfiguration);
parser.parse(source, handler);
} catch (Exception e) {
throw new CacheException("Error configuring from input stream. Initial cause was " + e.getMessage(), e);
}
return cacheConfiguration;
}
/**
* Translates system properties which can be added as tokens to the config file using ${token} syntax.
*
* So, if the config file contains a character sequence "multicastGroupAddress=${multicastAddress}", and there is a system property
* multicastAddress=230.0.0.12 then the translated sequence becomes "multicastGroupAddress=230.0.0.12"
*
* @param inputStream
* @return a translated stream
*/
private static InputStream translateSystemProperties(InputStream inputStream) throws IOException {
StringBuilder sb = new StringBuilder();
int c;
Reader reader = new InputStreamReader(inputStream, "UTF-8");
while ((c = reader.read()) != -1) {
sb.append((char) c);
}
String configuration = sb.toString();
Set tokens = extractPropertyTokens(configuration);
for (Object tokenObject : tokens) {
String token = (String) tokenObject;
String leftTrimmed = token.replaceAll("\\$\\{", "");
String trimmedToken = leftTrimmed.replaceAll("\\}", "");
String property = System.getProperty(trimmedToken);
if (property == null) {
LOG.debug("Did not find a system property for the " + token +
" token specified in the configuration.Replacing with \"\"");
} else {
//replaceAll by default clobbers \ and $
String propertyWithQuotesProtected = Matcher.quoteReplacement(property);
configuration = configuration.replaceAll("\\$\\{" + trimmedToken + "\\}", propertyWithQuotesProtected);
LOG.debug("Found system property value of " + property + " for the " + token +
" token specified in the configuration.");
}
}
return new ByteArrayInputStream(configuration.getBytes("UTF-8"));
}
/**
* Extracts properties of the form ${...}
*
* @param sourceDocument the source document
* @return a Set of properties. So, duplicates are only counted once.
*/
static Set extractPropertyTokens(String sourceDocument) {
Set propertyTokens = new HashSet();
Pattern pattern = Pattern.compile("\\$\\{.+?\\}");
Matcher matcher = pattern.matcher(sourceDocument);
while (matcher.find()) {
String token = matcher.group();
propertyTokens.add(token);
}
return propertyTokens;
}
}