Java OptionConverter类代码示例

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
private void parseErrorHandler(
  final ErrorHandler eh,
  final String errorHandlerPrefix,
  final Properties props, 
  final LoggerRepository hierarchy) {
boolean rootRef = OptionConverter.toBoolean(
			  OptionConverter.findAndSubst(errorHandlerPrefix + ROOT_REF, props), false);
if (rootRef) {
		  eh.setLogger(hierarchy.getRootLogger());
   }
String loggerName = OptionConverter.findAndSubst(errorHandlerPrefix + LOGGER_REF , props);
if (loggerName != null) {
	Logger logger = (loggerFactory == null) ? hierarchy.getLogger(loggerName)
	                : hierarchy.getLogger(loggerName, loggerFactory);
	eh.setLogger(logger);
}
String appenderName = OptionConverter.findAndSubst(errorHandlerPrefix + APPENDER_REF_TAG, props);
if (appenderName != null) {
	Appender backup = parseAppender(props, appenderName);
	if (backup != null) {
		eh.setBackupAppender(backup);
	}
}
}
 

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
public
Object invoke(String operationName, Object params[], String signature[])
  throws MBeanException,
  ReflectionException {

  if(operationName.equals("activateOptions") &&
                   appender instanceof OptionHandler) {
    OptionHandler oh = (OptionHandler) appender;
    oh.activateOptions();
    return "Options activated.";
  } else if (operationName.equals("setLayout")) {
    Layout layout = (Layout) OptionConverter.instantiateByClassName((String)
						      params[0],
						      Layout.class,
						      null);
    appender.setLayout(layout);
    registerLayoutMBean(layout);
  }
  return null;
}
 

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
/**
    Add a renderer to a hierarchy passed as parameter.
 */
 static
 public
 void addRenderer(RendererSupport repository, String renderedClassName,
	   String renderingClassName) {
   LogLog.debug("Rendering class: ["+renderingClassName+"], Rendered class: ["+
	 renderedClassName+"].");
   ObjectRenderer renderer = (ObjectRenderer)
            OptionConverter.instantiateByClassName(renderingClassName,
					    ObjectRenderer.class,
					    null);
   if(renderer == null) {
     LogLog.error("Could not instantiate renderer ["+renderingClassName+"].");
     return;
   } else {
     try {
Class renderedClass = Loader.loadClass(renderedClassName);
repository.setRenderer(renderedClass, renderer);
     } catch(ClassNotFoundException e) {
LogLog.error("Could not find class ["+renderedClassName+"].", e);
     }
   }
 }
 

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
void configureRootCategory(Properties props, LoggerRepository hierarchy) {
   String effectiveFrefix = ROOT_LOGGER_PREFIX;
   String value = OptionConverter.findAndSubst(ROOT_LOGGER_PREFIX, props);

   if(value == null) {
     value = OptionConverter.findAndSubst(ROOT_CATEGORY_PREFIX, props);
     effectiveFrefix = ROOT_CATEGORY_PREFIX;
   }

   if(value == null)
     LogLog.debug("Could not find root logger information. Is this OK?");
   else {
     Logger root = hierarchy.getRootLogger();
     synchronized(root) {
parseCategory(props, root, effectiveFrefix, INTERNAL_ROOT_NAME, value);
     }
   }
 }
 

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
/**
   Convert <code>val</code> a String parameter to an object of a
   given type.
*/
protected
Object convertArg(String val, Class type) {
  if(val == null)
    return null;

  String v = val.trim();
  if (String.class.isAssignableFrom(type)) {
    return val;
  } else if (Integer.TYPE.isAssignableFrom(type)) {
    return new Integer(v);
  } else if (Long.TYPE.isAssignableFrom(type)) {
    return new Long(v);
  } else if (Boolean.TYPE.isAssignableFrom(type)) {
    if ("true".equalsIgnoreCase(v)) {
      return Boolean.TRUE;
    } else if ("false".equalsIgnoreCase(v)) {
      return Boolean.FALSE;
    }
  } else if (Priority.class.isAssignableFrom(type)) {
    return OptionConverter.toLevel(v, (Level) Level.DEBUG);
  }
  return null;
}
 

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
/**
    Read configuration options from <code>properties</code>.

    See {@link #doConfigure(String, LoggerRepository)} for the expected format.
 */
 public
 void doConfigure(Properties properties, LoggerRepository hierarchy) {
   String value = properties.getProperty(LogLog.DEBUG_KEY);
   if(value == null) {
     value = properties.getProperty("log4j.configDebug");
     if(value != null)
LogLog.warn("[log4j.configDebug] is deprecated. Use [log4j.debug] instead.");
   }

   if(value != null) {
     LogLog.setInternalDebugging(OptionConverter.toBoolean(value, true));
   }

     //
     //   if log4j.reset=true then
     //        reset hierarchy
   String reset = properties.getProperty(RESET_KEY);
   if (reset != null && OptionConverter.toBoolean(reset, false)) {
         hierarchy.resetConfiguration();
   }

   String thresholdStr = OptionConverter.findAndSubst(THRESHOLD_PREFIX,
					       properties);
   if(thresholdStr != null) {
     hierarchy.setThreshold(OptionConverter.toLevel(thresholdStr,
					     (Level) Level.ALL));
     LogLog.debug("Hierarchy threshold set to ["+hierarchy.getThreshold()+"].");
   }

   configureRootCategory(properties, hierarchy);
   configureLoggerFactory(properties);
   parseCatsAndRenderers(properties, hierarchy);

   LogLog.debug("Finished configuring.");
   // We don't want to hold references to appenders preventing their
   // garbage collection.
   registry.clear();
 }
 

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
/**
   Check the provided <code>Properties</code> object for a
   {@link org.apache.log4j.spi.LoggerFactory LoggerFactory}
   entry specified by {@link #LOGGER_FACTORY_KEY}.  If such an entry
   exists, an attempt is made to create an instance using the default
   constructor.  This instance is used for subsequent Category creations
   within this configurator.

   @see #parseCatsAndRenderers
 */
protected void configureLoggerFactory(Properties props) {
  String factoryClassName = OptionConverter.findAndSubst(LOGGER_FACTORY_KEY,
					   props);
  if(factoryClassName != null) {
    LogLog.debug("Setting category factory to ["+factoryClassName+"].");
    loggerFactory = (LoggerFactory)
         OptionConverter.instantiateByClassName(factoryClassName,
					 LoggerFactory.class,
					 loggerFactory);
    PropertySetter.setProperties(loggerFactory, props, FACTORY_PREFIX + ".");
  }
}
 

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
/**
    Parse non-root elements, such non-root categories and renderers.
 */
 protected
 void parseCatsAndRenderers(Properties props, LoggerRepository hierarchy) {
   Enumeration enumeration = props.propertyNames();
   while(enumeration.hasMoreElements()) {
     String key = (String) enumeration.nextElement();
     if(key.startsWith(CATEGORY_PREFIX) || key.startsWith(LOGGER_PREFIX)) {
String loggerName = null;
if(key.startsWith(CATEGORY_PREFIX)) {
  loggerName = key.substring(CATEGORY_PREFIX.length());
} else if(key.startsWith(LOGGER_PREFIX)) {
  loggerName = key.substring(LOGGER_PREFIX.length());
}
String value =  OptionConverter.findAndSubst(key, props);
Logger logger = hierarchy.getLogger(loggerName, loggerFactory);
synchronized(logger) {
  parseCategory(props, logger, key, loggerName, value);
  parseAdditivityForLogger(props, logger, loggerName);
}
     } else if(key.startsWith(RENDERER_PREFIX)) {
String renderedClass = key.substring(RENDERER_PREFIX.length());
String renderingClass = OptionConverter.findAndSubst(key, props);
if(hierarchy instanceof RendererSupport) {
  RendererMap.addRenderer((RendererSupport) hierarchy, renderedClass,
			  renderingClass);
}
     }
   }
 }
 

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
/**
   Parse the additivity option for a non-root category.
 */
void parseAdditivityForLogger(Properties props, Logger cat,
		  String loggerName) {
  String value = OptionConverter.findAndSubst(ADDITIVITY_PREFIX + loggerName,
			     props);
  LogLog.debug("Handling "+ADDITIVITY_PREFIX + loggerName+"=["+value+"]");
  // touch additivity only if necessary
  if((value != null) && (!value.equals(""))) {
    boolean additivity = OptionConverter.toBoolean(value, true);
    LogLog.debug("Setting additivity for \""+loggerName+"\" to "+
   additivity);
    cat.setAdditivity(additivity);
  }
}
 

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
/**
   @deprecated Use the setter method for the option directly instead
   of the generic <code>setOption</code> method. 
*/
public
void setOption(String key, String value) { 
  
  if(key.equalsIgnoreCase(STRING_TO_MATCH_OPTION)) {
    stringToMatch = value;
  } else if (key.equalsIgnoreCase(ACCEPT_ON_MATCH_OPTION)) {
    acceptOnMatch = OptionConverter.toBoolean(value, acceptOnMatch);
  }
}
 

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
public
void setAttribute(Attribute attribute) throws AttributeNotFoundException,
                                              InvalidAttributeValueException,
                                              MBeanException,
                                              ReflectionException {

  // Check attribute is not null to avoid NullPointerException later on
  if (attribute == null) {
    throw new RuntimeOperationsException(
                new IllegalArgumentException("Attribute cannot be null"),
 "Cannot invoke a setter of "+dClassName+" with null attribute");
  }
  String name = attribute.getName();
  Object value = attribute.getValue();

  if (name == null) {
    throw new RuntimeOperationsException(
             new IllegalArgumentException("Attribute name cannot be null"),
      "Cannot invoke the setter of "+dClassName+
      " with null attribute name");
  }

  if(name.equals(THRESHOLD)) {
    Level l = OptionConverter.toLevel((String) value,
			   hierarchy.getThreshold());
    hierarchy.setThreshold(l);
  }


}
 

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
void addAppender(String appenderClass, String appenderName) {
  cat.debug("addAppender called with "+appenderClass+", "+appenderName);
  Appender appender = (Appender)
     OptionConverter.instantiateByClassName(appenderClass,
			      org.apache.log4j.Appender.class,
			      null);
  appender.setName(appenderName);
  logger.addAppender(appender);

  //appenderMBeanRegistration();

}
 

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
/**
    Used internally to parse a filter element.
  */
 protected
 void parseFilters(Element element, Appender appender) {
   String clazz = subst(element.getAttribute(CLASS_ATTR));
   Filter filter = (Filter) OptionConverter.instantiateByClassName(clazz,
                                               Filter.class, null);
   
   if(filter != null) {
     PropertySetter propSetter = new PropertySetter(filter);
     NodeList children = element.getChildNodes();
     final int length 	= children.getLength();

     for (int loop = 0; loop < length; loop++) {
Node currentNode = children.item(loop);
if (currentNode.getNodeType() == Node.ELEMENT_NODE) {
  Element currentElement = (Element) currentNode;
  String tagName = currentElement.getTagName();
  if(tagName.equals(PARAM_TAG)) {
           setParameter(currentElement, propSetter);
  } else {
           quietParseUnrecognizedElement(filter, currentElement, props);
     }
}
     }
     propSetter.activate();
     LogLog.debug("Adding filter of type ["+filter.getClass()
	   +"] to appender named ["+appender.getName()+"].");
     appender.addFilter(filter);
   }    
 }
 

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
/**
    Used internally to parse the category factory element.
 */
 protected
 void parseCategoryFactory(Element factoryElement) {
   String className = subst(factoryElement.getAttribute(CLASS_ATTR));

   if(EMPTY_STR.equals(className)) {
     LogLog.error("Category Factory tag " + CLASS_ATTR + " attribute not found.");
     LogLog.debug("No Category Factory configured.");
   }
   else {
     LogLog.debug("Desired category factory: ["+className+']');
     Object factory = OptionConverter.instantiateByClassName(className,
                                                                LoggerFactory.class, 
                                                                null);
     if (factory instanceof LoggerFactory) {
         catFactory = (LoggerFactory) factory;
     } else {
         LogLog.error("Category Factory class " + className + " does not implement org.apache.log4j.LoggerFactory");
     }
     PropertySetter propSetter = new PropertySetter(factory);

     Element  currentElement = null;
     Node     currentNode    = null;
     NodeList children       = factoryElement.getChildNodes();
     final int length        = children.getLength();

     for (int loop=0; loop < length; loop++) {
       currentNode = children.item(loop);
if (currentNode.getNodeType() == Node.ELEMENT_NODE) {
  currentElement = (Element)currentNode;
  if (currentElement.getTagName().equals(PARAM_TAG)) {
    setParameter(currentElement, propSetter);
  } else {
          quietParseUnrecognizedElement(factory, currentElement, props);
     }
}
     }
   }
 }
 

import org.apache.log4j.helpers.OptionConverter; //导入依赖的package包/类
/**
    Used internally to parse a level  element.
 */
 protected
 void parseLevel(Element element, Logger logger, boolean isRoot) {
   String catName = logger.getName();
   if(isRoot) {
     catName = "root";
   }

   String priStr = subst(element.getAttribute(VALUE_ATTR));
   LogLog.debug("Level value for "+catName+" is  ["+priStr+"].");
   
   if(INHERITED.equalsIgnoreCase(priStr) || NULL.equalsIgnoreCase(priStr)) {
     if(isRoot) {
LogLog.error("Root level cannot be inherited. Ignoring directive.");
     } else {
logger.setLevel(null);
     }
   } else {
     String className = subst(element.getAttribute(CLASS_ATTR));      
     if(EMPTY_STR.equals(className)) {	
logger.setLevel(OptionConverter.toLevel(priStr, Level.DEBUG));
     } else {
LogLog.debug("Desired Level sub-class: ["+className+']');
try {	 
  Class clazz = Loader.loadClass(className);
  Method toLevelMethod = clazz.getMethod("toLevel", 
					    ONE_STRING_PARAM);
  Level pri = (Level) toLevelMethod.invoke(null, 
					    new Object[] {priStr});
  logger.setLevel(pri);
} catch (Exception oops) {
  LogLog.error("Could not create level ["+priStr+
	       "]. Reported error follows.", oops);
  return;
}
     }
   }
   LogLog.debug(catName + " level set to " + logger.getLevel());    
 }