1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.configuration.interpol;
18
19 import java.lang.reflect.Field;
20 import java.util.HashMap;
21 import java.util.Map;
22
23 import org.apache.commons.lang.ClassUtils;
24 import org.apache.commons.lang.text.StrLookup;
25 import org.apache.commons.logging.Log;
26 import org.apache.commons.logging.LogFactory;
27
28 /***
29 * <p>
30 * A specialized lookup implementation that allows access to constant fields of
31 * classes.
32 * </p>
33 * <p>
34 * Sometimes it is necessary in a configuration file to refer to a constant
35 * defined in a class. This can be done with this lookup implementation.
36 * Variable names passed in must be of the form
37 * <code>mypackage.MyClass.FIELD</code>. The <code>lookup()</code> method
38 * will split the passed in string at the last dot, separating the fully
39 * qualified class name and the name of the constant (i.e. <strong>static final</strong>)
40 * member field. Then the class is loaded and the field's value is obtained
41 * using reflection.
42 * </p>
43 * <p>
44 * Once retrieved values are cached for fast access. This class is thread-safe.
45 * It can be used as a standard (i.e. global) lookup object and serve multiple
46 * clients concurrently.
47 * </p>
48 *
49 * @version $Id: ConstantLookup.java 588329 2007-10-25 20:01:31Z oheger $
50 * @since 1.4
51 * @author <a
52 * href="http://commons.apache.org/configuration/team-list.html">Commons
53 * Configuration team</a>
54 */
55 public class ConstantLookup extends StrLookup
56 {
57 /*** Constant for the field separator. */
58 private static final char FIELD_SEPRATOR = '.';
59
60 /*** An internally used cache for already retrieved values. */
61 private static Map constantCache = new HashMap();
62
63 /*** The logger. */
64 private Log log = LogFactory.getLog(getClass());
65
66 /***
67 * Tries to resolve the specified variable. The passed in variable name is
68 * interpreted as the name of a <b>static final</b> member field of a
69 * class. If the value has already been obtained, it can be retrieved from
70 * an internal cache. Otherwise this method will invoke the
71 * <code>resolveField()</code> method and pass in the name of the class
72 * and the field.
73 *
74 * @param var the name of the variable to be resolved
75 * @return the value of this variable or <b>null</b> if it cannot be
76 * resolved
77 */
78 public String lookup(String var)
79 {
80 if (var == null)
81 {
82 return null;
83 }
84
85 String result;
86 synchronized (constantCache)
87 {
88 result = (String) constantCache.get(var);
89 }
90 if (result != null)
91 {
92 return result;
93 }
94
95 int fieldPos = var.lastIndexOf(FIELD_SEPRATOR);
96 if (fieldPos < 0)
97 {
98 return null;
99 }
100 try
101 {
102 Object value = resolveField(var.substring(0, fieldPos), var
103 .substring(fieldPos + 1));
104 if (value != null)
105 {
106 synchronized (constantCache)
107 {
108
109
110
111 constantCache.put(var, String.valueOf(value));
112 }
113 result = value.toString();
114 }
115 }
116 catch (Exception ex)
117 {
118 log.warn("Could not obtain value for variable " + var, ex);
119 }
120
121 return result;
122 }
123
124 /***
125 * Clears the shared cache with the so far resolved constants.
126 */
127 public static void clear()
128 {
129 synchronized (constantCache)
130 {
131 constantCache.clear();
132 }
133 }
134
135 /***
136 * Determines the value of the specified constant member field of a class.
137 * This implementation will call <code>fetchClass()</code> to obtain the
138 * <code>java.lang.Class</code> object for the target class. Then it will
139 * use reflection to obtain the field's value. For this to work the field
140 * must be accessable.
141 *
142 * @param className the name of the class
143 * @param fieldName the name of the member field of that class to read
144 * @return the field's value
145 * @throws Exception if an error occurs
146 */
147 protected Object resolveField(String className, String fieldName)
148 throws Exception
149 {
150 Class clazz = fetchClass(className);
151 Field field = clazz.getField(fieldName);
152 return field.get(null);
153 }
154
155 /***
156 * Loads the class with the specified name. If an application has special
157 * needs regarding the class loaders to be used, it can hook in here. This
158 * implementation delegates to the <code>getClass()</code> method of
159 * Commons Lang's
160 * <code><a href="http://commons.apache.org/lang/api-release/org/apache/commons/lang/ClassUtils.html">
161 * ClassUtils</a></code>.
162 *
163 * @param className the name of the class to be loaded
164 * @return the corresponding class object
165 * @throws ClassNotFoundException if the class cannot be loaded
166 */
167 protected Class fetchClass(String className) throws ClassNotFoundException
168 {
169 return ClassUtils.getClass(className);
170 }
171 }