View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *     http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.configuration2.interpol;
18  
19  import java.util.Map;
20  import java.util.concurrent.ConcurrentHashMap;
21  
22  import org.apache.commons.lang3.ClassUtils;
23  import org.apache.commons.logging.Log;
24  import org.apache.commons.logging.LogFactory;
25  
26  /**
27   * <p>
28   * Looks up constant fields in classes.
29   * </p>
30   * <p>
31   * Variable names passed in must be of the form {@code mypackage.MyClass.FIELD}. The {@code lookup()} method will split
32   * the passed in string at the last dot, separating the fully qualified class name and the name of the constant (i.e.
33   * <strong>static final</strong>) member field. Then the class is loaded and the field's value is obtained using
34   * reflection.
35   * </p>
36   * <p>
37   * Once retrieved values are cached for fast access. This class is thread-safe. It can be used as a standard (i.e.
38   * global) lookup object and serve multiple clients concurrently.
39   * </p>
40   *
41   * @since 1.4
42   */
43  public class ConstantLookup implements Lookup {
44  
45      /** Constant for the field separator. */
46      private static final char FIELD_SEPRATOR = '.';
47  
48      /** Cache of field values. */
49      private static final Map<String, Object> CACHE = new ConcurrentHashMap<>();
50  
51      /**
52       * Clears the shared cache with the so far resolved constants.
53       */
54      public static void clear() {
55          CACHE.clear();
56      }
57  
58      /** The logger. */
59      private final Log log = LogFactory.getLog(getClass());
60  
61      /**
62       * Loads the class with the specified name. If an application has special needs regarding the class loaders to be used,
63       * it can hook in here. This implementation delegates to the {@code getClass()} method of Commons Lang's
64       * <a href="https://commons.apache.org/lang/api-release/org/apache/commons/lang/ClassUtils.html">
65       * ClassUtils</a>.
66       *
67       * @param className the name of the class to be loaded
68       * @return the corresponding class object
69       * @throws ClassNotFoundException if the class cannot be loaded
70       */
71      protected Class<?> fetchClass(final String className) throws ClassNotFoundException {
72          return ClassUtils.getClass(className);
73      }
74  
75      /**
76       * Looks up a variable. The passed in variable name is interpreted as the name of a <strong>static final</strong> member field of
77       * a class. If the value has already been obtained, it can be retrieved from an internal cache. Otherwise this method
78       * will invoke the {@code resolveField()} method and pass in the name of the class and the field.
79       *
80       * @param var the name of the variable to be resolved
81       * @return the value of this variable or <strong>null</strong> if it cannot be resolved
82       */
83      @Override
84      public Object lookup(final String var) {
85          if (var == null) {
86              return null;
87          }
88          return CACHE.computeIfAbsent(var, k -> {
89              final int fieldPos = var.lastIndexOf(FIELD_SEPRATOR);
90              if (fieldPos >= 0) {
91                  try {
92                      return resolveField(var.substring(0, fieldPos), var.substring(fieldPos + 1));
93                  } catch (final Exception ex) {
94                      log.warn("Could not obtain value for variable " + var, ex);
95                  }
96              }
97              return null;
98          });
99      }
100 
101     /**
102      * Determines the value of the specified constant member field of a class. This implementation will call
103      * {@code fetchClass()} to obtain the {@link Class} object for the target class. Then it will use reflection
104      * to obtain the field's value. For this to work the field must be accessible.
105      *
106      * @param className the name of the class
107      * @param fieldName the name of the member field of that class to read
108      * @return the field's value
109      * @throws Exception if an error occurs
110      */
111     protected Object resolveField(final String className, final String fieldName) throws Exception {
112         return fetchClass(className).getField(fieldName).get(null);
113     }
114 }