Java Parameter类代码示例

import com.google.common.reflect.Parameter; //导入依赖的package包/类
private Object[] buildParamList(Invokable<?, ?> invokable, int indexOfParamToSetToNull) {
  ImmutableList<Parameter> params = invokable.getParameters();
  Object[] args = new Object[params.size()];

  for (int i = 0; i < args.length; i++) {
    Parameter param = params.get(i);
    if (i != indexOfParamToSetToNull) {
      args[i] = getDefaultValue(param.getType());
      Assert.assertTrue(
          "Can't find or create a sample instance for type '"
              + param.getType()
              + "'; please provide one using NullPointerTester.setDefault()",
          args[i] != null || isNullable(param));
    }
  }
  return args;
}
 

import com.google.common.reflect.Parameter; //导入依赖的package包/类
/**
 * Returns dummy factory arguments that are equal to {@code args} but may be different instances,
 * to be used to construct a second instance of the same equality group.
 */
private List<Object> generateEqualFactoryArguments(
    Invokable<?, ?> factory, List<Parameter> params, List<Object> args)
    throws ParameterNotInstantiableException, FactoryMethodReturnsNullException,
    InvocationTargetException, IllegalAccessException {
  List<Object> equalArgs = Lists.newArrayList(args);
  for (int i = 0; i < args.size(); i++) {
    Parameter param = params.get(i);
    Object arg = args.get(i);
    // Use new fresh value generator because 'args' were populated with new fresh generator each.
    // Two newFreshValueGenerator() instances should normally generate equal value sequence.
    Object shouldBeEqualArg = generateDummyArg(param, newFreshValueGenerator());
    if (arg != shouldBeEqualArg
        && Objects.equal(arg, shouldBeEqualArg)
        && hashCodeInsensitiveToArgReference(factory, args, i, shouldBeEqualArg)
        && hashCodeInsensitiveToArgReference(
            factory, args, i, generateDummyArg(param, newFreshValueGenerator()))) {
      // If the implementation uses identityHashCode(), referential equality is
      // probably intended. So no point in using an equal-but-different factory argument.
      // We check twice to avoid confusion caused by accidental hash collision.
      equalArgs.set(i, shouldBeEqualArg);
    }
  }
  return equalArgs;
}
 

import com.google.common.reflect.Parameter; //导入依赖的package包/类
private List<Object> getDummyArguments(Invokable<?, ?> invokable)
    throws ParameterNotInstantiableException {
  List<Object> args = Lists.newArrayList();
  for (Parameter param : invokable.getParameters()) {
    if (param.isAnnotationPresent(Nullable.class)) {
      args.add(null);
      continue;
    }
    Object defaultValue = getDummyValue(param.getType());
    if (defaultValue == null) {
      throw new ParameterNotInstantiableException(param);
    }
    args.add(defaultValue);
  }
  return args;
}
 

import com.google.common.reflect.Parameter; //导入依赖的package包/类
@Override
protected void bind(Object target, String key, FixtureMap fixtureMap) {
    List<Method> candidates = findSetterCandidates(target, key);

    for (Method candidate : candidates) {
        ImmutableList<Parameter> paramTypes = Invokable.from(candidate).getParameters();
        if (paramTypes.size() != 1) continue;

        TypeToken<?> paramType = paramTypes.get(0).getType();
        try {
            Object candidateParam = getFixtureConverter().convert(fixtureMap, paramType);
            if (candidateParam != null) {
                candidate.invoke(target, candidateParam);
                return;
            }
        } catch (Exception e) {
            throw new FixtureMappingException(e);
        }
    }

    bindByField(target, key, fixtureMap);
}
 

import com.google.common.reflect.Parameter; //导入依赖的package包/类
@Test
public void testAllAuroraSchedulerManagerIfaceMethodsHaveAuthorizingParam() throws Exception {
  for (Method declaredMethod : AuroraSchedulerManager.Iface.class.getDeclaredMethods()) {
    Invokable<?, ?> invokable = Invokable.from(declaredMethod);
    Collection<Parameter> parameters = invokable.getParameters();
    Invokable<?, ?> annotatedInvokable = Invokable.from(
        AnnotatedAuroraAdmin.class.getDeclaredMethod(
            invokable.getName(),
            FluentIterable.from(parameters)
                .transform(input -> input.getType().getRawType())
                .toList()
                .toArray(new Class<?>[0])));

    Collection<Parameter> annotatedParameters = Collections2.filter(
        annotatedInvokable.getParameters(),
        input -> input.getAnnotation(AuthorizingParam.class) != null);

    assertFalse(
        "Method " + invokable + " should have at least 1 " + AuthorizingParam.class.getName()
            + " annotation but none were found.",
        annotatedParameters.isEmpty());
  }
}
 

import com.google.common.reflect.Parameter; //导入依赖的package包/类
private void addExposedTypes(Invokable<?, ?> invokable, Class<?> cause) {
  addExposedTypes(invokable.getReturnType(), cause);
  for (Annotation annotation : invokable.getAnnotations()) {
    LOG.debug(
        "Adding exposed types from {}, which is an annotation on invokable {}",
        annotation,
        invokable);
    addExposedTypes(annotation.annotationType(), cause);
  }
  for (Parameter parameter : invokable.getParameters()) {
    LOG.debug(
        "Adding exposed types from {}, which is a parameter on invokable {}",
        parameter,
        invokable);
    addExposedTypes(parameter, cause);
  }
  for (TypeToken<?> exceptionType : invokable.getExceptionTypes()) {
    LOG.debug(
        "Adding exposed types from {}, which is an exception type on invokable {}",
        exceptionType,
        invokable);
    addExposedTypes(exceptionType, cause);
  }
}
 

import com.google.common.reflect.Parameter; //导入依赖的package包/类
private boolean eligibilityVerified(Invokable<T, Object> method, Errors errors) {
  List<TypeToken<?>> primitiveTypes = Lists.newArrayList();

  for (Parameter parameter : method.getParameters()) {
    if (parameter.getType().isPrimitive()) {
      primitiveTypes.add(parameter.getType());
    }
  }

  if (method.getReturnType().isPrimitive() && !isVoid(method)) {
    primitiveTypes.add(method.getReturnType());
  }

  if (!primitiveTypes.isEmpty()) {
    errors.addMessage("Incompartible eventual provider method '%s'"
        + "\n\tSignature has primitive types: %s."
        + " Please use boxed types instead",
        method.getName(),
        Joiner.on(", ").join(primitiveTypes));
  }

  return primitiveTypes.isEmpty();
}
 

import com.google.common.reflect.Parameter; //导入依赖的package包/类
/**
 * Returns dummy factory arguments that are equal to {@code args} but may be different instances,
 * to be used to construct a second instance of the same equality group.
 */
private List<Object> generateEqualFactoryArguments(
    Invokable<?, ?> factory, List<Parameter> params, List<Object> args)
    throws ParameterNotInstantiableException, FactoryMethodReturnsNullException,
        InvocationTargetException, IllegalAccessException {
  List<Object> equalArgs = Lists.newArrayList(args);
  for (int i = 0; i < args.size(); i++) {
    Parameter param = params.get(i);
    Object arg = args.get(i);
    // Use new fresh value generator because 'args' were populated with new fresh generator each.
    // Two newFreshValueGenerator() instances should normally generate equal value sequence.
    Object shouldBeEqualArg = generateDummyArg(param, newFreshValueGenerator());
    if (arg != shouldBeEqualArg
        && Objects.equal(arg, shouldBeEqualArg)
        && hashCodeInsensitiveToArgReference(factory, args, i, shouldBeEqualArg)
        && hashCodeInsensitiveToArgReference(
            factory, args, i, generateDummyArg(param, newFreshValueGenerator()))) {
      // If the implementation uses identityHashCode(), referential equality is
      // probably intended. So no point in using an equal-but-different factory argument.
      // We check twice to avoid confusion caused by accidental hash collision.
      equalArgs.set(i, shouldBeEqualArg);
    }
  }
  return equalArgs;
}
 

import com.google.common.reflect.Parameter; //导入依赖的package包/类
private List<Object> getDummyArguments(Invokable<?, ?> invokable)
    throws ParameterNotInstantiableException {
  List<Object> args = Lists.newArrayList();
  for (Parameter param : invokable.getParameters()) {
    if (isNullable(param)) {
      args.add(null);
      continue;
    }
    Object defaultValue = getDummyValue(param.getType());
    if (defaultValue == null) {
      throw new ParameterNotInstantiableException(param);
    }
    args.add(defaultValue);
  }
  return args;
}
 

import com.google.common.reflect.Parameter; //导入依赖的package包/类
@Override protected Object handleInvocation(
    Object proxy, Method method, Object[] args) {
  Invokable<?, ?> invokable = interfaceType.method(method);
  ImmutableList<Parameter> params = invokable.getParameters();
  for (int i = 0; i < args.length; i++) {
    Parameter param = params.get(i);
    if (!param.isAnnotationPresent(Nullable.class)) {
      checkNotNull(args[i]);
    }
  }
  return dummyReturnValue(interfaceType.resolveType(method.getGenericReturnType()));
}
 

import com.google.common.reflect.Parameter; //导入依赖的package包/类
private boolean hasInstanceMethodToTestNulls(Class<?> c, Visibility visibility) {
  for (Method method : nullPointerTester.getInstanceMethodsToTest(c, visibility)) {
    for (Parameter param : Invokable.from(method).getParameters()) {
      if (!NullPointerTester.isPrimitiveOrNullable(param)) {
        return true;
      }
    }
  }
  return false;
}
 

import com.google.common.reflect.Parameter; //导入依赖的package包/类
private void testEqualsUsing(final Invokable<?, ?> factory)

      throws ParameterNotInstantiableException, ParameterHasNoDistinctValueException,
             IllegalAccessException, InvocationTargetException, FactoryMethodReturnsNullException {
    List<Parameter> params = factory.getParameters();
    List<FreshValueGenerator> argGenerators = Lists.newArrayListWithCapacity(params.size());
    List<Object> args = Lists.newArrayListWithCapacity(params.size());
    for (Parameter param : params) {
      FreshValueGenerator generator = newFreshValueGenerator();
      argGenerators.add(generator);
      args.add(generateDummyArg(param, generator));
    }
    Object instance = createInstance(factory, args);
    List<Object> equalArgs = generateEqualFactoryArguments(factory, params, args);
    // Each group is a List of items, each item has a list of factory args.
    final List<List<List<Object>>> argGroups = Lists.newArrayList();
    argGroups.add(ImmutableList.of(args, equalArgs));
    EqualsTester tester = new EqualsTester(new ItemReporter() {
      @Override String reportItem(Item<?> item) {
        List<Object> factoryArgs = argGroups.get(item.groupNumber).get(item.itemNumber);
        return factory.getName() + "(" + Joiner.on(", ").useForNull("null").join(factoryArgs) + ")";
      }
    });
    tester.addEqualityGroup(instance, createInstance(factory, equalArgs));
    for (int i = 0; i < params.size(); i++) {
      List<Object> newArgs = Lists.newArrayList(args);
      Object newArg = argGenerators.get(i).generateFresh(params.get(i).getType());

      if (newArg == null || Objects.equal(args.get(i), newArg)) {
        if (params.get(i).getType().getRawType().isEnum()) {
          continue; // Nothing better we can do if it's single-value enum
        }
        throw new ParameterHasNoDistinctValueException(params.get(i));
      }
      newArgs.set(i, newArg);
      tester.addEqualityGroup(createInstance(factory, newArgs));
      argGroups.add(ImmutableList.of(newArgs));
    }
    tester.testEquals();
  }
 

import com.google.common.reflect.Parameter; //导入依赖的package包/类
@Nullable private static Object generateDummyArg(Parameter param, FreshValueGenerator generator)
    throws ParameterNotInstantiableException {
  if (param.isAnnotationPresent(Nullable.class)) {
    return null;
  }
  Object arg = generator.generateFresh(param.getType());
  if (arg == null) {
    throw new ParameterNotInstantiableException(param);
  }
  return arg;
}
 

import com.google.common.reflect.Parameter; //导入依赖的package包/类
public static GenericMethodType<?> of(Invokable<?, ?> invokable) {
    return new GenericMethodType<>(invokable.getReturnType(),
                                   invokable.getParameters()
                                            .stream()
                                            .map(Parameter::getType)
                                            .collect(Collectors.toImmutableList()));
}
 

import com.google.common.reflect.Parameter; //导入依赖的package包/类
/**
 * Returns a list of argument types for the given method, which must
 * be a part of the class.
 */
public List<TypeDescriptor<?>> getArgumentTypes(Method method) {
  Invokable<?, ?> typedMethod = token.method(method);

  List<TypeDescriptor<?>> argTypes = Lists.newArrayList();
  for (Parameter parameter : typedMethod.getParameters()) {
    argTypes.add(new SimpleTypeDescriptor<>(parameter.getType()));
  }
  return argTypes;
}