    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 1842194 2018-09-27 22:24:23Z 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(final 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        final int fieldPos = var.lastIndexOf(FIELD_SEPRATOR);
    096        if (fieldPos < 0)
    097        {
    098            return null;
    099        }
    100        try
    101        {
    102            final 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 (final 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(final String className, final String fieldName)
    148            throws Exception
    149    {
    150        final Class<?> clazz = fetchClass(className);
    151        final 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(final String className) throws ClassNotFoundException
    168    {
    169        return ClassUtils.getClass(className);
    170    }
    171}