log4j的用法

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import org.apache.commons.configuration.CompositeConfiguration;
import org.apache.commons.configuration.Configuration;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.SystemConfiguration;
import org.apache.commons.configuration.XMLConfiguration;
import org.apache.commons.configuration.reloading.FileChangedReloadingStrategy;
import org.apache.log4j.Logger;

public class ClientConfig
{
  private static final String UDDI_CONFIG_FILENAME_PROPERTY = "uddi.client.xml";
  public static final String DEFAULT_UDDI_CONFIG = "META-INF/uddi.xml";
  private Logger log = Logger.getLogger(ClientConfig.class);
  private Configuration config = null;
  private Map<String, UDDINode> uddiNodes = null;
  private Map<String, UDDIClerk> uddiClerks = null;
  private Set<XRegistration> xBusinessRegistrations = null;
  private Set<XRegistration> xServiceBindingRegistrations = null;
  private String managerName = null;

  public ClientConfig(String configurationFile)
    throws ConfigurationException
  {
    loadConfiguration(configurationFile);
  }
  protected void loadManager() throws ConfigurationException {
    this.uddiNodes = readNodeConfig(this.config);
    this.uddiClerks = readClerkConfig(this.config, this.uddiNodes);
    this.xServiceBindingRegistrations = readXServiceBindingRegConfig(this.config, this.uddiClerks);
    this.xBusinessRegistrations = readXBusinessRegConfig(this.config, this.uddiClerks);
  }

  private void loadConfiguration(String configurationFile)
    throws ConfigurationException
  {
    CompositeConfiguration compositeConfig = new CompositeConfiguration();
    compositeConfig.addConfiguration(new SystemConfiguration());

    XMLConfiguration xmlConfig = null;
    if (configurationFile != null) {
      xmlConfig = new XMLConfiguration(configurationFile);
    } else {
      String filename = System.getProperty("uddi.client.xml");
      if (filename != null)
        xmlConfig = new XMLConfiguration(filename);
      else {
        xmlConfig = new XMLConfiguration("META-INF/uddi.xml");
      }
    }
    this.log.info("Reading UDDI Client properties file " + xmlConfig.getBasePath());
    long refreshDelay = xmlConfig.getLong("reloadDelay", 1000L);
    this.log.debug("Setting refreshDelay to " + refreshDelay);
    FileChangedReloadingStrategy fileChangedReloadingStrategy = new FileChangedReloadingStrategy();
    fileChangedReloadingStrategy.setRefreshDelay(refreshDelay);
    xmlConfig.setReloadingStrategy(fileChangedReloadingStrategy);
    compositeConfig.addConfiguration(xmlConfig);

    this.config = compositeConfig;
    loadManager();
  }

  private Map<String, UDDIClerk> readClerkConfig(Configuration config, Map<String, UDDINode> uddiNodes) throws ConfigurationException
  {
    this.managerName = config.getString("manager[@name]");
    Map clerks = new HashMap();
    if (config.containsKey("manager.clerks.clerk[@name]")) {
      String[] names = config.getStringArray("manager.clerks.clerk[@name]");

      this.log.debug("clerk names=" + names);
      for (int i = 0; i < names.length; i++) {
        UDDIClerk uddiClerk = new UDDIClerk();
        uddiClerk.setManagerName(this.managerName);
        uddiClerk.setName(config.getString("manager.clerks.clerk(" + i + ")[@name]"));
        String nodeRef = config.getString("manager.clerks.clerk(" + i + ")[@node]");
        if (!uddiNodes.containsKey(nodeRef)) throw new ConfigurationException("Could not find Node with name=" + nodeRef);
        UDDINode uddiNode = (UDDINode)uddiNodes.get(nodeRef);
        uddiClerk.setUDDINode(uddiNode);
        uddiClerk.setPublisher(config.getString("manager.clerks.clerk(" + i + ")[@publisher]"));
        uddiClerk.setPassword(config.getString("manager.clerks.clerk(" + i + ")[@password]"));
        String[] classes = config.getStringArray("manager.clerks.clerk(" + i + ").class");
        uddiClerk.setClassWithAnnotations(classes);
        clerks.put(names[i], uddiClerk);
      }
    }
    return clerks;
  }

  public boolean isRegisterOnStartup() {
    boolean isRegisterOnStartup = false;
    if (this.config.containsKey("manager.clerks[@registerOnStartup]")) {
      isRegisterOnStartup = this.config.getBoolean("manager.clerks[@registerOnStartup]");
    }
    return isRegisterOnStartup;
  }

  private Map<String, UDDINode> readNodeConfig(Configuration config) throws ConfigurationException
  {
    String[] names = config.getStringArray("manager.nodes.node.name");
    Map nodes = new HashMap();
    this.log.debug("node names=" + names);
    for (int i = 0; i < names.length; i++) {
      UDDINode uddiNode = new UDDINode();
      String nodeName = config.getString("manager.nodes.node(" + i + ").name");
      String[] propertyKeys = config.getStringArray("manager.nodes.node(" + i + ").properties.property[@name]");
      Properties properties = null;
      if ((propertyKeys != null) && (propertyKeys.length > 0)) {
        properties = new Properties();
        for (int p = 0; p < propertyKeys.length; p++) {
          String name = config.getString("manager.nodes.node(" + i + ").properties.property(" + p + ")[@name]");
          String value = config.getString("manager.nodes.node(" + i + ").properties.property(" + p + ")[@value]");
          this.log.debug("Property: name=" + name + " value=" + value);
          properties.put(name, value);
        }
        uddiNode.setProperties(properties);
      }
      uddiNode.setHomeJUDDI(config.getBoolean("manager.nodes.node(" + i + ")[@isHomeJUDDI]", false));
      uddiNode.setName(config.getString("manager.nodes.node(" + i + ").name"));
      uddiNode.setManagerName(config.getString("manager[@name]"));
      uddiNode.setDescription(config.getString("manager.nodes.node(" + i + ").description"));
      uddiNode.setProxyTransport(config.getString("manager.nodes.node(" + i + ").proxyTransport"));
      uddiNode.setInquiryUrl(TokenResolver.replaceTokens(config.getString("manager.nodes.node(" + i + ").inquiryUrl"), properties));
      uddiNode.setPublishUrl(TokenResolver.replaceTokens(config.getString("manager.nodes.node(" + i + ").publishUrl"), properties));
      uddiNode.setCustodyTransferUrl(TokenResolver.replaceTokens(config.getString("manager.nodes.node(" + i + ").custodyTransferUrl"), properties));
      uddiNode.setSecurityUrl(TokenResolver.replaceTokens(config.getString("manager.nodes.node(" + i + ").securityUrl"), properties));
      uddiNode.setSubscriptionUrl(TokenResolver.replaceTokens(config.getString("manager.nodes.node(" + i + ").subscriptionUrl"), properties));
      uddiNode.setSubscriptionListenerUrl(TokenResolver.replaceTokens(config.getString("manager.nodes.node(" + i + ").subscriptionListenerUrl"), properties));
      uddiNode.setJuddiApiUrl(TokenResolver.replaceTokens(config.getString("manager.nodes.node(" + i + ").juddiApiUrl"), properties));
      uddiNode.setFactoryInitial(config.getString("manager.nodes.node(" + i + ").javaNamingFactoryInitial"));
      uddiNode.setFactoryURLPkgs(config.getString("manager.nodes.node(" + i + ").javaNamingFactoryUrlPkgs"));
      uddiNode.setFactoryNamingProvider(TokenResolver.replaceTokens(config.getString("manager.nodes.node(" + i + ").javaNamingProviderUrl"), properties));
      nodes.put(nodeName, uddiNode);
    }
    return nodes;
  }

  private Set<XRegistration> readXBusinessRegConfig(Configuration config, Map<String, UDDIClerk> clerks) throws ConfigurationException
  {
    return readXRegConfig(config, clerks, "business");
  }

  private Set<XRegistration> readXServiceBindingRegConfig(Configuration config, Map<String, UDDIClerk> clerks) throws ConfigurationException
  {
    return readXRegConfig(config, clerks, "servicebinding");
  }

  private Set<XRegistration> readXRegConfig(Configuration config, Map<String, UDDIClerk> clerks, String entityType) throws ConfigurationException
  {
    String[] entityKeys = config.getStringArray("manager.clerks.xregister." + entityType + "[@entityKey]");
    Set xRegistrations = new HashSet();
    this.log.info("XRegistration " + entityKeys.length + " " + entityType + "Keys");
    for (int i = 0; i < entityKeys.length; i++) {
      XRegistration xRegistration = new XRegistration();
      xRegistration.setEntityKey(config.getString("manager.clerks.xregister." + entityType + "(" + i + ")[@entityKey]"));

      String fromClerkRef = config.getString("manager.clerks.xregister." + entityType + "(" + i + ")[@fromClerk]");
      if (!clerks.containsKey(fromClerkRef)) throw new ConfigurationException("Could not find fromClerk with name=" + fromClerkRef);
      UDDIClerk fromClerk = (UDDIClerk)clerks.get(fromClerkRef);
      xRegistration.setFromClerk(fromClerk);

      String toClerkRef = config.getString("manager.clerks.xregister." + entityType + "(" + i + ")[@toClerk]");
      if (!clerks.containsKey(toClerkRef)) throw new ConfigurationException("Could not find toClerk with name=" + toClerkRef);
      UDDIClerk toClerk = (UDDIClerk)clerks.get(toClerkRef);
      xRegistration.setToClerk(toClerk);
      this.log.info(xRegistration);

      xRegistrations.add(xRegistration);
    }
    return xRegistrations;
  }

  protected Map<String, UDDINode> getUDDINodes() {
    return this.uddiNodes;
  }

  public UDDINode getHomeNode() throws ConfigurationException {
    if (this.uddiNodes == null) throw new ConfigurationException("The juddi client configuration must contain at least one node element.");

    if (this.uddiNodes.values().size() == 1) return (UDDINode)this.uddiNodes.values().iterator().next();
    for (UDDINode uddiNode : this.uddiNodes.values()) {
      if (uddiNode.isHomeJUDDI()) {
        return uddiNode;
      }
    }
    throw new ConfigurationException("One of the node elements in the client configuration needs to a 'isHomeJUDDI=\"true\"' attribute.");
  }

  public UDDINode getUDDINode(String nodeName) throws ConfigurationException {
    if (!this.uddiNodes.containsKey(nodeName)) {
      throw new ConfigurationException("Node '" + nodeName + "' cannot be found in the config '" + getManagerName() + "'");
    }

    return (UDDINode)this.uddiNodes.get(nodeName);
  }

  public Map<String, UDDIClerk> getUDDIClerks() {
    return this.uddiClerks;
  }

  public Set<XRegistration> getXServiceBindingRegistrations() {
    return this.xServiceBindingRegistrations;
  }

  public Set<XRegistration> getXBusinessRegistrations() {
    return this.xBusinessRegistrations;
  }

  public Configuration getConfiguration() {
    return this.config;
  }

  public String getManagerName() {
    return this.managerName;
  }
}