001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *     http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.commons.configuration.interpol;
018
019import java.lang.reflect.Field;
020import java.util.HashMap;
021import java.util.Map;
022
023import org.apache.commons.lang.ClassUtils;
024import org.apache.commons.lang.text.StrLookup;
025import org.apache.commons.logging.Log;
026import org.apache.commons.logging.LogFactory;
027
028/**
029 * <p>
030 * A specialized lookup implementation that allows access to constant fields of
031 * classes.
032 * </p>
033 * <p>
034 * Sometimes it is necessary in a configuration file to refer to a constant
035 * defined in a class. This can be done with this lookup implementation.
036 * Variable names passed in must be of the form
037 * {@code mypackage.MyClass.FIELD}. The {@code lookup()} method
038 * will split the passed in string at the last dot, separating the fully
039 * qualified class name and the name of the constant (i.e. <strong>static final</strong>)
040 * member field. Then the class is loaded and the field's value is obtained
041 * using reflection.
042 * </p>
043 * <p>
044 * Once retrieved values are cached for fast access. This class is thread-safe.
045 * It can be used as a standard (i.e. global) lookup object and serve multiple
046 * clients concurrently.
047 * </p>
048 *
049 * @version $Id: ConstantLookup.java 1210218 2011-12-04 20:57:48Z oheger $
050 * @since 1.4
051 * @author <a
052 * href="http://commons.apache.org/configuration/team-list.html">Commons
053 * Configuration team</a>
054 */
055public class ConstantLookup extends StrLookup
056{
057    /** Constant for the field separator. */
058    private static final char FIELD_SEPRATOR = '.';
059
060    /** An internally used cache for already retrieved values. */
061    private static Map<String, String> constantCache = new HashMap<String, String>();
062
063    /** The logger. */
064    private Log log = LogFactory.getLog(getClass());
065
066    /**
067     * Tries to resolve the specified variable. The passed in variable name is
068     * interpreted as the name of a <b>static final</b> member field of a
069     * class. If the value has already been obtained, it can be retrieved from
070     * an internal cache. Otherwise this method will invoke the
071     * {@code resolveField()} method and pass in the name of the class
072     * and the field.
073     *
074     * @param var the name of the variable to be resolved
075     * @return the value of this variable or <b>null</b> if it cannot be
076     * resolved
077     */
078    @Override
079    public String lookup(String var)
080    {
081        if (var == null)
082        {
083            return null;
084        }
085
086        String result;
087        synchronized (constantCache)
088        {
089            result = constantCache.get(var);
090        }
091        if (result != null)
092        {
093            return result;
094        }
095
096        int fieldPos = var.lastIndexOf(FIELD_SEPRATOR);
097        if (fieldPos < 0)
098        {
099            return null;
100        }
101        try
102        {
103            Object value = resolveField(var.substring(0, fieldPos), var
104                    .substring(fieldPos + 1));
105            if (value != null)
106            {
107                synchronized (constantCache)
108                {
109                    // In worst case, the value will be fetched multiple times
110                    // because of this lax synchronisation, but for constant
111                    // values this shouldn't be a problem.
112                    constantCache.put(var, String.valueOf(value));
113                }
114                result = value.toString();
115            }
116        }
117        catch (Exception ex)
118        {
119            log.warn("Could not obtain value for variable " + var, ex);
120        }
121
122        return result;
123    }
124
125    /**
126     * Clears the shared cache with the so far resolved constants.
127     */
128    public static void clear()
129    {
130        synchronized (constantCache)
131        {
132            constantCache.clear();
133        }
134    }
135
136    /**
137     * Determines the value of the specified constant member field of a class.
138     * This implementation will call {@code fetchClass()} to obtain the
139     * {@code java.lang.Class} object for the target class. Then it will
140     * use reflection to obtain the field's value. For this to work the field
141     * must be accessable.
142     *
143     * @param className the name of the class
144     * @param fieldName the name of the member field of that class to read
145     * @return the field's value
146     * @throws Exception if an error occurs
147     */
148    protected Object resolveField(String className, String fieldName)
149            throws Exception
150    {
151        Class<?> clazz = fetchClass(className);
152        Field field = clazz.getField(fieldName);
153        return field.get(null);
154    }
155
156    /**
157     * Loads the class with the specified name. If an application has special
158     * needs regarding the class loaders to be used, it can hook in here. This
159     * implementation delegates to the {@code getClass()} method of
160     * Commons Lang's
161     * <code><a href="http://commons.apache.org/lang/api-release/org/apache/commons/lang/ClassUtils.html">
162     * ClassUtils</a></code>.
163     *
164     * @param className the name of the class to be loaded
165     * @return the corresponding class object
166     * @throws ClassNotFoundException if the class cannot be loaded
167     */
168    protected Class<?> fetchClass(String className) throws ClassNotFoundException
169    {
170        return ClassUtils.getClass(className);
171    }
172}