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.configuration2.interpol;
018
019import java.lang.reflect.Field;
020import java.util.HashMap;
021import java.util.Map;
022
023import org.apache.commons.lang3.ClassUtils;
024import org.apache.commons.logging.Log;
025import org.apache.commons.logging.LogFactory;
026
027/**
028 * <p>
029 * A specialized lookup implementation that allows access to constant fields of
030 * classes.
031 * </p>
032 * <p>
033 * Sometimes it is necessary in a configuration file to refer to a constant
034 * defined in a class. This can be done with this lookup implementation.
035 * Variable names passed in must be of the form
036 * {@code mypackage.MyClass.FIELD}. The {@code lookup()} method
037 * will split the passed in string at the last dot, separating the fully
038 * qualified class name and the name of the constant (i.e. <strong>static final</strong>)
039 * member field. Then the class is loaded and the field's value is obtained
040 * using reflection.
041 * </p>
042 * <p>
043 * Once retrieved values are cached for fast access. This class is thread-safe.
044 * It can be used as a standard (i.e. global) lookup object and serve multiple
045 * clients concurrently.
046 * </p>
047 *
048 * @version $Id: ConstantLookup.java 1790899 2017-04-10 21:56:46Z ggregory $
049 * @since 1.4
050 * @author <a
051 * href="http://commons.apache.org/configuration/team-list.html">Commons
052 * Configuration team</a>
053 */
054public class ConstantLookup implements Lookup
055{
056    /** Constant for the field separator. */
057    private static final char FIELD_SEPRATOR = '.';
058
059    /** An internally used cache for already retrieved values. */
060    private static Map<String, Object> constantCache = new HashMap<>();
061
062    /** The logger. */
063    private final Log log = LogFactory.getLog(getClass());
064
065    /**
066     * Tries to resolve the specified variable. The passed in variable name is
067     * interpreted as the name of a <b>static final</b> member field of a
068     * class. If the value has already been obtained, it can be retrieved from
069     * an internal cache. Otherwise this method will invoke the
070     * {@code resolveField()} method and pass in the name of the class
071     * and the field.
072     *
073     * @param var the name of the variable to be resolved
074     * @return the value of this variable or <b>null</b> if it cannot be
075     * resolved
076     */
077    @Override
078    public Object lookup(String var)
079    {
080        if (var == null)
081        {
082            return null;
083        }
084
085        Object result;
086        synchronized (constantCache)
087        {
088            result = constantCache.get(var);
089        }
090        if (result != null)
091        {
092            return result;
093        }
094
095        int fieldPos = var.lastIndexOf(FIELD_SEPRATOR);
096        if (fieldPos < 0)
097        {
098            return null;
099        }
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                    // In worst case, the value will be fetched multiple times
109                    // because of this lax synchronization, but for constant
110                    // values this shouldn't be a problem.
111                    constantCache.put(var, value);
112                }
113                result = value;
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()} to obtain the
138     * {@code java.lang.Class} 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()} 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}