org.apache.commons.configuration.interpol.ConstantLookup Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of phoenix-client
Phoenix Client
There is a newer version: 4.15.0-HBase-1.5
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.configuration.interpol;

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.lang.ClassUtils;
import org.apache.commons.lang.text.StrLookup;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * 
 * A specialized lookup implementation that allows access to constant fields of
 * classes.
 * 
 * 
 * Sometimes it is necessary in a configuration file to refer to a constant
 * defined in a class. This can be done with this lookup implementation.
 * Variable names passed in must be of the form
 * mypackage.MyClass.FIELD. The lookup() method
 * will split the passed in string at the last dot, separating the fully
 * qualified class name and the name of the constant (i.e. static final)
 * member field. Then the class is loaded and the field's value is obtained
 * using reflection.
 * 
 * 
 * Once retrieved values are cached for fast access. This class is thread-safe.
 * It can be used as a standard (i.e. global) lookup object and serve multiple
 * clients concurrently.
 * 
 *
 * @version $Id: ConstantLookup.java 588329 2007-10-25 20:01:31Z oheger $
 * @since 1.4
 * @author Commons
 * Configuration team
 */
public class ConstantLookup extends StrLookup
{
    /** Constant for the field separator. */
    private static final char FIELD_SEPRATOR = '.';

    /** An internally used cache for already retrieved values. */
    private static Map constantCache = new HashMap();

    /** The logger. */
    private Log log = LogFactory.getLog(getClass());

    /**
     * Tries to resolve the specified variable. The passed in variable name is
     * interpreted as the name of a static final member field of a
     * class. If the value has already been obtained, it can be retrieved from
     * an internal cache. Otherwise this method will invoke the
     * resolveField() method and pass in the name of the class
     * and the field.
     *
     * @param var the name of the variable to be resolved
     * @return the value of this variable or null if it cannot be
     * resolved
     */
    public String lookup(String var)
    {
        if (var == null)
        {
            return null;
        }

        String result;
        synchronized (constantCache)
        {
            result = (String) constantCache.get(var);
        }
        if (result != null)
        {
            return result;
        }

        int fieldPos = var.lastIndexOf(FIELD_SEPRATOR);
        if (fieldPos < 0)
        {
            return null;
        }
        try
        {
            Object value = resolveField(var.substring(0, fieldPos), var
                    .substring(fieldPos + 1));
            if (value != null)
            {
                synchronized (constantCache)
                {
                    // In worst case, the value will be fetched multiple times
                    // because of this lax synchronisation, but for constant
                    // values this shouldn't be a problem.
                    constantCache.put(var, String.valueOf(value));
                }
                result = value.toString();
            }
        }
        catch (Exception ex)
        {
            log.warn("Could not obtain value for variable " + var, ex);
        }

        return result;
    }

    /**
     * Clears the shared cache with the so far resolved constants.
     */
    public static void clear()
    {
        synchronized (constantCache)
        {
            constantCache.clear();
        }
    }

    /**
     * Determines the value of the specified constant member field of a class.
     * This implementation will call fetchClass() to obtain the
     * java.lang.Class object for the target class. Then it will
     * use reflection to obtain the field's value. For this to work the field
     * must be accessable.
     *
     * @param className the name of the class
     * @param fieldName the name of the member field of that class to read
     * @return the field's value
     * @throws Exception if an error occurs
     */
    protected Object resolveField(String className, String fieldName)
            throws Exception
    {
        Class clazz = fetchClass(className);
        Field field = clazz.getField(fieldName);
        return field.get(null);
    }

    /**
     * Loads the class with the specified name. If an application has special
     * needs regarding the class loaders to be used, it can hook in here. This
     * implementation delegates to the getClass() method of
     * Commons Lang's
     * 
     * ClassUtils.
     *
     * @param className the name of the class to be loaded
     * @return the corresponding class object
     * @throws ClassNotFoundException if the class cannot be loaded
     */
    protected Class fetchClass(String className) throws ClassNotFoundException
    {
        return ClassUtils.getClass(className);
    }
}