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 * https://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 * Constructs a new instance.
63 */
64 public ConstantLookup() {
65 // empty
66 }
67
68 /**
69 * Loads the class with the specified name. If an application has special needs regarding the class loaders to be used,
70 * it can hook in here. This implementation delegates to the {@code getClass()} method of Commons Lang's
71 * <a href="https://commons.apache.org/lang/api-release/org/apache/commons/lang/ClassUtils.html">
72 * ClassUtils</a>.
73 *
74 * @param className the name of the class to be loaded
75 * @return the corresponding class object
76 * @throws ClassNotFoundException if the class cannot be loaded
77 */
78 protected Class<?> fetchClass(final String className) throws ClassNotFoundException {
79 return ClassUtils.getClass(className);
80 }
81
82 /**
83 * Looks up a variable. The passed in variable name is interpreted as the name of a <strong>static final</strong> member field of
84 * a class. If the value has already been obtained, it can be retrieved from an internal cache. Otherwise this method
85 * will invoke the {@code resolveField()} method and pass in the name of the class and the field.
86 *
87 * @param var the name of the variable to be resolved
88 * @return the value of this variable or <strong>null</strong> if it cannot be resolved
89 */
90 @Override
91 public Object lookup(final String var) {
92 if (var == null) {
93 return null;
94 }
95 return CACHE.computeIfAbsent(var, k -> {
96 final int fieldPos = var.lastIndexOf(FIELD_SEPRATOR);
97 if (fieldPos >= 0) {
98 try {
99 return resolveField(var.substring(0, fieldPos), var.substring(fieldPos + 1));
100 } catch (final Exception ex) {
101 log.warn("Could not obtain value for variable " + var, ex);
102 }
103 }
104 return null;
105 });
106 }
107
108 /**
109 * Determines the value of the specified constant member field of a class. This implementation will call
110 * {@code fetchClass()} to obtain the {@link Class} object for the target class. Then it will use reflection
111 * to obtain the field's value. For this to work the field must be accessible.
112 *
113 * @param className the name of the class
114 * @param fieldName the name of the member field of that class to read
115 * @return the field's value
116 * @throws Exception if an error occurs
117 */
118 protected Object resolveField(final String className, final String fieldName) throws Exception {
119 return fetchClass(className).getField(fieldName).get(null);
120 }
121 }