Java Constructor.isAnnotationPresent方法代码示例

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
protected final void extractFromConstructors()
{
    if (builderType == null) {
        // struct class must have a valid constructor
        addConstructors(structType);
    }
    else {
        // builder class must have a valid constructor
        addConstructors(builderType);

        // builder class must have a build method annotated with @ThriftConstructor
        addBuilderMethods();

        // verify struct class does not have @ThriftConstructors
        for (Constructor<?> constructor : getStructClass().getConstructors()) {
            if (constructor.isAnnotationPresent(ThriftConstructor.class)) {
                metadataErrors.addWarning(
                        "Thrift class '%s' has a builder class, but constructor '%s' annotated with @ThriftConstructor",
                        getStructClass().getName(),
                        constructor);
            }
        }
    }
}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
public static void init(Object object) throws IllegalAccessException, InvocationTargetException, InstantiationException {
    if (object instanceof User) {
        Class clz = object.getClass();
        Constructor [] constructors = clz.getConstructors();
        for (Constructor constructor : constructors) {
            if (constructor.isAnnotationPresent(AConstructor.class)) {
                AConstructor aConstructor = (AConstructor) constructor.getAnnotation(AConstructor.class);
                String name = aConstructor.initName();
                int age = aConstructor.initAge();
                ((User) object).name = name;
                ((User) object).age = age;
            }
        }
    }else{
        throw new RuntimeException("无法向下转型到指定类");
    }

}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
/**
   * 简单打印出UserAnnotation 类中所使用到的构造方法注解
   * 该方法只打印了 构造方法 类型的注解
   * @throws ClassNotFoundException
   */
  @SuppressWarnings("rawtypes")
  public static void parseConstructAnnotation()  throws ClassNotFoundException{
Constructor[] constructors = UserAnnotation.class.getConstructors();
      for (Constructor constructor : constructors) {
          /* 
           * 判断构造方法中是否有指定注解类型的注解 
           */  
          boolean hasAnnotation = constructor.isAnnotationPresent(TestA.class);
          if(hasAnnotation){
               /* 
               * 根据注解类型返回方法的指定类型注解 
               */
              @SuppressWarnings("unchecked")
		TestA annotation = (TestA) constructor.getAnnotation(TestA.class);
              System.out.println("constructor = " + constructor.getName()  
                      + "   |   id = " + annotation.id() + "  |  description = "  
                      + annotation.name() + "  |   gid= "+annotation.gid());
          }
      }
  }
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
private void updateFactoryData(Class<? extends T> clazz, DeveloperData data){
	this.data=data;
	variableSetters=new ArrayList<>();
	Constructor<? extends T> myCtor=null;
	Constructor<? extends T>[] ctors=(Constructor<? extends T>[]) clazz.getConstructors();
	for(Constructor<? extends T> constructor:ctors){
		if(constructor.isAnnotationPresent(ConstructorForDeveloper.class)){
			ctor=constructor;
			break;
		}
	}	
	if(ctor==null){
		AlertHandler.showError("Constructor not found");//Throw exception
		return;
	}
	parameters=ctor.getParameters();
	setterFactory=new VariableSetterFactory(data);
}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
public Constructor Select(Class type) throws NoSuchMethodException {
    Constructor[] constructors = type.getConstructors();
    if (constructors.length == 0) {
        throw new NoSuchMethodException("No constructor was found in " + type.getName());
    }
    for (Constructor<?> constructor : constructors) {
        if (constructor.isAnnotationPresent(Inject.class)) {
            return constructor;
        }
    }
    return constructors[0];
}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private static <T> Constructor<T> getConstructor(final Key<T> key) {
    final boolean staticClass = Modifier.isStatic(key.getType().getModifiers());
    final Class<?> parentClass = key.getType().getDeclaringClass();
    final boolean innerClass = !staticClass && parentClass != null;

    Constructor<T> inject = null;
    Constructor<T> noarg = null;

    for (final Constructor<T> c : ((Constructor<T>[]) key.getType().getDeclaredConstructors())) {
        if (c.isAnnotationPresent(Inject.class)) {
            if (inject == null) {
                inject = c;
            } else {
                throw new InjectException(String.format("%s has multiple @Inject constructors", key.getType()));
            }
        } else if (c.getParameterTypes().length == 0) {
            noarg = c;
        } else if (innerClass && c.getParameterTypes().length == 1) {
            noarg = c;
        }
    }

    final Constructor<T> constructor = inject != null ? inject : noarg;
    if (constructor == null) {
        throw new InjectException(String.format("%s doesn't have an @Inject or no-arg constructor, or a module provider", key.getType().getName()));
    }

    constructor.setAccessible(true);
    return constructor;
}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
private Object injectFieldsIntoClass(final Class<?> classToInject)
        throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    for (final Constructor<?> constructor : classToInject.getConstructors()) {
        if (constructor.isAnnotationPresent(OwnInject.class)) {
            return injectFieldsViaConstructor(classToInject, constructor);
        } else {
            return injectFields(classToInject);
        }
    }
    return null;
}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
/**
 * Finds a constructor suitable for the method. If the implementation contained any constructors marked with {@link AssistedInject}, this requires all
 * {@link Assisted} parameters to exactly match the parameters (in any order) listed in the method. Otherwise, if no {@link AssistedInject} constructors
 * exist, this will default to looking for a {@literal @}{@link Inject} constructor.
 */
private Constructor findMatchingConstructor(Method method, TypeLiteral<?> implementation, List<Key<?>> paramList, Errors errors) throws ErrorsException {
    Constructor<?> matchingConstructor = null;
    boolean anyAssistedInjectConstructors = false;

    // Look for AssistedInject constructors...
    for (Constructor<?> constructor : implementation.getRawType().getDeclaredConstructors()) {
        if (constructor.isAnnotationPresent(AssistedInject.class)) {
            anyAssistedInjectConstructors = true;

            if (constructorHasMatchingParams(implementation, constructor, paramList, errors)) {
                if (matchingConstructor != null) {
                    errors.addMessage(PrettyPrinter.format("%s has more than one constructor annotated with @AssistedInject "
                            + "that matches the parameters in method %s.", implementation, method));
                    return null;
                } else {
                    matchingConstructor = constructor;
                }
            }
        }
    }

    if (matchingConstructor != null) {
        return matchingConstructor;
    }

    if (anyAssistedInjectConstructors) {
        errors.addMessage(PrettyPrinter.format("%s has @AssistedInject constructors, but none of them match the " + "parameters in method %s.",
                implementation, method));
        return null;
    }

    // Look for @Inject constructors...
    Constructor<?> injectConstructor = (Constructor) InjectionPoint.forConstructorOf(implementation).getMember();

    if (injectConstructorHasMatchingParams(implementation, injectConstructor, paramList, errors)) {
        return injectConstructor;
    }

    // No matching constructor exists, complain.
    errors.addMessage(PrettyPrinter.format("%s has no constructors matching the parameters in method %s.", implementation, method));
    return null;
}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
/** Returns true if the inject annotation is on the constructor. */
private static boolean hasAtInject(Constructor cxtor) {
  return cxtor.isAnnotationPresent(Inject.class)
      || cxtor.isAnnotationPresent(javax.inject.Inject.class);
}