对配置文件的配置及解析是每个框架的基本且必不可少的部分，本文主要对Hadoop中的配置文件的解析类Configuration的基本结构及主要方法进行介绍。       Hadoop的配置文件的操作主要分为三个部分：配置的加载、属性读取和设置，本文将分别对其进行介绍。如下是Configuration的主要的成员属性：

/**    * 保存了所有的资源配置的来源信息，资源文件主要有以下几种形式: URL、String、Path、InputStream和Properties。   */ private ArrayList<Resource> resources = new ArrayList<Resource>();  /**   * 记录了配置文件中配置的final类型的属性名称，标记为final之后如果另外有同名的属性，那么该属性将不会被替换   */ private Set<String> finalParameters = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>());  /**   * 记录了配置初始化后更新过的属性，其键为更新的属性名，值为更新操作的来源   */ private Map<String, String[]> updatingResource;  /**   * 记录了所有的属性，包括系统初始化以及后续设置的属性   */ private Properties properties;  /**   * 记录了除了初始化之后手动调用set方法设置的属性   */ private Properties overlay;  /**   * 记录了过期的属性   */ private static AtomicReference<DeprecationContext> deprecationContext = new AtomicReference<DeprecationContext>(new DeprecationContext(null, defaultDeprecations)); 

1.配置的加载

       Configuration中的配置文件的信息主要保存在resources属性中，该属性是一个ArrayList<Resource>类型，如下是Resource的结构：

private static class Resource {     private final Object resource;     private final String name;          // 构造方法，get和set方法略   } 

这里的name表示资源文件的名称，resource则表示具体的资源，其用一个Object类型，但具体的类型如下：

• URL: 通过一个URL链接来进行读取；
• String: 从当前classpath下该字符串所指定的文件读取；
• Path: 以绝对路径指定的配置文件或者是使用url指定的配置；
• InputStream: 以流的形式指定的配置文件；
• Properties: 以属性配置类保存的配置信息。 除了可以通过上述方式进行配置的设置以外，Hadoop还设置了几个默认的配置文件：core-default.xml、core-site.xml和hadoop-site.xml，具体的读取代码如下：

  static {     // Add default resources     addDefaultResource("core-default.xml");     addDefaultResource("core-site.xml");      // print deprecation warning if hadoop-site.xml is found in classpath     ClassLoader cL = Thread.currentThread().getContextClassLoader();     if (cL == null) {       cL = Configuration.class.getClassLoader();     }     if (cL.getResource("hadoop-site.xml") != null) {       LOG.warn("DEPRECATED: hadoop-site.xml found in the classpath. " +           "Usage of hadoop-site.xml is deprecated. Instead use core-site.xml, "           + "mapred-site.xml and hdfs-site.xml to override properties of " +           "core-default.xml, mapred-default.xml and hdfs-default.xml " +           "respectively");       addDefaultResource("hadoop-site.xml");     }   } 

这里需要注意的是，Hadoop对配置文件的读取并不是在Configuration类初始化时进行的，而是在获取配置信息时再进行读取，再此之前，配置相关的信息都保存在resources属性中。如下是addDefaultResource(String)方法的代码：

  public static synchronized void addDefaultResource(String name) {     if(!defaultResources.contains(name)) {       defaultResources.add(name);       for(Configuration conf : REGISTRY.keySet()) {         if(conf.loadDefaults) {           conf.reloadConfiguration();         }       }     }   } 

       从上述代码可以看出，在添加配置文件时，其先检查默认配置文件中是否有该配置文件，如果不存在，则将其添加到defaultResources列表中，并且其会对Configuration配置项进行检查，如果其配置了加载默认配置文件，那么其就会对该配置中保存配置信息的properties和finalParameters进行清空，以此触发属性的重新加载。        在初始化时将相关配置信息添加到resources和defaultResources列表之后，配置文件中属性的读取是在客户端具体调用get*方法时进行的，以下是初始化配置信息的代码：

  protected synchronized Properties getProps() {     if (properties == null) {       properties = new Properties();       Map<String, String[]> backup =           new ConcurrentHashMap<String, String[]>(updatingResource);       loadResources(properties, resources, quietmode);        if (overlay != null) {         properties.putAll(overlay);         for (Map.Entry<Object,Object> item: overlay.entrySet()) {           String key = (String)item.getKey();           String[] source = backup.get(key);           if(source != null) {             updatingResource.put(key, source);           }         }       }     }     return properties;   } 

上述代码中，首先判断properties是否为空，为空则进行初始化，否则直接返回，这也就是前面为什么将properties和finalParameters进行清空之后能够触发属性的重新加载的原因。在初始化配置信息的时候首先对更新的资源过的资源进行备份，然后调用loadResources()方法加载配置文件的信息，加载完之后还会将用户调用set*方法设置的属性（保存在overlay中）添加到properties中，并且将用户设置的信息添加到updatingResource中。如下是loadResources()方法的具体代码：

  private void loadResources(Properties properties, ArrayList<Resource> resources, boolean quiet) {     if(loadDefaults) {       for (String resource : defaultResources) {         loadResource(properties, new Resource(resource), quiet);       }     }          for (int i = 0; i < resources.size(); i++) {       Resource ret = loadResource(properties, resources.get(i), quiet);       if (ret != null) {         resources.set(i, ret);       }     }   } 

loadResources是对所有的配置文件信息进行加载的方法，其主要包括两个部分：加载默认配置文件和加载资源文件。在加载配置文件时除了Properties和Resource属性之外，还有一个boolean类型的属性quiet，该属性表示是否以“安静”模式加载配置文件，即加载时是否打印加载日志。如下是通过loadResource()加载配置文件的具体代码：

  private Resource loadResource(Properties properties,                                 Resource wrapper, boolean quiet) {     String name = UNKNOWN_RESOURCE;     try {       Object resource = wrapper.getResource();       name = wrapper.getName();       XMLStreamReader2 reader = null;       boolean returnCachedProperties = false;        if (resource instanceof URL) {                  // an URL resource         reader = (XMLStreamReader2)parse((URL)resource);       } else if (resource instanceof String) {        // a CLASSPATH resource         URL url = getResource((String)resource);         reader = (XMLStreamReader2)parse(url);       } else if (resource instanceof Path) {          // a file resource         // Can't use FileSystem API or we get an infinite loop         // since FileSystem uses Configuration API.  Use java.io.File instead.         File file = new File(((Path)resource).toUri().getPath())           .getAbsoluteFile();         if (file.exists()) {           if (!quiet) {             LOG.debug("parsing File " + file);           }           reader = (XMLStreamReader2)parse(new BufferedInputStream(               new FileInputStream(file)), ((Path)resource).toString());         }       } else if (resource instanceof InputStream) {         reader = (XMLStreamReader2)parse((InputStream)resource, null);         returnCachedProperties = true;       } else if (resource instanceof Properties) {         overlay(properties, (Properties)resource);       }        if (reader == null) {         if (quiet) {           return null;         }         throw new RuntimeException(resource + " not found");       }       Properties toAddTo = properties;       if(returnCachedProperties) {         toAddTo = new Properties();       }       DeprecationContext deprecations = deprecationContext.get();        StringBuilder token = new StringBuilder();       String confName = null;       String confValue = null;       String confInclude = null;       boolean confFinal = false;       boolean fallbackAllowed = false;       boolean fallbackEntered = false;       boolean parseToken = false;       LinkedList<String> confSource = new LinkedList<String>();        while (reader.hasNext()) {         switch (reader.next()) {         case XMLStreamConstants.START_ELEMENT:           switch (reader.getLocalName()) {           case "property":             confName = null;             confValue = null;             confFinal = false;             confSource.clear();              // First test for short format configuration             int attrCount = reader.getAttributeCount();             for (int i = 0; i < attrCount; i++) {               String propertyAttr = reader.getAttributeLocalName(i);               if ("name".equals(propertyAttr)) {                 confName = StringInterner.weakIntern(                     reader.getAttributeValue(i));               } else if ("value".equals(propertyAttr)) {                 confValue = StringInterner.weakIntern(                     reader.getAttributeValue(i));               } else if ("final".equals(propertyAttr)) {                 confFinal = "true".equals(reader.getAttributeValue(i));               } else if ("source".equals(propertyAttr)) {                 confSource.add(StringInterner.weakIntern(                     reader.getAttributeValue(i)));               }             }             break;           case "name":           case "value":           case "final":           case "source":             parseToken = true;             token.setLength(0);             break;           case "include":             // Determine href for xi:include             confInclude = null;             attrCount = reader.getAttributeCount();             for (int i = 0; i < attrCount; i++) {               String attrName = reader.getAttributeLocalName(i);               if ("href".equals(attrName)) {                 confInclude = reader.getAttributeValue(i);               }             }             if (confInclude == null) {               break;             }             // Determine if the included resource is a classpath resource             // otherwise fallback to a file resource             // xi:include are treated as inline and retain current source             URL include = getResource(confInclude);             if (include != null) {               Resource classpathResource = new Resource(include, name);               loadResource(properties, classpathResource, quiet);             } else {               URL url;               try {                 url = new URL(confInclude);                 url.openConnection().connect();               } catch (IOException ioe) {                 File href = new File(confInclude);                 if (!href.isAbsolute()) {                   // Included resources are relative to the current resource                   File baseFile = new File(name).getParentFile();                   href = new File(baseFile, href.getPath());                 }                 if (!href.exists()) {                   // Resource errors are non-fatal iff there is 1 xi:fallback                   fallbackAllowed = true;                   break;                 }                 url = href.toURI().toURL();               }               Resource uriResource = new Resource(url, name);               loadResource(properties, uriResource, quiet);             }             break;           case "fallback":             fallbackEntered = true;             break;           case "configuration":             break;           default:             break;           }           break;          case XMLStreamConstants.CHARACTERS:           if (parseToken) {             char[] text = reader.getTextCharacters();             token.append(text, reader.getTextStart(), reader.getTextLength());           }           break;          case XMLStreamConstants.END_ELEMENT:           switch (reader.getLocalName()) {           case "name":             if (token.length() > 0) {               confName = StringInterner.weakIntern(token.toString().trim());             }             break;           case "value":             if (token.length() > 0) {               confValue = StringInterner.weakIntern(token.toString());             }             break;           case "final":             confFinal = "true".equals(token.toString());             break;           case "source":             confSource.add(StringInterner.weakIntern(token.toString()));             break;           case "include":             if (fallbackAllowed && !fallbackEntered) {               throw new IOException("Fetch fail on include for '"                   + confInclude + "' with no fallback while loading '"                   + name + "'");             }             fallbackAllowed = false;             fallbackEntered = false;             break;           case "property":             if (confName == null || (!fallbackAllowed && fallbackEntered)) {               break;             }             confSource.add(name);             DeprecatedKeyInfo keyInfo =                 deprecations.getDeprecatedKeyMap().get(confName);             if (keyInfo != null) {               keyInfo.clearAccessed();               for (String key : keyInfo.newKeys) {                 // update new keys with deprecated key's value                 loadProperty(toAddTo, name, key, confValue, confFinal,                     confSource.toArray(new String[confSource.size()]));               }             } else {               loadProperty(toAddTo, name, confName, confValue, confFinal,                   confSource.toArray(new String[confSource.size()]));             }             break;           default:             break;           }         default:           break;         }       }       reader.close();        if (returnCachedProperties) {         overlay(properties, toAddTo);         return new Resource(toAddTo, name);       }       return null;     } catch (IOException e) {       LOG.fatal("error parsing conf " + name, e);       throw new RuntimeException(e);     } catch (XMLStreamException e) {       LOG.fatal("error parsing conf " + name, e);       throw new RuntimeException(e);     }   } 

从代码中可以看出，在加载每个配置文件的时候，首先通过instanceof判断wrapper对象中Object类型的属性resource是什么类型，然后根据具体不同的类型将其转换为一个XMLStreamReader2类型的reader。对于转换之后的reader，其会依次读取xml配置文件中的具体标签信息，如：name、value、final、source等等，并且将读取后的信息保存在properties中，这里需要注意的是，在代码中的case "include"处可以看出，配置文件中如果使用了<include></include>标签引入其他的配置文件，那么其会递归的调用loadResource()方法对其进行读取。        在加载完配置

2.属性的获取

       Configuration类主要是通过get方法获取相关属性的，其get方法的种类有三十多个，如：get(String)、get(String, String)、getBoolean(String, Boolean)、getClass(String, Class<?>)等等，但是最终调用的还是get(String, String)方法，该方法的作用是获取一个某个名称对应的属性值，具体代码如下：

  public String get(String name, String defaultValue) {     // 处理过期的属性     String[] names = handleDeprecation(deprecationContext.get(), name);     String result = null;     // 对属性值中形如${foo.bar}引入的其他属性进行替换     for(String n : names) {       result = substituteVars(getProps().getProperty(n, defaultValue));     }     return result;   } 

通过上述代码可以看出，get(String, String)方法主要做了两件事：处理过期键和对属性值进行标签替换处理。根据前面的介绍我们知道deprecationContext是一个AtomicReference<DeprecationContext>类型的变量，其保存有过期键的相关信息，并且这里使用AtomicReference包装，也就是说其获取和更新都是原子化的。这里我们首先讲解一下DeprecationContext具体实现方式，如下是该类的代码：

  private static class DeprecationContext {     /**      * 保存有过期键信息，其值为主要是该过期键更新后的键的信息      */     private final Map<String, DeprecatedKeyInfo> deprecatedKeyMap;      /**      * 对于DeprecatedKeyInfo，其有一个String[] newKeys属性，即更新后的键信息，这里reverseDeprecatedKeyMap的      * 键为newKeys中的各个字符串，而值则对应于newKeys所在的DeprecatedKeyInfo对象在deprecatedKeyMap所属的键      */     private final Map<String, String> reverseDeprecatedKeyMap;      /**      * 根据另一个DeprecationContext对象实例化一个DeprecationContext对象，这里DeprecationDelta指的是除了DeprecationContext对象以外新增加的属性      */     @SuppressWarnings("unchecked")     DeprecationContext(DeprecationContext other, DeprecationDelta[] deltas) {       HashMap<String, DeprecatedKeyInfo> newDeprecatedKeyMap = new HashMap<String, DeprecatedKeyInfo>();       HashMap<String, String> newReverseDeprecatedKeyMap = new HashMap<String, String>();       if (other != null) {         for (Entry<String, DeprecatedKeyInfo> entry : other.deprecatedKeyMap.entrySet()) {           newDeprecatedKeyMap.put(entry.getKey(), entry.getValue());         }         for (Entry<String, String> entry : other.reverseDeprecatedKeyMap.entrySet()) {           newReverseDeprecatedKeyMap.put(entry.getKey(), entry.getValue());         }       }       for (DeprecationDelta delta : deltas) {         if (!newDeprecatedKeyMap.containsKey(delta.getKey())) {           DeprecatedKeyInfo newKeyInfo = new DeprecatedKeyInfo(delta.getNewKeys(), delta.getCustomMessage());           newDeprecatedKeyMap.put(delta.key, newKeyInfo);           // 从这里可以看出，reverseDeprecatedKeyMap中的键为更新之后的过期键信息，而值为最初的过期键           for (String newKey : delta.getNewKeys()) {             newReverseDeprecatedKeyMap.put(newKey, delta.key);           }         }       }       this.deprecatedKeyMap = UnmodifiableMap.decorate(newDeprecatedKeyMap);       this.reverseDeprecatedKeyMap = UnmodifiableMap.decorate(newReverseDeprecatedKeyMap);     }      Map<String, DeprecatedKeyInfo> getDeprecatedKeyMap() {       return deprecatedKeyMap;     }      Map<String, String> getReverseDeprecatedKeyMap() {       return reverseDeprecatedKeyMap;     }   } 

        DeprecationContext中主要有两个属性：deprecatedKeyMap和reverseDeprecatedKeyMap。对于deprecatedKeyMap，其键是过期的键，而值则主要保存该键被替换之后的新键的信息；对于reverseDeprecatedKeyMap，其键为某个过期键更新之后的键，而值则了被更新的过期键。         在介绍了DeprecationContext的具体结构之后，我们继续来看get(String, String)方法中handleDeprecation()方法的具体处理方式，以下是该方法的具体代码：

  private String[] handleDeprecation(DeprecationContext deprecations, String name) {     if (null != name) {       name = name.trim();     }     // 默认使用目标name作为返回值     String[] names = new String[]{name};     // 查询当前name所对应的过期键信息，并且获取其更新后的信息     DeprecatedKeyInfo keyInfo = deprecations.getDeprecatedKeyMap().get(name);     if (keyInfo != null) {       if (!keyInfo.getAndSetAccessed()) {         logDeprecation(keyInfo.getWarningMessage(name));       }       // 将当前过期键更新后的名称返回       names = keyInfo.newKeys;     }     // 如果没用通过set*方法设置的属性，那么直接返回     Properties overlayProperties = getOverlay();     if (overlayProperties.isEmpty()) {       return names;     }      // 查找当前name在DeprecatedKeyInfo中对应的最新的keys，如果某个key的属性在overlay（用户设置的key-value）中存在，那么就将该key对应的     // 值更新该key的值为所更新的过期键的值     for (String n : names) {       String deprecatedKey = deprecations.getReverseDeprecatedKeyMap().get(n);  // 查找当前name是否在更新后的key中存在       if (deprecatedKey != null && overlayProperties.containsKey(n)) {  // 当前name在DeprecatedKeyInfo更新后的名字中存在，且在overlayProperties中也存在当前name的键         String deprecatedValue = overlayProperties.getProperty(deprecatedKey);         if (deprecatedValue != null) {           getProps().setProperty(n, deprecatedValue); // 将DeprecatedKeyInfo中新的键与旧的键所对应的值关联起来，保存在properties和overlay中           overlayProperties.setProperty(n, deprecatedValue);         }       }     }     return names;   } 

       总结来说，在handleDeprecation()方法中，其会查询当前的name是否是过期键，如果不是，则将当前name组装为一个数组返回，如果是，则通过该过期键获取其所对应的更新之后的键，并将其作为返回值。除此之外，其还会在调用者设置的属性(overlayProperties)中查询其是否保存有当前过期键所更新的键名的信息，如果有，则将其更新为该过期键所对应的值。        接下来我们回头看看get(String, String)方法，在通过handleDeprecation()方法获取到该name的相关信息之后，这里主要调用了substituteVars()方法，该方法的主要作用为对获取到的属性值中的占位符如${foo.bar}进行替换，这里getProps()方法即为前面所讲解的通过配置文件初始化相关属性的方法。以下是substituteVars()的具体实现：

  private String substituteVars(String expr) {     if (expr == null) {       return null;     }     String eval = expr;     for(int s = 0; s < MAX_SUBST; s++) {       // 返回值为长度为2的数组，该方法获取属性值中最内层占位符的起始和终止索引，如${prefix${foo.bar}suffix}将返回foo.bar的起始和终止索引       final int[] varBounds = findSubVariable(eval);       if (varBounds[SUB_START_IDX] == -1) {         return eval;       }       final String var = eval.substring(varBounds[SUB_START_IDX], varBounds[SUB_END_IDX]);       String val = null;       try {         // 判断是否为系统属性，系统属性以env.开头         if (var.startsWith("env.") && 4 < var.length()) {           String v = var.substring(4);           int i = 0;           for (; i < v.length(); i++) {             char c = v.charAt(i);             if (c == ':' && i < v.length() - 1 && v.charAt(i + 1) == '-') {               val = getenv(v.substring(0, i));               if (val == null || val.length() == 0) {                 val = v.substring(i + 2);               }               break;             } else if (c == '-') {               val = getenv(v.substring(0, i));               if (val == null) {                 val = v.substring(i + 1);               }               break;             }           }           if (i == v.length()) {             // i == v.length()说明为系统属性，那么返回值为系统属性             val = getenv(v);           }         } else {           // 如果不为系统属性，则从当前上下文环境中获取该属性           val = getProperty(var);         }       } catch(SecurityException se) {         LOG.warn("Unexpected SecurityException in Configuration", se);       }       if (val == null) {         // 如果既不是系统属性也不是环境属性，则在配置文件或者是用户设置的属性中查找         val = getRaw(var);       }       if (val == null) {         // val为null，说明该属性没有定义，则直接返回原始值         return eval;       }        final int dollar = varBounds[SUB_START_IDX] - "${".length();       final int afterRightBrace = varBounds[SUB_END_IDX] + "}".length();  // 因为这里SUB_END_INDEX实际上指向的就是"{"       final String refVar = eval.substring(dollar, afterRightBrace);        // 这里refVar即为要替换的占位符，如${foo.bar}，走到这一步说明foo.bar有对应的属性值，即val，这里判断val中是否继续包含       // 有${foo.bar}，如果有，则说明发生了嵌套占位，这种情况直接返回原始字符串，否则会发生无限循环       if (val.contains(refVar)) {         return expr;       }        eval = eval.substring(0, dollar) + val + eval.substring(afterRightBrace);     }     throw new IllegalStateException("Variable substitution depth too large: " + MAX_SUBST + " " + expr);   } 

       总结而言，substituteVars()方法主要对属性值中的占位符进行替换，对于属性值的获取，其可以通过三个途径进行：系统变量、当前环境变量和配置文件及用户设置的属性值，并且其优先级是：系统变量 > 当前环境变量 > 配置文件及用户设置的属性值。除此之外，该方法还会处理嵌套占位符，如${prefix${foo.bar}suffix}，其是由内而外进行解析，直到不存在占位符，或者是进行解析的层数超过了20层（最外层的for循环控制，这里MAX_SUBST为20）。

3.属性设置

       相对而言，属性的设置要简单一些，和get方法类似，虽然set方法也有很多，但其最终还是调用的set(String, String, String)方法，其第一个和第二个参数为要设置的键值对，第三个参数则为当前属性值的来源。如下是该方法的具体实现：

  public void set(String name, String value, String source) {     Preconditions.checkArgument(name != null, "Property name must not be null");     Preconditions.checkArgument(value != null, "The value of property %s must not be null", name);     name = name.trim();     DeprecationContext deprecations = deprecationContext.get();     if (deprecations.getDeprecatedKeyMap().isEmpty()) {       // 初始化配置文件信息       getProps();     }     getOverlay().setProperty(name, value);     getProps().setProperty(name, value);     String newSource = (source == null ? "programmatically" : source);      if (!isDeprecated(name)) {       // 这里该name不是过期键分为两种情况，一种是在存储过期键的map（即deprecatedKeyMap）中没有相应数据，       // 而在更新的map（即reverseDeprecatedKeyMap）中有数据，第二种是在这两个map中都没有数据       updatingResource.put(name, new String[] {newSource});       // 判断该键是否为更新某一个过期键之后的键，如果是，则获取所有更新了该过期键的键       String[] altNames = getAlternativeNames(name);       if(altNames != null) {         // 更新所有该键所对应的过期键更新之后的键值         for(String n: altNames) {           if(!n.equals(name)) {             getOverlay().setProperty(n, value);             getProps().setProperty(n, value);             updatingResource.put(n, new String[] {newSource});           }         }       }     } else {       // 如果该键为过期键，则将该过期键更新之后的键的值都设置为新的值       String[] names = handleDeprecation(deprecationContext.get(), name);       String altSource = "because " + name + " is deprecated";       for(String n : names) {         getOverlay().setProperty(n, value);         getProps().setProperty(n, value);         updatingResource.put(n, new String[] {altSource});       }     }   } 

       对于set(String, String, String)方法，其不仅更新了当前键值对的属性，而且还判断了该键是否为过期键或者是更新过期键之后的键，如果是则将更新之后的键所对应的值都设置为新值。