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.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 /** The logger. */ 052 private final Log log = LogFactory.getLog(getClass()); 053 054 /** 055 * Looks up a variable. The passed in variable name is interpreted as the name of a <b>static final</b> member field of 056 * a class. If the value has already been obtained, it can be retrieved from an internal cache. Otherwise this method 057 * will invoke the {@code resolveField()} method and pass in the name of the class and the field. 058 * 059 * @param var the name of the variable to be resolved 060 * @return the value of this variable or <b>null</b> if it cannot be resolved 061 */ 062 @Override 063 public Object lookup(final String var) { 064 if (var == null) { 065 return null; 066 } 067 return CACHE.computeIfAbsent(var, k -> { 068 final int fieldPos = var.lastIndexOf(FIELD_SEPRATOR); 069 if (fieldPos >= 0) { 070 try { 071 return resolveField(var.substring(0, fieldPos), var.substring(fieldPos + 1)); 072 } catch (final Exception ex) { 073 log.warn("Could not obtain value for variable " + var, ex); 074 } 075 } 076 return null; 077 }); 078 } 079 080 /** 081 * Clears the shared cache with the so far resolved constants. 082 */ 083 public static void clear() { 084 CACHE.clear(); 085 } 086 087 /** 088 * Determines the value of the specified constant member field of a class. This implementation will call 089 * {@code fetchClass()} to obtain the {@link Class} object for the target class. Then it will use reflection 090 * to obtain the field's value. For this to work the field must be accessible. 091 * 092 * @param className the name of the class 093 * @param fieldName the name of the member field of that class to read 094 * @return the field's value 095 * @throws Exception if an error occurs 096 */ 097 protected Object resolveField(final String className, final String fieldName) throws Exception { 098 return fetchClass(className).getField(fieldName).get(null); 099 } 100 101 /** 102 * Loads the class with the specified name. If an application has special needs regarding the class loaders to be used, 103 * it can hook in here. This implementation delegates to the {@code getClass()} method of Commons Lang's 104 * <code><a href="https://commons.apache.org/lang/api-release/org/apache/commons/lang/ClassUtils.html"> 105 * ClassUtils</a></code>. 106 * 107 * @param className the name of the class to be loaded 108 * @return the corresponding class object 109 * @throws ClassNotFoundException if the class cannot be loaded 110 */ 111 protected Class<?> fetchClass(final String className) throws ClassNotFoundException { 112 return ClassUtils.getClass(className); 113 } 114}