Source code
Description: source: package: org.apache.commons.configuration2.interpol, class: ConstantLookup

    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 *     https://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.util.Map;
    020import java.util.concurrent.ConcurrentHashMap;
    021
    022import org.apache.commons.lang3.ClassUtils;
    023import org.apache.commons.logging.Log;
    024import org.apache.commons.logging.LogFactory;
    025
    026/**
    027 * <p>
    028 * Looks up constant fields in classes.
    029 * </p>
    030 * <p>
    031 * Variable names passed in must be of the form {@code mypackage.MyClass.FIELD}. The {@code lookup()} method will split
    032 * the passed in string at the last dot, separating the fully qualified class name and the name of the constant (i.e.
    033 * <strong>static final</strong>) member field. Then the class is loaded and the field's value is obtained using
    034 * reflection.
    035 * </p>
    036 * <p>
    037 * Once retrieved values are cached for fast access. This class is thread-safe. It can be used as a standard (i.e.
    038 * global) lookup object and serve multiple clients concurrently.
    039 * </p>
    040 *
    041 * @since 1.4
    042 */
    043public class ConstantLookup implements Lookup {
    044
    045    /** Constant for the field separator. */
    046    private static final char FIELD_SEPRATOR = '.';
    047
    048    /** Cache of field values. */
    049    private static final Map<String, Object> CACHE = new ConcurrentHashMap<>();
    050
    051    /**
    052     * Clears the shared cache with the so far resolved constants.
    053     */
    054    public static void clear() {
    055        CACHE.clear();
    056    }
    057
    058    /** The logger. */
    059    private final Log log = LogFactory.getLog(getClass());
    060
    061    /**
    062     * Constructs a new instance.
    063     */
    064    public ConstantLookup() {
    065        // empty
    066    }
    067
    068    /**
    069     * Loads the class with the specified name. If an application has special needs regarding the class loaders to be used,
    070     * it can hook in here. This implementation delegates to the {@code getClass()} method of Commons Lang's
    071     * <a href="https://commons.apache.org/lang/api-release/org/apache/commons/lang/ClassUtils.html">
    072     * ClassUtils</a>.
    073     *
    074     * @param className the name of the class to be loaded
    075     * @return the corresponding class object
    076     * @throws ClassNotFoundException if the class cannot be loaded
    077     */
    078    protected Class<?> fetchClass(final String className) throws ClassNotFoundException {
    079        return ClassUtils.getClass(className);
    080    }
    081
    082    /**
    083     * Looks up a variable. The passed in variable name is interpreted as the name of a <strong>static final</strong> member field of
    084     * a class. If the value has already been obtained, it can be retrieved from an internal cache. Otherwise this method
    085     * will invoke the {@code resolveField()} method and pass in the name of the class and the field.
    086     *
    087     * @param var the name of the variable to be resolved
    088     * @return the value of this variable or <strong>null</strong> if it cannot be resolved
    089     */
    090    @Override
    091    public Object lookup(final String var) {
    092        if (var == null) {
    093            return null;
    094        }
    095        return CACHE.computeIfAbsent(var, k -> {
    096            final int fieldPos = var.lastIndexOf(FIELD_SEPRATOR);
    097            if (fieldPos >= 0) {
    098                try {
    099                    return resolveField(var.substring(0, fieldPos), var.substring(fieldPos + 1));
    100                } catch (final Exception ex) {
    101                    log.warn("Could not obtain value for variable " + var, ex);
    102                }
    103            }
    104            return null;
    105        });
    106    }
    107
    108    /**
    109     * Determines the value of the specified constant member field of a class. This implementation will call
    110     * {@code fetchClass()} to obtain the {@link Class} object for the target class. Then it will use reflection
    111     * to obtain the field's value. For this to work the field must be accessible.
    112     *
    113     * @param className the name of the class
    114     * @param fieldName the name of the member field of that class to read
    115     * @return the field's value
    116     * @throws Exception if an error occurs
    117     */
    118    protected Object resolveField(final String className, final String fieldName) throws Exception {
    119        return fetchClass(className).getField(fieldName).get(null);
    120    }
    121}