Java Constructor.getParameters方法代码示例

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
private static void collectMemberDataForConstructor(final Class<?> clazz, final Map<String, MemberData> memberData) {
    Constructor<?> annotatedConstructor = null;
    for (final Constructor<?> constuctor : clazz.getDeclaredConstructors()) {
        if (isFullyAnnotated(constuctor)
                && (annotatedConstructor == null || annotatedConstructor.getParameterTypes().length < constuctor.getParameterTypes().length)) {
            annotatedConstructor = constuctor;
        }
    }

    if (annotatedConstructor != null) {
        final Parameter[] parameters = annotatedConstructor.getParameters();
        for (int parameterIndex = 0; parameterIndex < parameters.length; parameterIndex++) {
            final Parameter parameter = parameters[parameterIndex];
            final String name = getNameFromMemberAnnotation(parameter);
            LOGGER.debug("constructor member '{}' -> ", name, parameter);
            getMemberData(memberData, name).constructor = annotatedConstructor;
            getMemberData(memberData, name).constructorIndex = parameterIndex;
        }
    }
}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
private void test(Constructor<MyEntity> constructor,
                 Class<?>[] paramClasses) {
    final Parameter[] params = constructor.getParameters();

    for (int i = 0; i < params.length; i++) {
        final Parameter parameter = params[i];
        System.out.println(parameter.toString());

        if (!parameter.getType().equals(paramClasses[i])) {
            errors++;
            System.err.println("Expected type " + paramClasses[i] +
                               " but got " + parameter.getType());
        }

        System.out.println(parameter.getParameterizedType());
        System.out.println(parameter.getAnnotatedType());
    }

}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
static <T> boolean hasNamedParameterSupport(Class<T> classDefinition) {
    for (Constructor constructor : classDefinition.getConstructors()) {
        for (Parameter parameter : constructor.getParameters()) {
            return parameter.isNamePresent();
        }
    }
    return true;
}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
protected void validateConstructorArgs(List<Throwable> errors) {
    final Constructor<?> constructor = getTestClass().getOnlyConstructor();
    final java.lang.reflect.Parameter[] parameters = constructor.getParameters();
    for (int i = 0; i < parameters.length; i++) {
        final String refName = Spockito.parameterRefNameOrNull(parameters[i]);
        if (refName != null && !tableRow.isValidRefName(refName)) {
            errors.add(new Exception("Invalid @Ref value or parameter name for argument " + i +
                    " of type " + parameters[i].getType() + " in the constructor: " + refName +
                    " does not reference a column of the table defined by @Unroll"));
        }
    }
}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
private Boolean classHasDefaultConstructor(){
    for(Constructor constructor : tClass.getConstructors()){
        if(constructor.getParameters().length == 0){
            return true;
        }
    }
    return false;
}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
private Constructor getClassDefaultConstructor(){
    Constructor returnConstructor = null;
    for(Constructor constructor : tClass.getConstructors()){
        if(constructor.getParameters().length == 0){
            returnConstructor = constructor;
        }
    }
    return returnConstructor;
}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
public void check() {
    final Class<?> cls = this.getClass();
    final Constructor<?> ctor = cls.getDeclaredConstructors()[0];
    final Parameter[] params = ctor.getParameters();
    final String[] names = names();
    final int[] modifiers = modifiers();
    final Class[] types = types();

    System.err.println("Testing class " + cls);

    if (params.length == names.length) {
        for (int i = 0; i < names.length; i++) {
            System.err.println("Testing parameter " + params[i].getName());
            if (!params[i].getName().equals(names[i]))
                error("Expected parameter name " + names[i] +
                      " got " + params[i].getName());
            if (params[i].getModifiers() != modifiers[i])
                error("Expected parameter modifiers " +
                      modifiers[i] + " got " +
                      params[i].getModifiers());
            if (!params[i].getType().equals(types[i]))
                error("Expected parameter type " + types[i] +
                      " got " + params[i].getType());
        }
    } else
        error("Expected " + names.length + " parameters");

}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
@Override
public boolean canInstantiate() {
    if (workingConstructors == null) {
        /*
          This MUST be the first instruction, because the empty array list takes care of a loop in the
          instantiation graph.

          Side effect: this will also (possibly) not work:

          ```
          class A {
            A(B b) {
            }

            A(C c) {
            }
          }

          class B {
            B(A a) {
            }
          }
          ```

          At this time, circular dependencies of any kind are not supported and it should not be possible to
          instantiate A _at all_.

          TODO fix cycle detection for all possibilities.
         */
        workingConstructors = new ArrayList<>();
        for (ConstructorDefinition<T> constructorDefinition : classDefinition.getConstructorDefinitions()) {
            Constructor<T> constructor       = constructorDefinition.getConstructor();
            boolean        usableConstructor = true;
            for (Parameter parameter : constructor.getParameters()) {
                if (constructorDefinition.getFixedParameterValues().containsKey(parameter)) {
                    continue;
                }
                if (namedParameterValues.containsKey(parameter.getName())) {
                    continue;
                }
                if (!factoryMap.containsKey(parameter.getType())) {
                    usableConstructor = false;
                    logger.info(
                        "Removing constructor for " +
                        classDefinition.getClassDefinition().getName() +
                        " because the constructor parameter " +
                        parameter.getName() +
                        " of type " +
                        parameter.getType().getName() +
                        " has no dependency injection definition."
                    );
                    break;
                }
                if (!factoryMap.get(parameter.getType()).canInstantiate()) {
                    usableConstructor = false;
                    logger.info(
                        "Removing constructor for " +
                        classDefinition.getClassDefinition().getName() +
                        " because the constructor parameter " +
                        parameter.getName() +
                        " of type " +
                        parameter.getType().getName() +
                        " has a dependency injection definition, but cannot instantiate."
                    );
                    break;
                }
            }
            if (usableConstructor) {
                workingConstructors.add(constructorDefinition);
            }
        }
    }
    if (workingConstructors.size() == 0) {
        logger.warn(
            this.classDefinition.getClassDefinition().getName() + " has no working constructors"
        );
    }
    return workingConstructors.size() > 0;
}
 

import java.lang.reflect.Constructor; //导入方法依赖的package包/类
private void recursiveRegisterType(Class<?> clazz) {

        if (registeredTypes.contains(clazz)) {

            return;
        }

        IocIgnore ignore = clazz.getAnnotation(IocIgnore.class);

        if (ignore != null) {

            return;
        }

        registeredTypes.add(clazz);

        // register these who implement the interface
        if (clazz.isInterface()) {

            Class<?>[] implementers = ClassesWalker.reflectImplementers(appClass, clazz);
            Arrays.stream(implementers).forEach(this::recursiveRegisterType);
            return;
        }

        try {
            // controller self
            Service inject = clazz.getAnnotation(Service.class);
            if (inject != null && inject.sington()) {
                registerType(clazz).singleInstance();
            } else {
                registerType(clazz).instancePerDependency();
            }

            // constructor parameters
            Constructor constructor = ConstructorWalker.findInjectConstructor(clazz);
            if (constructor != null) {

                Parameter[] paramNames = constructor.getParameters();
                Arrays.stream(paramNames).map(Parameter::getType).forEach(this::recursiveRegisterType);
                log.info("Ioc registered {} parameters for {} constructor", paramNames, clazz.getName());

                // class fields
                registerFields(clazz);
            }
        } catch (Exception e) {

            log.error(e.getMessage());
            e.printStackTrace();
        }
    }