org.activiti.engine.impl.util.ReflectUtil Maven / Gradle / Ivy

Go to download
/* Licensed 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.activiti.engine.impl.util;

import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.Arrays;
import java.util.Locale;
import java.util.regex.Pattern;

import org.activiti.engine.ActivitiClassLoadingException;
import org.activiti.engine.ActivitiException;
import org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl;
import org.activiti.engine.impl.context.Context;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**

 */
public abstract class ReflectUtil {

  private static final Logger LOG = LoggerFactory.getLogger(ReflectUtil.class);

  private static final Pattern GETTER_PATTERN = Pattern.compile("(get|is)[A-Z].*");
  private static final Pattern SETTER_PATTERN = Pattern.compile("set[A-Z].*");

  public static ClassLoader getClassLoader() {
    ClassLoader loader = getCustomClassLoader();
    if (loader == null) {
      loader = Thread.currentThread().getContextClassLoader();
    }
    return loader;
  }

  public static Class loadClass(String className) {
    Class clazz = null;
    ClassLoader classLoader = getCustomClassLoader();

    // First exception in chain of classloaders will be used as cause when
    // no class is found in any of them
    Throwable throwable = null;

    if (classLoader != null) {
      try {
        LOG.trace("Trying to load class with custom classloader: {}", className);
        clazz = loadClass(classLoader, className);
      } catch (Throwable t) {
        throwable = t;
      }
    }
    if (clazz == null) {
      try {
        LOG.trace("Trying to load class with current thread context classloader: {}", className);
        clazz = loadClass(Thread.currentThread().getContextClassLoader(), className);
      } catch (Throwable t) {
        if (throwable == null) {
          throwable = t;
        }
      }
      if (clazz == null) {
        try {
          LOG.trace("Trying to load class with local classloader: {}", className);
          clazz = loadClass(ReflectUtil.class.getClassLoader(), className);
        } catch (Throwable t) {
          if (throwable == null) {
            throwable = t;
          }
        }
      }
    }

    if (clazz == null) {
      throw new ActivitiClassLoadingException(className, throwable);
    }
    return clazz;
  }

  public static InputStream getResourceAsStream(String name) {
    InputStream resourceStream = null;
    ClassLoader classLoader = getCustomClassLoader();
    if (classLoader != null) {
      resourceStream = classLoader.getResourceAsStream(name);
    }

    if (resourceStream == null) {
      // Try the current Thread context classloader
      classLoader = Thread.currentThread().getContextClassLoader();
      resourceStream = classLoader.getResourceAsStream(name);
      if (resourceStream == null) {
        // Finally, try the classloader for this class
        classLoader = ReflectUtil.class.getClassLoader();
        resourceStream = classLoader.getResourceAsStream(name);
      }
    }
    return resourceStream;
  }

  public static URL getResource(String name) {
    URL url = null;
    ClassLoader classLoader = getCustomClassLoader();
    if (classLoader != null) {
      url = classLoader.getResource(name);
    }
    if (url == null) {
      // Try the current Thread context classloader
      classLoader = Thread.currentThread().getContextClassLoader();
      url = classLoader.getResource(name);
      if (url == null) {
        // Finally, try the classloader for this class
        classLoader = ReflectUtil.class.getClassLoader();
        url = classLoader.getResource(name);
      }
    }

    return url;
  }

  public static Object instantiate(String className) {
    try {
      Class clazz = loadClass(className);
      return clazz.newInstance();
    } catch (Exception e) {
      throw new ActivitiException("couldn't instantiate class " + className, e);
    }
  }

  public static Object invoke(Object target, String methodName, Object[] args) {
    try {
      Class clazz = target.getClass();
      Method method = findMethod(clazz, methodName, args);
      method.setAccessible(true);
      return method.invoke(target, args);
    } catch (Exception e) {
      throw new ActivitiException("couldn't invoke " + methodName + " on " + target, e);
    }
  }

  /**
   * Returns the field of the given object or null if it doesn't exist.
   */
  public static Field getField(String fieldName, Object object) {
    return getField(fieldName, object.getClass());
  }

  /**
   * Returns the field of the given class or null if it doesn't exist.
   */
  public static Field getField(String fieldName, Class clazz) {
    Field field = null;
    try {
      field = clazz.getDeclaredField(fieldName);
    } catch (SecurityException e) {
      throw new ActivitiException("not allowed to access field " + field + " on class " + clazz.getCanonicalName());
    } catch (NoSuchFieldException e) {
      // for some reason getDeclaredFields doesn't search superclasses
      // (which getFields() does ... but that gives only public fields)
      Class superClass = clazz.getSuperclass();
      if (superClass != null) {
        return getField(fieldName, superClass);
      }
    }
    return field;
  }

  public static void setField(Field field, Object object, Object value) {
    try {
      field.setAccessible(true);
      field.set(object, value);
    } catch (IllegalArgumentException e) {
      throw new ActivitiException("Could not set field " + field.toString(), e);
    } catch (IllegalAccessException e) {
      throw new ActivitiException("Could not set field " + field.toString(), e);
    }
  }

  /**
   * Returns the setter-method for the given field name or null if no setter exists.
   */
  public static Method getSetter(String fieldName, Class clazz, Class fieldType) {
    String setterName = "set" + Character.toTitleCase(fieldName.charAt(0)) + fieldName.substring(1, fieldName.length());
    try {
      // Using getMethods(), getMethod(...) expects exact parameter type
      // matching and ignores inheritance-tree.
      Method[] methods = clazz.getMethods();
      for (Method method : methods) {
        if (method.getName().equals(setterName)) {
          Class[] paramTypes = method.getParameterTypes();
          if (paramTypes != null && paramTypes.length == 1 && paramTypes[0].isAssignableFrom(fieldType)) {
            return method;
          }
        }
      }
      return null;
    } catch (SecurityException e) {
      throw new ActivitiException("Not allowed to access method " + setterName + " on class " + clazz.getCanonicalName());
    }
  }

  private static Method findMethod(Class clazz, String methodName, Object[] args) {
    for (Method method : clazz.getDeclaredMethods()) {
      // TODO add parameter matching
      if (method.getName().equals(methodName) && matches(method.getParameterTypes(), args)) {
        return method;
      }
    }
    Class superClass = clazz.getSuperclass();
    if (superClass != null) {
      return findMethod(superClass, methodName, args);
    }
    return null;
  }

  public static Object instantiate(String className, Object[] args) {
    Class clazz = loadClass(className);
    Constructor constructor = findMatchingConstructor(clazz, args);
    if (constructor == null) {
      throw new ActivitiException("couldn't find constructor for " + className + " with args " + Arrays.asList(args));
    }
    try {
      return constructor.newInstance(args);
    } catch (Exception e) {
      throw new ActivitiException("couldn't find constructor for " + className + " with args " + Arrays.asList(args), e);
    }
  }

  @SuppressWarnings({ "unchecked", "rawtypes" })
  private static  Constructor findMatchingConstructor(Class clazz, Object[] args) {
    for (Constructor constructor : clazz.getDeclaredConstructors()) { // cannot
                                                                      // use
                                                                      // 
                                                                      // or
                                                                      // 
                                                                      // due
                                                                      // to
                                                                      // JDK
                                                                      // 5/6
                                                                      // incompatibility
      if (matches(constructor.getParameterTypes(), args)) {
        return constructor;
      }
    }
    return null;
  }

  private static boolean matches(Class[] parameterTypes, Object[] args) {
    if ((parameterTypes == null) || (parameterTypes.length == 0)) {
      return ((args == null) || (args.length == 0));
    }
    if ((args == null) || (parameterTypes.length != args.length)) {
      return false;
    }
    for (int i = 0; i < parameterTypes.length; i++) {
      if ((args[i] != null) && (!parameterTypes[i].isAssignableFrom(args[i].getClass()))) {
        return false;
      }
    }
    return true;
  }

  private static ClassLoader getCustomClassLoader() {
    ProcessEngineConfigurationImpl processEngineConfiguration = Context.getProcessEngineConfiguration();
    if (processEngineConfiguration != null) {
      final ClassLoader classLoader = processEngineConfiguration.getClassLoader();
      if (classLoader != null) {
        return classLoader;
      }
    }
    return null;
  }

  private static Class loadClass(ClassLoader classLoader, String className) throws ClassNotFoundException {
    ProcessEngineConfigurationImpl processEngineConfiguration = Context.getProcessEngineConfiguration();
    boolean useClassForName = processEngineConfiguration == null || processEngineConfiguration.isUseClassForNameClassLoading();
    return useClassForName ? Class.forName(className, true, classLoader) : classLoader.loadClass(className);
  }

  public static boolean isGetter(Method method) {
    String name = method.getName();
    Class type = method.getReturnType();
    Class params[] = method.getParameterTypes();

    if (!GETTER_PATTERN.matcher(name).matches()) {
      return false;
    }

    // special for isXXX boolean
    if (name.startsWith("is")) {
      return params.length == 0 && type.getSimpleName().equalsIgnoreCase("boolean");
    }

    return params.length == 0 && !type.equals(Void.TYPE);
  }

  public static boolean isSetter(Method method, boolean allowBuilderPattern) {
    String name = method.getName();
    Class type = method.getReturnType();
    Class params[] = method.getParameterTypes();

    if (!SETTER_PATTERN.matcher(name).matches()) {
      return false;
    }

    return params.length == 1 && (type.equals(Void.TYPE) || (allowBuilderPattern && method.getDeclaringClass().isAssignableFrom(type)));
  }

  public static boolean isSetter(Method method) {
    return isSetter(method, false);
  }

  public static String getGetterShorthandName(Method method) {
    if (!isGetter(method)) {
      return method.getName();
    }

    String name = method.getName();
    if (name.startsWith("get")) {
      name = name.substring(3);
      name = name.substring(0, 1).toLowerCase(Locale.ENGLISH) + name.substring(1);
    } else if (name.startsWith("is")) {
      name = name.substring(2);
      name = name.substring(0, 1).toLowerCase(Locale.ENGLISH) + name.substring(1);
    }

    return name;
  }

  public static String getSetterShorthandName(Method method) {
    if (!isSetter(method)) {
      return method.getName();
    }

    String name = method.getName();
    if (name.startsWith("set")) {
      name = name.substring(3);
      name = name.substring(0, 1).toLowerCase(Locale.ENGLISH) + name.substring(1);
    }

    return name;
  }
}