reflectionutils.java

lucene2.2.0版本

/**
 * 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.lucene.gdata.utils;

import java.lang.reflect.Constructor;

/**
 * A collection of static helper methods solve common reflection problems
 * 
 * @author Simon Willnauer
 * 
 */
public class ReflectionUtils {

    /**
     * Check if the given type implements a given super type
     * @param typeToCheck - type supposed to implement an interface
     * @param superType - the interface to be implemented by the type to check
     * @return <code>true</code> if and only if the super type is above in the type hierarchy of the given type, otherwise <code>false</code>
     */
    public static boolean implementsType(Class typeToCheck, Class superType) {
        if(superType == null)
            return false;
        if(!superType.isInterface())
            return  false;
        if (typeToCheck == null)
            return false;
        if (typeToCheck.equals(Object.class))
            return false;
        if (typeToCheck.equals(superType))
            return true;
        Class[] interfaces = typeToCheck.getInterfaces();
        for (int i = 0; i < interfaces.length; i++) {
            if (implementsType(interfaces[i], superType))
                return true;
        }
        return implementsType(typeToCheck.getSuperclass(),superType);
        
    }
    /**
     * Check if the given type extends a given super type
     * @param typeToCheck - type supposed to extend an specific type
     * @param superType - the type to be extended by the type to check
     * @return <code>true</code> if and only if the super type is above in the type hierarchy of the given type, otherwise <code>false</code>
     */
    public static boolean extendsType(Class typeToCheck, Class superType) {
        if (typeToCheck == null)
            return false;
        if (typeToCheck.equals(Object.class))
            return false;
        if (typeToCheck.equals(superType))
            return true;
        
        return extendsType(typeToCheck.getSuperclass(),superType);
    }
    /**
     * This method combines the extendsType and implementsType and checks interfaces and classes
     * @param typeToCheck - type supposed to extend / implement an specific type
     * @param superType - the type to be extended / implemented by the type to check
     * @return <code>true</code> if and only if the super type is above in the type hierarchy of the given type, otherwise <code>false</code>
     */
    public static boolean isTypeOf(Class typeToCheck, Class superType){
        return extendsType(typeToCheck,superType)||implementsType(typeToCheck,superType);
    }
    
    /**
     * @param type - the type to check
     * @param parameter - the constructor parameter
     * @return <code>true</code> if and only if the type has a visible constructor with the desired parameters
     */
    public static boolean hasDesiredConstructor(Class type, Class[] parameter){
        try{
        return type.getConstructor(parameter) != null;
        
        }catch (Exception e) {
            return false;
        }
    }
  
 
/**
 * @param <T> the type of the class to instantiate 
 * @param clazz - class object of the type
 * @return a new instance of T

 */
@SuppressWarnings("unchecked")
public  static <T> T getDefaultInstance(Class<T> clazz) {
    if(clazz == null)
        throw new ReflectionException("class must not be null");
    
    try{
    Constructor constructor = clazz.getConstructor(new Class[]{});
    return (T) constructor.newInstance(new Object[]{});
    }catch (Exception e) {
        throw new ReflectionException("can not instantiate type of class "+clazz.getName(),e);
    }
}


/**
 * This method calls {@link Class#newInstance()} to get a new instance. Use with care!
 * @param clazz - the class to instantiate
 * @return <code>true</code> if an instance could be created, otherwise false;
 */
public static boolean canCreateInstance(Class clazz){
    if(clazz == null)
        return false;
    if(clazz.isPrimitive())
        clazz = getPrimitiveWrapper(clazz);
    try{
        Object o = clazz.newInstance();
        return o != null;
    }catch (Throwable e) {
        return false;
    }
}
/**
 * Returns the wrapper type for the given primitive type. Wrappers can be
 * easily instantiated via reflection and will be boxed by the VM
 * @param primitive - the primitive type 
 * @return - the corresponding wrapper type
 */
public static final Class getPrimitiveWrapper(Class primitive) {
    if(primitive == null )
        throw new ReflectionException("primitive must not be null");
    if(!primitive.isPrimitive())
        throw new ReflectionException("given class is not a primitive");
                
    if (primitive == Integer.TYPE)
        return Integer.class;
    if (primitive == Float.TYPE)
        return Float.class;
    if (primitive == Long.TYPE)
        return Long.class;
    if (primitive == Short.TYPE)
        return Short.class;
    if (primitive == Byte.TYPE)
        return Byte.class;
    if (primitive == Double.TYPE)
        return Double.class;
    if (primitive == Boolean.TYPE)
        return Boolean.class;

    return primitive;
}

/**
 * Exception wrapper for all thrown exception in the ReflectionUtils methods
 * @author Simon Willnauer
 *
 */
public static class ReflectionException extends RuntimeException{

    /**
     * 
     */
    private static final long serialVersionUID = -4855060602565614280L;

    /**
     * @param message -  the exception message
     * @param cause - the exception root cause
     */
    public ReflectionException(String message, Throwable cause) {
        super(message, cause);
        // TODO Auto-generated constructor stub
    }

    /**
     * @param message - the exception message
     */
    public ReflectionException(String message) {
        super(message);
        // TODO Auto-generated constructor stub
    }
    
}

}