View Javadoc
   /* ====================================================================
    * License: 
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
    *
    * 1. Redistributions of source code must retain the above copyright
    *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by 
   *        Robert Half International (http://www.rhi.com/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Parc", "RHI", and "Robert Half International" must
   *    not be used to endorse or promote products derived from this
   *    software without prior written permission. For written
   *    permission, please contact pete.mckinstry@rhi.com.
   *
   * 5. Products derived from this software may not be called "PARC",
   *    nor may "PARC" appear in their name, without prior written
   *    permission of Robert Half International.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   */
  package com.rhi.architecture.logging;
  
  import com.rhi.architecture.config.ConfigurationException;
  import com.rhi.architecture.resource.InitializationException;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.HashMap;
  import java.util.Properties;
  
  import org.apache.log4j.PropertyConfigurator;
  
  /***
   * The Log4JFactory/Log4JLogger are holdovers from a specific system that
   * required some special configuration. These special settings complicated the
   * usage pattern, and so this class has been provided for other users who wish
   * to use Log4j, but dont' want/need to inherit the baggage from that system. 
   * It performs only the absolute minimum configuration & leaves everything 
   * else up to Log4j itself.
   * 
   * @author Pete McKinstry
   * @version 1.0
   */
  public class BasicLog4JFactory extends LogFactory {
  
  	/***
  	 * config entry specifying the log4j configuration file to use.
  	 */
  	public static final String LOG4J_PROPERTYFILE = "Log4j.Properties";
  	/***
  	 * the default category to use when logging.
  	 */
  	public static final String LOG4J_DEFAULTCATEGORY = "Log4j.DefaultCategory";
  
  	// application properties
  	private Properties props;
  
  	// cache Categories
  	private static HashMap categories = new HashMap();
  
  	// Default logger name
  	private static String defaultLoggerName = Logger.DEFAULT_CATEGORY;
  
  	/*
  	 * Inititialization flag. 
  	 * Only allows the logging factory to be initialized once per 
  	 * application. If you run multiple processes w/in the same 
  	 * application (e.g. GIT->GST->FILE) you would attempt to 
  	 * initialize the logfactory 3 times since it is a Resource
  	 * & would be reloaded each time the ResourceContext is 
  	 * re-initialized for each process. Ensure that this doesn't 
  	 * happen by holding on to a static flag that ensures init()
  	 * only happens once. 
 	 */
 	private static boolean loaded = false;
 
 	/***
 	 * default constructor - protected
 	 * 
 	 * @since 1.0
 	 */
 	public BasicLog4JFactory() {
 		super();
 	}
 
 	/***
 	 * Perform whatever initialization is required of the resource.
 	 * This method should only be called once per application instance.
 	 *
 	 * @param p
 	 * @throws InitializationException
 	 * 
 	 * @since 1.2
 	 */
 	public void init(Properties p) throws InitializationException {
 		this.props = p;
 
 		/* in the case of multi-process applications, the init() may
 		 * be called more than once. Ensure that log4j only creates one file by
 		 * only configuring it one time per application.
 		 */
 		if (!isLoaded()) {
 			// configure log4j if a log4j config file is provided in the 
 			// parc configuration. If not, ignore configuration on the assumption
 			// that log4j will handle it internally.  
 			String log4j_properties = props.getProperty(LOG4J_PROPERTYFILE);
 			if (log4j_properties != null) {
 				// create a temporary properties object into which the Log4J
 				// properties from the file will be loaded for passing to the
 				// Log4J configurator 
 				Properties tempProps = new Properties();
 				InputStream is = Thread.currentThread()
 					.getContextClassLoader().getResourceAsStream(log4j_properties);
 				if (is != null) {
 					try {
 						// create an input stream for reading the properties from
 						// the file and load it into the temporary properties object
 						is.available();
 						tempProps.load(is);
 					} catch (IOException ioe) {
 						throw new ConfigurationException("File not found in classpath");
 					}
 				}
 				else {
 					throw new ConfigurationException("File not found in classpath");
 				}
 				PropertyConfigurator.configure(tempProps);
 			}
 
 			// log4j initialized.
 			loaded = true;
 
 			// If there is a default logger configured in the properties file then
 			// use that.  Otherwise use use Logger.DEFAULT_CATEGORY
 			defaultLoggerName =
 				p.getProperty(LOG4J_DEFAULTCATEGORY, Logger.DEFAULT_CATEGORY);
 		}
 	}
 
 	/***
 	 * Returns the properties.
 	 * 
 	 * @return Properties
 	 */
 	protected Properties getProperties() {
 		return this.props;
 	}
 
 	/*** 
 	 * Perform any required cleanup.
 	 * 
 	 * @since 1.0
 	 */
 	public void close() {
 		categories.clear();
 	}
 
 	/***
 	 * @param type
 	 * @see com.rhi.architecture.logging.LogFactory#getLogger(String)
 	 * @return
 	 * @throws ConfigurationException
 	 */
 	public Logger getLogger(String type) throws ConfigurationException {
 		if (categories.containsKey(type) == false) {
 			categories.put(type, new Log4JLogger(type));
 		}
 		return (Logger) categories.get(type);
 	}
 
 	/***
 	 * Get default logger. This method exists to support backward 
 	 * compatibility prior to the factory class. Prefer 
 	 * getLogger(String type) instead.
 	 * 
 	 * @return Logger 
 	 * @throws ConfigurationException
 	 */
 	public Logger getDefaultLogger() throws ConfigurationException {
 		return getLogger(defaultLoggerName);
 	}
 
 	/***
 	 * Returns the loaded.
 	 * @return boolean
 	 */
 	protected boolean isLoaded() {
 		return loaded;
 	}
 
 }