Java OptionHelper.instantiateByClassName方法代码示例

import ch.qos.logback.core.util.OptionHelper; //导入方法依赖的package包/类
/**
 * Attempt to create a converter using the information found in
 * 'converterMap'.
 *
 * @param kn
 * @return
 */
@SuppressWarnings("unchecked")
DynamicConverter<E> createConverter(SimpleKeywordNode kn) {
  String keyword = (String) kn.getValue();
  String converterClassStr = (String) converterMap.get(keyword);

  if (converterClassStr != null) {
    try {
      return (DynamicConverter) OptionHelper.instantiateByClassName(
              converterClassStr, DynamicConverter.class, context);
    } catch (Exception e) {
      addError("Failed to instantiate converter class [" + converterClassStr
              + "] for keyword ["+keyword+"]", e);
      return null;
    }
  } else {
    addError("There is no conversion class registered for conversion word ["
            + keyword + "]");
    return null;
  }
}
 

import ch.qos.logback.core.util.OptionHelper; //导入方法依赖的package包/类
/**
 * Attempt to create a converter using the information found in
 * 'compositeConverterMap'.
 *
 * @param cn
 * @return
 */
@SuppressWarnings("unchecked")
CompositeConverter<E> createCompositeConverter(CompositeNode cn) {
  String keyword = (String) cn.getValue();
  String converterClassStr = (String) converterMap.get(keyword);

  if (converterClassStr != null) {
    try {
      return (CompositeConverter) OptionHelper.instantiateByClassName(
              converterClassStr, CompositeConverter.class, context);
    } catch (Exception e) {
      addError("Failed to instantiate converter class [" + converterClassStr
              + "] as a composite converter for keyword ["+keyword+"]", e);
      return null;
    }
  } else {
    addError("There is no conversion class registered for composite conversion word ["
            + keyword + "]");
    return null;
  }
}
 

import ch.qos.logback.core.util.OptionHelper; //导入方法依赖的package包/类
private static StatusListener createListenerPerClassName(KonkerLoggerContext loggerContext,
                                                         String listenerClass) {
    try {
        return (StatusListener)OptionHelper.instantiateByClassName(listenerClass, StatusListener.class, loggerContext);
    } catch (Exception var3) {
        var3.printStackTrace();
        return null;
    }
}
 

import ch.qos.logback.core.util.OptionHelper; //导入方法依赖的package包/类
public void begin(InterpretationContext ec, String name, Attributes attributes) throws ActionException {
  inError = false;
  String className = attributes.getValue(CLASS_ATTRIBUTE);
  if (OptionHelper.isEmpty(className)) {
    addError("Missing class name for statusListener. Near ["
            + name + "] line " + getLineNumber(ec));
    inError = true;
    return;
  }

  try {
    statusListener = (StatusListener) OptionHelper.instantiateByClassName(
            className, StatusListener.class, context);
    ec.getContext().getStatusManager().add(statusListener);
    if (statusListener instanceof ContextAware) {
      ((ContextAware) statusListener).setContext(context);
    }
    addInfo("Added status listener of type [" + className + "]");
    ec.pushObject(statusListener);
  } catch (Exception e) {
    inError = true;
    addError(
            "Could not create an StatusListener of type [" + className + "].", e);
    throw new ActionException(e);
  }

}
 

import ch.qos.logback.core.util.OptionHelper; //导入方法依赖的package包/类
/**
 * Instantiates a shutdown hook of the given class and sets its name.
 * 
 * The hook thus generated is placed in the {@link InterpretationContext}'s
 * shutdown hook bag.
 */
@Override
public void begin(InterpretationContext ic, String name, Attributes attributes) throws ActionException {    
  hook = null;
  inError = false;
  
  String className = attributes.getValue(CLASS_ATTRIBUTE);
  if (OptionHelper.isEmpty(className)) {
    addError("Missing class name for shutdown hook. Near [" + name
        + "] line " + getLineNumber(ic));
    inError = true;
    return;
  }
    
  try {
    addInfo("About to instantiate shutdown hook of type [" + className + "]");

    hook = (ShutdownHookBase) OptionHelper.instantiateByClassName(className,
        ShutdownHookBase.class, context);
    hook.setContext(context);
        
    ic.pushObject(hook);
  }catch (Exception e) {
    inError = true;
    addError("Could not create a shutdown hook of type [" + className + "].", e);
    throw new ActionException(e);
  }
}
 

import ch.qos.logback.core.util.OptionHelper; //导入方法依赖的package包/类
@Override
public void begin(InterpretationContext ic, String name,
    Attributes attributes) throws ActionException {
  
  String className = attributes.getValue(CLASS_ATTRIBUTE);
  if (OptionHelper.isEmpty(className)) {
    addError("Missing class name for receiver. Near [" + name
        + "] line " + getLineNumber(ic));
    inError = true;
    return;
  }

  try {
    addInfo("About to instantiate receiver of type [" + className + "]");

    receiver = (ReceiverBase) OptionHelper.instantiateByClassName(
        className, ReceiverBase.class, context);
    receiver.setContext(context);
    
    ic.pushObject(receiver);
  }
  catch (Exception ex) {
    inError = true;
    addError("Could not create a receiver of type [" + className + "].", ex);
    throw new ActionException(ex);
  }
}
 

import ch.qos.logback.core.util.OptionHelper; //导入方法依赖的package包/类
@Override
public void begin(InterpretationContext ec, String name, Attributes attributes)
        throws ActionException {

  inError = false;

  String className = attributes.getValue(CLASS_ATTRIBUTE);
  if (OptionHelper.isEmpty(className)) {
    addError("Mandatory \"" + CLASS_ATTRIBUTE
            + "\" attribute not set for <loggerContextListener> element");
    inError = true;
    return;
  }

  try {
    lcl = (LoggerContextListener) OptionHelper.instantiateByClassName(
            className, LoggerContextListener.class, context);

    if(lcl instanceof ContextAware) {
      ((ContextAware) lcl).setContext(context);
    }

    ec.pushObject(lcl);
    addInfo("Adding LoggerContextListener of type [" + className
            + "] to the object stack");

  } catch (Exception oops) {
    inError = true;
    addError("Could not create LoggerContextListener of type " + className + "].", oops);
  }
}
 

import ch.qos.logback.core.util.OptionHelper; //导入方法依赖的package包/类
private static StatusListener createListenerPerClassName(LoggerContext loggerContext, String listenerClass) {
  try {
    return (StatusListener) OptionHelper.instantiateByClassName(
            listenerClass, StatusListener.class, loggerContext);
  } catch (Exception e) {
    // printing on the console is the best we can do
    e.printStackTrace();
    return null;
  }
}
 

import ch.qos.logback.core.util.OptionHelper; //导入方法依赖的package包/类
/**
 * Instantiates an evaluator of the given class and sets its name.
 */
public void begin(InterpretationContext ec, String name, Attributes attributes) {
  // Let us forget about previous errors (in this instance)
  inError = false;
  evaluator = null;

  String className = attributes.getValue(CLASS_ATTRIBUTE);
  if (OptionHelper.isEmpty(className)) {
    className = defaultClassName();
    addInfo("Assuming default evaluator class [" + className + "]");
  }

  if (OptionHelper.isEmpty(className)) {
    className = defaultClassName();
    inError = true;
    addError("Mandatory \"" + CLASS_ATTRIBUTE
        + "\" attribute not set for <evaluator>");
    return;
  }

  String evaluatorName = attributes.getValue(Action.NAME_ATTRIBUTE);
  if (OptionHelper.isEmpty(evaluatorName)) {
    inError = true;
    addError("Mandatory \"" + NAME_ATTRIBUTE
        + "\" attribute not set for <evaluator>");
    return;
  }
  try {
    evaluator = (EventEvaluator<?>) OptionHelper.instantiateByClassName(
        className, ch.qos.logback.core.boolex.EventEvaluator.class, context);

    evaluator.setContext(this.context);
    evaluator.setName(evaluatorName);

    ec.pushObject(evaluator);
    addInfo("Adding evaluator named [" + evaluatorName
        + "] to the object stack");

  } catch (Exception oops) {
    inError = true;
    addError("Could not create evaluator of type " + className + "].", oops);
  }
}
 

import ch.qos.logback.core.util.OptionHelper; //导入方法依赖的package包/类
/**
 * Instantiates an appender of the given class and sets its name.
 * 
 * The appender thus generated is placed in the {@link InterpretationContext}'s
 * appender bag.
 */
@SuppressWarnings("unchecked")
public void begin(InterpretationContext ec, String localName,
    Attributes attributes) throws ActionException {
  // We are just beginning, reset variables
  appender = null;
  inError = false;

  String className = attributes.getValue(CLASS_ATTRIBUTE);
  if (OptionHelper.isEmpty(className)) {
    addError("Missing class name for appender. Near [" + localName
        + "] line " + getLineNumber(ec));
    inError = true;
    return;
  }

  try {
    addInfo("About to instantiate appender of type [" + className + "]");

    appender = (Appender<E>) OptionHelper.instantiateByClassName(className,
        ch.qos.logback.core.Appender.class, context);

    appender.setContext(context);

    String appenderName = ec.subst(attributes.getValue(NAME_ATTRIBUTE));

    if (OptionHelper.isEmpty(appenderName)) {
      addWarn("No appender name given for appender of type " + className
          + "].");
    } else {
      appender.setName(appenderName);
      addInfo("Naming appender as [" + appenderName + "]");
    }

    // The execution context contains a bag which contains the appenders
    // created thus far.
    HashMap<String, Appender<E>> appenderBag = (HashMap<String, Appender<E>>) ec.getObjectMap().get(
        ActionConst.APPENDER_BAG);

    // add the appender just created to the appender bag.
    appenderBag.put(appenderName, appender);

    ec.pushObject(appender);
  } catch (Exception oops) {
    inError = true;
    addError("Could not create an Appender of type [" + className + "].",
        oops);
    throw new ActionException(oops);
  }
}
 

import ch.qos.logback.core.util.OptionHelper; //导入方法依赖的package包/类
/**
 * Instantiates an a data source and bind it to JNDI
 * Most of the required parameters are placed in the ec.substitutionProperties
 */
public void begin(
    InterpretationContext ec, String localName, Attributes attributes) {
  String dsClassName = ec.getProperty(DATA_SOURCE_CLASS);

  if (OptionHelper.isEmpty(dsClassName)) {
    addWarn("dsClassName is a required parameter");
    ec.addError("dsClassName is a required parameter");

    return;
  }

  String urlStr = ec.getProperty(URL);
  String userStr = ec.getProperty(USER);
  String passwordStr = ec.getProperty(PASSWORD);

  try {
    DataSource ds =
      (DataSource) OptionHelper.instantiateByClassName(dsClassName, DataSource.class, context);

    PropertySetter setter = new PropertySetter(ds);
    setter.setContext(context);

    if (!OptionHelper.isEmpty(urlStr)) {
      setter.setProperty("url", urlStr);
    }

    if (!OptionHelper.isEmpty(userStr)) {
      setter.setProperty("user", userStr);
    }

    if (!OptionHelper.isEmpty(passwordStr)) {
      setter.setProperty("password", passwordStr);
    }

    Context ctx = new InitialContext();
    ctx.rebind("dataSource", ds);
  } catch (Exception oops) {
    addError(
      "Could not bind  datasource. Reported error follows.", oops);
    ec.addError("Could not not bind  datasource of type [" + dsClassName + "].");
  }
}