ContextFactory.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:7k
源码类别:

网格计算

开发平台:

Java

  1. /*
  2.  * ContextFactory.java
  3.  *
  4.  * Licensed to the Apache Software Foundation (ASF) under one
  5.  * or more contributor license agreements.  See the NOTICE file
  6.  * distributed with this work for additional information
  7.  * regarding copyright ownership.  The ASF licenses this file
  8.  * to you under the Apache License, Version 2.0 (the
  9.  * "License"); you may not use this file except in compliance
  10.  * with the License.  You may obtain a copy of the License at
  11.  *
  12.  *     http://www.apache.org/licenses/LICENSE-2.0
  13.  *
  14.  * Unless required by applicable law or agreed to in writing, software
  15.  * distributed under the License is distributed on an "AS IS" BASIS,
  16.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17.  * See the License for the specific language governing permissions and
  18.  * limitations under the License.
  19.  */
  20. package org.apache.hadoop.metrics;
  21. import java.io.IOException;
  22. import java.io.InputStream;
  23. import java.util.HashMap;
  24. import java.util.Iterator;
  25. import java.util.Map;
  26. import java.util.Properties;
  27. import org.apache.hadoop.metrics.spi.AbstractMetricsContext;
  28. import org.apache.hadoop.metrics.spi.NullContext;
  29. /**
  30.  * Factory class for creating MetricsContext objects.  To obtain an instance
  31.  * of this class, use the static <code>getFactory()</code> method.
  32.  */
  33. public class ContextFactory {
  34.     
  35.   private static final String PROPERTIES_FILE = 
  36.     "/hadoop-metrics.properties";
  37.   private static final String CONTEXT_CLASS_SUFFIX =
  38.     ".class";
  39.   private static final String DEFAULT_CONTEXT_CLASSNAME =
  40.     "org.apache.hadoop.metrics.spi.NullContext";
  41.     
  42.   private static ContextFactory theFactory = null;
  43.     
  44.   private Map<String,Object> attributeMap = new HashMap<String,Object>();
  45.   private Map<String,MetricsContext> contextMap = 
  46.     new HashMap<String,MetricsContext>();
  47.     
  48.   // Used only when contexts, or the ContextFactory itself, cannot be
  49.   // created.
  50.   private static Map<String,MetricsContext> nullContextMap = 
  51.     new HashMap<String,MetricsContext>();
  52.     
  53.   /** Creates a new instance of ContextFactory */
  54.   protected ContextFactory() {
  55.   }
  56.     
  57.   /**
  58.    * Returns the value of the named attribute, or null if there is no 
  59.    * attribute of that name.
  60.    *
  61.    * @param attributeName the attribute name
  62.    * @return the attribute value
  63.    */
  64.   public Object getAttribute(String attributeName) {
  65.     return attributeMap.get(attributeName);
  66.   }
  67.     
  68.   /**
  69.    * Returns the names of all the factory's attributes.
  70.    * 
  71.    * @return the attribute names
  72.    */
  73.   public String[] getAttributeNames() {
  74.     String[] result = new String[attributeMap.size()];
  75.     int i = 0;
  76.     // for (String attributeName : attributeMap.keySet()) {
  77.     Iterator it = attributeMap.keySet().iterator();
  78.     while (it.hasNext()) {
  79.       result[i++] = (String) it.next();
  80.     }
  81.     return result;
  82.   }
  83.     
  84.   /**
  85.    * Sets the named factory attribute to the specified value, creating it
  86.    * if it did not already exist.  If the value is null, this is the same as
  87.    * calling removeAttribute.
  88.    *
  89.    * @param attributeName the attribute name
  90.    * @param value the new attribute value
  91.    */
  92.   public void setAttribute(String attributeName, Object value) {
  93.     attributeMap.put(attributeName, value);
  94.   }
  95.   /**
  96.    * Removes the named attribute if it exists.
  97.    *
  98.    * @param attributeName the attribute name
  99.    */
  100.   public void removeAttribute(String attributeName) {
  101.     attributeMap.remove(attributeName);
  102.   }
  103.     
  104.   /**
  105.    * Returns the named MetricsContext instance, constructing it if necessary 
  106.    * using the factory's current configuration attributes. <p/>
  107.    * 
  108.    * When constructing the instance, if the factory property 
  109.    * <i>contextName</i>.class</code> exists, 
  110.    * its value is taken to be the name of the class to instantiate.  Otherwise,
  111.    * the default is to create an instance of 
  112.    * <code>org.apache.hadoop.metrics.spi.NullContext</code>, which is a 
  113.    * dummy "no-op" context which will cause all metric data to be discarded.
  114.    * 
  115.    * @param contextName the name of the context
  116.    * @return the named MetricsContext
  117.    */
  118.   public synchronized MetricsContext getContext(String refName, String contextName)
  119.       throws IOException, ClassNotFoundException,
  120.              InstantiationException, IllegalAccessException {
  121.     MetricsContext metricsContext = contextMap.get(refName);
  122.     if (metricsContext == null) {
  123.       String classNameAttribute = refName + CONTEXT_CLASS_SUFFIX;
  124.       String className = (String) getAttribute(classNameAttribute);
  125.       if (className == null) {
  126.         className = DEFAULT_CONTEXT_CLASSNAME;
  127.       }
  128.       Class contextClass = Class.forName(className);
  129.       metricsContext = (MetricsContext) contextClass.newInstance();
  130.       metricsContext.init(contextName, this);
  131.       contextMap.put(contextName, metricsContext);
  132.     }
  133.     return metricsContext;
  134.   }
  135.   public synchronized MetricsContext getContext(String contextName)
  136.     throws IOException, ClassNotFoundException, InstantiationException,
  137.            IllegalAccessException {
  138.     return getContext(contextName, contextName);
  139.   }
  140.     
  141.   /**
  142.    * Returns a "null" context - one which does nothing.
  143.    */
  144.   public static synchronized MetricsContext getNullContext(String contextName) {
  145.     MetricsContext nullContext = nullContextMap.get(contextName);
  146.     if (nullContext == null) {
  147.       nullContext = new NullContext();
  148.       nullContextMap.put(contextName, nullContext);
  149.     }
  150.     return nullContext;
  151.   }
  152.     
  153.   /**
  154.    * Returns the singleton ContextFactory instance, constructing it if 
  155.    * necessary. <p/>
  156.    * 
  157.    * When the instance is constructed, this method checks if the file 
  158.    * <code>hadoop-metrics.properties</code> exists on the class path.  If it 
  159.    * exists, it must be in the format defined by java.util.Properties, and all 
  160.    * the properties in the file are set as attributes on the newly created
  161.    * ContextFactory instance.
  162.    *
  163.    * @return the singleton ContextFactory instance
  164.    */
  165.   public static synchronized ContextFactory getFactory() throws IOException {
  166.     if (theFactory == null) {
  167.       theFactory = new ContextFactory();
  168.       theFactory.setAttributes();
  169.     }
  170.     return theFactory;
  171.   }
  172.     
  173.   private void setAttributes() throws IOException {
  174.     InputStream is = getClass().getResourceAsStream(PROPERTIES_FILE);
  175.     if (is != null) {
  176.       Properties properties = new Properties();
  177.       properties.load(is);
  178.       //for (Object propertyNameObj : properties.keySet()) {
  179.       Iterator it = properties.keySet().iterator();
  180.       while (it.hasNext()) {
  181.         String propertyName = (String) it.next();
  182.         String propertyValue = properties.getProperty(propertyName);
  183.         setAttribute(propertyName, propertyValue);
  184.       }
  185.     }
  186.   }
  187.     
  188. }