Java tutorial
/* * 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, * 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.apache.commons.configuration.resolver; import java.io.IOException; import java.io.InputStream; import java.net.FileNameMap; import java.net.URL; import java.net.URLConnection; import java.util.Vector; import org.apache.commons.configuration.ex.ConfigurationException; import org.apache.commons.configuration.interpol.ConfigurationInterpolator; import org.apache.commons.configuration.io.FileLocator; import org.apache.commons.configuration.io.FileLocatorUtils; import org.apache.commons.configuration.io.FileSystem; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.xml.resolver.CatalogException; import org.apache.xml.resolver.readers.CatalogReader; import org.xml.sax.EntityResolver; import org.xml.sax.InputSource; import org.xml.sax.SAXException; /** * Thin wrapper around xml commons CatalogResolver to allow list of catalogs * to be provided. * @author <a * href="http://commons.apache.org/configuration/team-list.html">Commons * Configuration team</a> * @since 1.7 * @version $Id: CatalogResolver.java 1571738 2014-02-25 16:42:18Z ggregory $ */ public class CatalogResolver implements EntityResolver { /** * Debug everything. */ private static final int DEBUG_ALL = 9; /** * Normal debug setting. */ private static final int DEBUG_NORMAL = 4; /** * Debug nothing. */ private static final int DEBUG_NONE = 0; /** * The CatalogManager */ private final CatalogManager manager = new CatalogManager(); /** * The FileSystem in use. */ private FileSystem fs = FileLocatorUtils.DEFAULT_FILE_SYSTEM; /** * The CatalogResolver */ private org.apache.xml.resolver.tools.CatalogResolver resolver; /** * Stores the logger. */ private Log log; /** * Constructs the CatalogResolver */ public CatalogResolver() { manager.setIgnoreMissingProperties(true); manager.setUseStaticCatalog(false); manager.setFileSystem(fs); setLogger(null); } /** * Set the list of catalog file names * * @param catalogs The delimited list of catalog files. */ public void setCatalogFiles(String catalogs) { manager.setCatalogFiles(catalogs); } /** * Set the FileSystem. * @param fileSystem The FileSystem. */ public void setFileSystem(FileSystem fileSystem) { this.fs = fileSystem; manager.setFileSystem(fileSystem); } /** * Set the base path. * @param baseDir The base path String. */ public void setBaseDir(String baseDir) { manager.setBaseDir(baseDir); } /** * Set the {@code ConfigurationInterpolator}. * @param ci the {@code ConfigurationInterpolator} */ public void setInterpolator(ConfigurationInterpolator ci) { manager.setInterpolator(ci); } /** * Enables debug logging of xml-commons Catalog processing. * @param debug True if debugging should be enabled, false otherwise. */ public void setDebug(boolean debug) { if (debug) { manager.setVerbosity(DEBUG_ALL); } else { manager.setVerbosity(DEBUG_NONE); } } /** * Implements the {@code resolveEntity} method * for the SAX interface. * <p/> * <p>Presented with an optional public identifier and a system * identifier, this function attempts to locate a mapping in the * catalogs.</p> * <p/> * <p>If such a mapping is found, the resolver attempts to open * the mapped value as an InputSource and return it. Exceptions are * ignored and null is returned if the mapped value cannot be opened * as an input source.</p> * <p/> * <p>If no mapping is found (or an error occurs attempting to open * the mapped value as an input source), null is returned and the system * will use the specified system identifier as if no entityResolver * was specified.</p> * * @param publicId The public identifier for the entity in question. * This may be null. * @param systemId The system identifier for the entity in question. * XML requires a system identifier on all external entities, so this * value is always specified. * @return An InputSource for the mapped identifier, or null. * @throws SAXException if an error occurs. */ @Override public InputSource resolveEntity(String publicId, String systemId) throws SAXException { String resolved = getResolver().getResolvedEntity(publicId, systemId); if (resolved != null) { String badFilePrefix = "file://"; String correctFilePrefix = "file:///"; // Java 5 has a bug when constructing file URLS if (resolved.startsWith(badFilePrefix) && !resolved.startsWith(correctFilePrefix)) { resolved = correctFilePrefix + resolved.substring(badFilePrefix.length()); } try { URL url = locate(fs, null, resolved); if (url == null) { throw new ConfigurationException("Could not locate " + resolved); } InputStream is = fs.getInputStream(url); InputSource iSource = new InputSource(resolved); iSource.setPublicId(publicId); iSource.setByteStream(is); return iSource; } catch (Exception e) { log.warn("Failed to create InputSource for " + resolved, e); return null; } } return null; } /** * Returns the logger used by this configuration object. * * @return the logger */ public Log getLogger() { return log; } /** * Allows to set the logger to be used by this configuration object. This * method makes it possible for clients to exactly control logging behavior. * Per default a logger is set that will ignore all log messages. Derived * classes that want to enable logging should call this method during their * initialization with the logger to be used. * * @param log the new logger */ public void setLogger(Log log) { this.log = (log != null) ? log : LogFactory.getLog(CatalogResolver.class); } private synchronized org.apache.xml.resolver.tools.CatalogResolver getResolver() { if (resolver == null) { resolver = new org.apache.xml.resolver.tools.CatalogResolver(manager); } return resolver; } /** * Helper method for locating a given file. This implementation delegates to * the corresponding method in {@link FileLocatorUtils}. * * @param fs the {@code FileSystem} * @param basePath the base path * @param name the file name * @return the URL pointing to the file */ private static URL locate(FileSystem fs, String basePath, String name) { FileLocator locator = FileLocatorUtils.fileLocator().fileSystem(fs).basePath(basePath).fileName(name) .create(); return FileLocatorUtils.locate(locator); } /** * Extend the CatalogManager to make the FileSystem and base directory accessible. */ public static class CatalogManager extends org.apache.xml.resolver.CatalogManager { /** The static catalog used by this manager. */ private static org.apache.xml.resolver.Catalog staticCatalog; /** The FileSystem */ private FileSystem fs; /** The base directory */ private String baseDir = System.getProperty("user.dir"); /** The object for handling interpolation. */ private ConfigurationInterpolator interpolator; /** * Set the FileSystem * @param fileSystem The FileSystem in use. */ public void setFileSystem(FileSystem fileSystem) { this.fs = fileSystem; } /** * Retrieve the FileSystem. * @return The FileSystem. */ public FileSystem getFileSystem() { return this.fs; } /** * Set the base directory. * @param baseDir The base directory. */ public void setBaseDir(String baseDir) { if (baseDir != null) { this.baseDir = baseDir; } } /** * Return the base directory. * @return The base directory. */ public String getBaseDir() { return this.baseDir; } public void setInterpolator(ConfigurationInterpolator ci) { interpolator = ci; } public ConfigurationInterpolator getInterpolator() { return interpolator; } /** * Get a new catalog instance. This method is only overridden because xml-resolver * might be in a parent ClassLoader and will be incapable of loading our Catalog * implementation. * * This method always returns a new instance of the underlying catalog class. * @return the Catalog. */ @Override public org.apache.xml.resolver.Catalog getPrivateCatalog() { org.apache.xml.resolver.Catalog catalog = staticCatalog; if (catalog == null || !getUseStaticCatalog()) { try { catalog = new Catalog(); catalog.setCatalogManager(this); catalog.setupReaders(); catalog.loadSystemCatalogs(); } catch (Exception ex) { ex.printStackTrace(); } if (getUseStaticCatalog()) { staticCatalog = catalog; } } return catalog; } /** * Get a catalog instance. * * If this manager uses static catalogs, the same static catalog will * always be returned. Otherwise a new catalog will be returned. * @return The Catalog. */ @Override public org.apache.xml.resolver.Catalog getCatalog() { return getPrivateCatalog(); } } /** * Overrides the Catalog implementation to use the underlying FileSystem. */ public static class Catalog extends org.apache.xml.resolver.Catalog { /** The FileSystem */ private FileSystem fs; /** FileNameMap to determine the mime type */ private final FileNameMap fileNameMap = URLConnection.getFileNameMap(); /** * Load the catalogs. * @throws IOException if an error occurs. */ @Override public void loadSystemCatalogs() throws IOException { fs = ((CatalogManager) catalogManager).getFileSystem(); String base = ((CatalogManager) catalogManager).getBaseDir(); // This is safe because the catalog manager returns a vector of strings. @SuppressWarnings("unchecked") Vector<String> catalogs = catalogManager.getCatalogFiles(); if (catalogs != null) { for (int count = 0; count < catalogs.size(); count++) { String fileName = catalogs.elementAt(count); URL url = null; InputStream is = null; try { url = locate(fs, base, fileName); if (url != null) { is = fs.getInputStream(url); } } catch (ConfigurationException ce) { String name = (url == null) ? fileName : url.toString(); // Ignore the exception. catalogManager.debug.message(DEBUG_ALL, "Unable to get input stream for " + name + ". " + ce.getMessage()); } if (is != null) { String mimeType = fileNameMap.getContentTypeFor(fileName); try { if (mimeType != null) { parseCatalog(mimeType, is); continue; } } catch (Exception ex) { // Ignore the exception. catalogManager.debug.message(DEBUG_ALL, "Exception caught parsing input stream for " + fileName + ". " + ex.getMessage()); } finally { is.close(); } } parseCatalog(base, fileName); } } } /** * Parse the specified catalog file. * @param baseDir The base directory, if not included in the file name. * @param fileName The catalog file. May be a full URI String. * @throws IOException If an error occurs. */ public void parseCatalog(String baseDir, String fileName) throws IOException { base = locate(fs, baseDir, fileName); catalogCwd = base; default_override = catalogManager.getPreferPublic(); catalogManager.debug.message(DEBUG_NORMAL, "Parse catalog: " + fileName); boolean parsed = false; for (int count = 0; !parsed && count < readerArr.size(); count++) { CatalogReader reader = (CatalogReader) readerArr.get(count); InputStream inStream; try { inStream = fs.getInputStream(base); } catch (Exception ex) { catalogManager.debug.message(DEBUG_NORMAL, "Unable to access " + base + ex.getMessage()); break; } try { reader.readCatalog(this, inStream); parsed = true; } catch (CatalogException ce) { catalogManager.debug.message(DEBUG_NORMAL, "Parse failed for " + fileName + ce.getMessage()); if (ce.getExceptionType() == CatalogException.PARSE_FAILED) { break; } else { // try again! continue; } } finally { try { inStream.close(); } catch (IOException ioe) { // Ignore the exception. inStream = null; } } } if (parsed) { parsePendingCatalogs(); } } /** * Perform character normalization on a URI reference. * * @param uriref The URI reference * @return The normalized URI reference. */ @Override protected String normalizeURI(String uriref) { ConfigurationInterpolator ci = ((CatalogManager) catalogManager).getInterpolator(); String resolved = (ci != null) ? String.valueOf(ci.interpolate(uriref)) : uriref; return super.normalizeURI(resolved); } } }