com.sun.faces.util.ReflectionUtils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of javax.faces Show documentation
This is the master POM file for Oracle's Implementation of the JSF 2.2 Specification.
There is a newer version: 2.4.0
/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package com.sun.faces.util;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.logging.Logger;
import java.util.logging.Level;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.beans.PropertyDescriptor;
import java.beans.Introspector;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import static java.beans.Introspector.getBeanInfo;
import java.beans.PropertyEditor;
import static java.beans.PropertyEditorManager.findEditor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;

/**
 * A set of utility methods to make working with
 * Classes and Reflection a little easier.
 */
public final class ReflectionUtils {

    private static final Logger LOGGER = FacesLogger.APPLICATION.getLogger();

    /**
     * Cache
     */
    private static final Map> REFLECTION_CACHE =
          new WeakHashMap<>();


    // ------------------------------------------------------------ Constructors


    private ReflectionUtils() { }


    // ---------------------------------------------------------- Public Methods
    
        
	/**
	 * Sets a collection of properties of a given object to the values associated with those properties.
	 * 
	 * In the map that represents these properties, each key represents the name of the property, with the value
	 * associated with that key being the value that is set for the property.
	 * 

	 * E.g. map entry key = foo, value = "bar", which "bar" an instance of String, will conceptually result in the
	 * following call: object.setFoo("string");
	 *
	 * 

	 * NOTE: This particular method assumes that there's a write method for each property in the map with the right
	 * type. No specific checking is done whether this is indeed the case.
	 *
	 * @param object
	 *            the object on which properties will be set
	 * @param propertiesToSet
	 *            the map containing properties and their values to be set on the object
	 */
	public static void setProperties(Object object, Map propertiesToSet) {

	  try {
			Map availableProperties = new HashMap<>();
			for (PropertyDescriptor propertyDescriptor : getBeanInfo(object.getClass()).getPropertyDescriptors()) {
				availableProperties.put(propertyDescriptor.getName(), propertyDescriptor);
			}

			for (Map.Entry propertyToSet : propertiesToSet.entrySet()) {
				availableProperties.get(propertyToSet.getKey()).getWriteMethod().invoke(object, propertyToSet.getValue());
			}

		} catch (IntrospectionException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
			throw new IllegalStateException(e);
		}
	}

	/**
	 * Sets a collection of properties of a given object to the (optionally coerced) values associated with those properties.
	 * 

	 * In the map that represents these properties, each key represents the name of the property, with the value
	 * associated with that key being the value that is set for the property.
	 * 

	 * E.g. map entry key = foo, value = "bar", which "bar" an instance of String, will conceptually result in the
	 * following call: object.setFoo("string");
	 *
	 * 

	 * NOTE 1: In case the value is a String, and the target type is not String, the standard property editor mechanism
	 * will be used to attempt a conversion.
	 *
	 * 

	 * Note 2: This method operates somewhat as the reverse of {@link Reflection#setProperties(Object, Map)}. Here only
	 * the available writable properties of the object are matched against the map with properties to set. Properties
	 * in the map for which there isn't a corresponding writable property on the object are ignored.
	 *
	 * 

	 * Following the above two notes, use this method when attempting to set properties on an object in a lenient best effort
	 * basis. Use {@link Reflection#setProperties(Object, Map)} when all properties need to be set with the exact type as the value
	 * appears in the map.
	 *
	 *
	 * @param object
	 *            the object on which properties will be set
	 * @param propertiesToSet
	 *            the map containing properties and their values to be set on the object
	 */
	public static void setPropertiesWithCoercion(Object object, Map propertiesToSet) {
		try {
			for (PropertyDescriptor property : getBeanInfo(object.getClass()).getPropertyDescriptors()) {
				Method setter = property.getWriteMethod();

				if (setter == null) {
					continue;
				}

				if (propertiesToSet.containsKey(property.getName())) {

					Object value = propertiesToSet.get(property.getName());
					if (value instanceof String && !property.getPropertyType().equals(String.class)) {

						// Try to convert Strings to the type expected by the converter

						PropertyEditor editor = findEditor(property.getPropertyType());
						editor.setAsText((String) value);
						value = editor.getValue();
					}

					property.getWriteMethod().invoke(object, value);
				}

			}
		} catch (Exception e) { // NOPMD
			throw new IllegalStateException(e);
		}
	}

	/**
	 * Finds a method based on the method name, amount of parameters and limited typing, if necessary prefixed with "get".
	 * 

	 * Note that this supports overloading, but a limited one. Given an actual parameter of type Long, this will select
	 * a method accepting Number when the choice is between Number and a non-compatible type like String. However,
	 * it will NOT select the best match if the choice is between Number and Long.
	 *
	 * @param base the object in which the method is to be found
	 * @param methodName name of the method to be found
	 * @param params the method parameters
	 * @return a method if one is found, null otherwise
	 */
	public static Method findMethod(Object base, String methodName, Object[] params) {

		List methods = new ArrayList<>();
		for (Method method : base.getClass().getMethods()) {
			if (method.getName().equals(methodName) && method.getParameterTypes().length == params.length) {
				methods.add(method);
			}
		}

		if (methods.size() == 1) {
			return methods.get(0);
		}

		if (methods.size() > 1) {
			// Overloaded methods were found. Try to get a match
			for (Method method : methods) {
				boolean match = true;
				Class[] candidateParams = method.getParameterTypes();
				for (int i = 0; i < params.length; i++) {
					if (!candidateParams[i].isInstance(params[i])) {
						match = false;
						break;
					}
				}

				// If all candidate parameters were expected and for none of them the actual
				// parameter was NOT an instance, we have a match
				if (match) {
					return method;
				}

				// Else, at least one parameter was not an instance
				// Go ahead a test then next methods
			}
		}

		return null;
	}

	/**
	 * Returns the Class instance associated with the class of the given string, using the context class
	 * loader and if that fails the defining class loader of the current class.
	 *
	 * @param className fully qualified class name of the class for which a Class instance needs to be created
	 * @return the Class object for the class with the given name.
	 * @throws IllegalStateException if the class cannot be found.
	 */
	public static Class toClass(String className) {
		try {
			return (Class.forName(className, true, Thread.currentThread().getContextClassLoader()));
		}
		catch (ClassNotFoundException e) {
			try {
				return Class.forName(className);
			}
			catch (Exception ignore) {
				ignore = null; // Just continue to IllegalStateException on original ClassNotFoundException.
			}

			throw new IllegalStateException(e);
		}
	}

	/**
	 * Creates an instance of a class with the given fully qualified class name.
	 *
	 * @param  The generic object type.
	 * @param className fully qualified class name of the class for which an instance needs to be created
	 * @return an instance of the class denoted by className
	 * @throws IllegalStateException if the class cannot be found
	 */
	@SuppressWarnings("unchecked")
	public static  T instance(String className) {
		return (T) instance(toClass(className));
	}

	/**
	 * Creates a new instance of the class represented by the given Class object
	 *
	 * @param  The generic object type.
	 * @param clazz the Class object for which an instance needs to be created
	 * @return an instance of the class as given by the clazz parameter
	 * @throws IllegalStateException if the class cannot be found, or cannot be instantiated or when a security manager prevents this operation
	 */
	public static  T instance(Class clazz) {
		try {
			return clazz.newInstance();
		} catch (InstantiationException | IllegalAccessException e) {
			throw new IllegalStateException(e);
		}
	}

    /**
     * 
Clears the cache for the specified ClassLoader.
     * This method MUST be called when ConfigureListener
     * .contextDestroyed() is called.
     * @param loader the ClassLoader whose associated cache
     *  should be cleared
     */
    public static synchronized void clearCache(ClassLoader loader) {

            REFLECTION_CACHE.remove(loader);

    }


    public static synchronized void initCache(ClassLoader loader) {

        if (REFLECTION_CACHE.get(loader) == null) {
            REFLECTION_CACHE.put(loader,
                                 new ConcurrentHashMap<>());
        }

    }


    /**
     * Returns the Constructor appropriate to the specified
     * Class and parameters.
     * @param clazz the Class of interest
     * @param params the parameters for the constructor of the provided Class
     * @return a Constructor that can be invoked with the specified parameters
     */
    public static Constructor lookupConstructor(
          Class clazz,
          Class... params) {

        ClassLoader loader = Util.getCurrentLoader(clazz);
        if (loader == null) {
            return null;
        }
        
        return getMetaData(loader, clazz).lookupConstructor(params);
        
    }
    
    /**
     * Returns the Method appropriate to the specified
     * Class, method name, and parameters.
     * @param clazz the Class of interest
     * @param methodName the name of the method
     * @param params the parameters for the specified method
     * @return a Method that can be invoked with the specified parameters
     */
    public static Method lookupMethod(
          Class clazz,
          String methodName,
          Class... params) {

        ClassLoader loader = Util.getCurrentLoader(clazz);
        if (loader == null) {
            return null;
        }        
        
        return getMetaData(loader, clazz).lookupMethod(methodName, params);
        
    }


    /**
     * Constructs a new object instance based off the
     * provided class name.
     * @param className the class of the object to instantiate
     * @return a new instances of said class
     * @throws InstantiationException if the class cannot be instantiated
     * @throws IllegalAccessException if there is a security violation
     */
    public static Object newInstance(String className)
    throws InstantiationException, IllegalAccessException {

        ClassLoader loader = Util.getCurrentLoader(null);
        if (loader == null) {
            return null;
        }

        return getMetaData(loader, className).lookupClass().newInstance();
        
    }


    /**
     * Obtain a Class instance based on the provided
     * String name.
     * @param className the class to look up
     * @return the Class corresponding to className
     */
    public static Class lookupClass(String className) {

        ClassLoader loader = Util.getCurrentLoader(null);
        if (loader == null) {
            return null;
        }

        return getMetaData(loader, className).lookupClass();
        
    }


    /**
     * @param className the fully qualified class name
     * @param propertyName a JavaBeans property name
     * @return a method suitable for setting a JavaBeans property, or
     *  null if the property doesn't exist or is readonly.
     */
    public static Method lookupWriteMethod(String className, String propertyName) {

        ClassLoader loader = Util.getCurrentLoader(null);
        if (loader == null) {
            return null;
        }

        return getMetaData(loader, className).lookupWriteMethod(propertyName);

    }


    /**
     * @param className the fully qualified class name
     * @param propertyName a JavaBeans property name
     * @return a method suitable for obtaining the value of a JavaBeans property,
     *  or null if the property doesn't exist or can't be read.
     */
    public static Method lookupReadMethod(String className, String propertyName) {


        ClassLoader loader = Util.getCurrentLoader(null);
        if (loader == null) {
            return null;
        }

        return getMetaData(loader, className).lookupReadMethod(propertyName);

    }


    // --------------------------------------------------------- Private Methods


    /**
     * Return the MetaData for the specified Class.
     * 
     * This will check the cache associated with the specified
     * ClassLoader.  If there is no cache hit, then a new
     * MetaData instance will be created and stored.
     * 
     * @param loader ClassLoader
     * @param clazz the Class of interest
     * @return a MetaData object for the specified Class
     */
    private static MetaData getMetaData(ClassLoader loader, Class clazz) {

        ConcurrentMap cache = REFLECTION_CACHE.get(loader);

        if (cache == null) {
            initCache(loader);
            cache = REFLECTION_CACHE.get(loader);
        }

        MetaData meta = cache.get(clazz.getName());
        if (meta == null) {
            meta = new MetaData(clazz);
            cache.put(clazz.getName(), meta);
        }
       
        return meta;

    }


    /**
     * 
Return the MetaData for the specified className.
     *
     * This will check the cache associated with the specified
     * ClassLoader.  If there is no cache hit, then a new
     * MetaData instance will be created and stored.
     *
     * @param loader ClassLoader
     * @param className the class of interest
     * @return a MetaData object for the specified Class
     */
    private static MetaData getMetaData(ClassLoader loader, String className) {

        ConcurrentMap cache = REFLECTION_CACHE.get(loader);

        if (cache == null) {
            initCache(loader);
            cache = REFLECTION_CACHE.get(loader);
        }

        MetaData meta = cache.get(className);
        if (meta == null) {
            try {
                Class clazz = Util.loadClass(className, cache);
                meta = new MetaData(clazz);
                cache.put(className, meta);
            } catch (ClassNotFoundException cnfe) {
                return null;
            }
        }

        return meta;
    }


    /**
     * 
MetaData contains lookup methods for Constructors and
     * Methods of a particular Class.
     */
    private static final class MetaData {


        Map constructors;
        Map> methods;
        Map> declaredMethods;
        Map propertyDescriptors;
        Class clazz;


    // ------------------------------------------------------------ Constructors


        /**
         * 
Constructs a new MetaData instance for the specified
         * class.
         * @param clazz class to construct a new MetaData instance from.
         */
        public MetaData(Class clazz) {

            String name;
            this.clazz = clazz;
            Constructor[] ctors = clazz.getConstructors();
            constructors = new HashMap<>(ctors.length, 1.0f);
            for (int i = 0, len = ctors.length; i < len; i++) {
                constructors.put(getKey(ctors[i].getParameterTypes()),
                                 ctors[i]);
            }
            Method[] meths = clazz.getMethods();
            methods = new HashMap<>(meths.length, 1.0f);
            for (int i = 0, len = meths.length; i < len; i++) {
                name = meths[i].getName();
                HashMap methodsMap = methods.get(name);
                if (methodsMap == null) {
                    methodsMap = new HashMap<>(4, 1.0f);
                    methods.put(name, methodsMap);
                }
                methodsMap.put(getKey(meths[i].getParameterTypes()), meths[i]);
            }
            
            meths = clazz.getDeclaredMethods();
            declaredMethods = new HashMap<>(meths.length, 1.0f);
            for (int i = 0, len = meths.length; i < len; i++) {
                name = meths[i].getName();
                HashMap declaredMethodsMap = declaredMethods.get(name);
                if (declaredMethodsMap == null) {
                    declaredMethodsMap = new HashMap<>(4, 1.0f);
                    declaredMethods.put(name, declaredMethodsMap);
                }
                declaredMethodsMap.put(getKey(meths[i].getParameterTypes()), meths[i]);
            }

            try {
                BeanInfo info = Introspector.getBeanInfo(clazz);
                PropertyDescriptor[] pds = info.getPropertyDescriptors();
                if (pds != null) {
                    if (propertyDescriptors == null) {
                        propertyDescriptors = new HashMap<>(pds.length, 1.0f);
                    }
                    for (PropertyDescriptor pd : pds) {
                        propertyDescriptors.put(pd.getName(), pd);
                    }
                }
            } catch (IntrospectionException ie) {
                if (LOGGER.isLoggable(Level.SEVERE)) {
                    LOGGER.log(Level.SEVERE,
                               ie.toString(),
                               ie);
                }
            }

        }


    // ---------------------------------------------------------- Public Methods


        /**
         * Looks up a Constructor based off the specified
         * params.
         * @param params constructor parameters
         * @return the Constructor appropriate to the specified 
         *  parameters or null
         */
        public Constructor lookupConstructor(Class... params) {

            return constructors.get(getKey(params));

        }


        /**
         * Looks up a Method based off the specified method
         * name and params.
         * @param name the name of the Method
         * @param params the Method parameters
         * @return the Method appropriate to the specified 
         *  name and parameters or null
         */
        public Method lookupMethod(String name, Class... params) {

            Map map = methods.get(name);
            Integer key = getKey(params);
            Method result = null;
            if ((null == map) || null == (result = map.get(key))) {
                map = declaredMethods.get(name);
                if (null != map) {
                    result = map.get(key);
                }
            }
            return result;

        }


        /**
         * Looks up the class for this MetaData instance.
         * @return the Class for this MetaData instance
         */
        public Class lookupClass() {

            return clazz;

        }


        /**
         * @param propName a JavaBeans property name
         * @return a method suitable for setting a JavaBeans property, or
         *  null if the property doesn't exist or is readonly.
         */
        public Method lookupWriteMethod(String propName) {

            if (propertyDescriptors == null) {
                return null;
            }

            PropertyDescriptor pd = propertyDescriptors.get(propName);
            if (pd != null) {
                return pd.getWriteMethod();
            }
            return null;

        }


        /**
         * @param propName a JavaBeans property name
         * @return a method suitable for obtaining the value of a JavaBeans property,
         *  or null if the property doesn't exist or can't be read.
         */
        public Method lookupReadMethod(String propName) {

            if (propertyDescriptors == null) {
                return null;
            }

            PropertyDescriptor pd = propertyDescriptors.get(propName);
            if (pd != null) {
                return pd.getReadMethod();
            }
            return null;

        }
        
    // --------------------------------------------------------- Private Methods


        /**
         * Return a hashcode of all the class parameters.
         * @param params the parameters to a Constructor or
         *  a Method instance
         * @return the result of Arrays.deepHashCode
         */
        private static Integer getKey(Class... params) {

            return Arrays.deepHashCode(params);

        }

    }

    
} // END ReflectionUtils