Java Invokable.getParameters方法代码示例

import com.google.common.reflect.Invokable; //导入方法依赖的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.Invokable; //导入方法依赖的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.Invokable; //导入方法依赖的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.Invokable; //导入方法依赖的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.Invokable; //导入方法依赖的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.Invokable; //导入方法依赖的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.Invokable; //导入方法依赖的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.Invokable; //导入方法依赖的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.Invokable; //导入方法依赖的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;
}
 

import com.google.common.reflect.Invokable; //导入方法依赖的package包/类
private EventualProvider<?> providerFor(Invokable<T, ?> method, Errors methodErrors) {
  Annotation[] annotations = method.getAnnotations();

  verifyMethodAccessibility(methodErrors, method, source);

  @Nullable Annotation bindingAnnotation =
      Annotations.findBindingAnnotation(methodErrors, method, annotations);

  verifyAbsenseOfScopeAnnotation(methodErrors, annotations, source);

  List<Dependency<ListenableFuture<?>>> dependencies =
      Lists.newArrayListWithCapacity(method.getParameters().size());

  for (Parameter parameter : method.getParameters()) {
    dependencies.add(extractDependency(methodErrors, parameter));
  }

  Key<ListenableFuture<?>> bindingKey;
  boolean exposedBinding = method.isAnnotationPresent(Exposed.class);

  if (isVoid(method)) {
    bindingKey = futureKey(TypeToken.of(Boolean.class), new BlackholedAnnotation());
    exposedBinding = false;
  } else {
    bindingKey = futureKey(method.getReturnType(), bindingAnnotation);
  }

  return new EventualProvider<>(
      method,
      exposedBinding,
      dependencies,
      bindingKey,
      scopeAnnotation,
      source);
}
 

import com.google.common.reflect.Invokable; //导入方法依赖的package包/类
public MethodBinder(Invokable<T, R> from)
{

  this.method = from;
  int positional = 0;

  for (Parameter p : from.getParameters())
  {
    if (p.getAnnotation(GQLContext.class) != null)
    {
      this.contextual.put(p.getType(), p);
      args.add((generator) -> generator.context(p));
    }
    else if (p.getAnnotation(GQLArg.class) != null)
    {
      final GQLArg arg = p.getAnnotation(GQLArg.class);
      named.put(arg.value(), p);
      args.add((generator) -> generator.named(arg.value(), p));
    }
    else
    {
      final int mpos = positional;
      this.positional.add(p);
      args.add((generator) -> generator.positional(mpos, p));
    }
  }

}
 

import com.google.common.reflect.Invokable; //导入方法依赖的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 (!isNullable(param)) {
      checkNotNull(args[i]);
    }
  }
  return dummyReturnValue(interfaceType.resolveType(method.getGenericReturnType()));
}
 

import com.google.common.reflect.Invokable; //导入方法依赖的package包/类
@Test
public void allNonDeprecatedMethodsTakeOptions() throws IOException, NoSuchMethodException {
	for (Class aClass : getAllModels()) {
		HashSet<Class<?>> interfaces = new HashSet<Class<?>>(Arrays.<Class<?>>asList(aClass.getInterfaces()));
		for (Method method : aClass.getMethods()) {
			// Skip methods not declared on the base class.
			if (method.getDeclaringClass() != aClass) {
				continue;
			}
			// Skip equals
			if (method.getName().equals("equals")) {
				continue;
			}
			// Skip setters
			if (method.getName().startsWith("set")) {
				continue;
			}
			// Skip getters
			if (method.getName().startsWith("get")) {
				continue;
			}

			// If more than one method with the same parameter types is declared in a class, and one of these
			// methods has a return type that is more specific than any of the others, that method is returned;
			// otherwise one of the methods is chosen arbitrarily.
			Method mostSpecificMethod = aClass.getDeclaredMethod(method.getName(), method.getParameterTypes());
			if (!method.equals(mostSpecificMethod)) {
				continue;
			}

			Invokable<?, Object> invokable = Invokable.from(method);
			// Skip private methods.
			if (invokable.isPrivate()) {
				continue;
			}
			// Skip deprecated methods - we need to keep them around, but aren't asserting their type.
			if (invokable.isAnnotationPresent(Deprecated.class)) {
				continue;
			}
			ImmutableList<Parameter> parameters = invokable.getParameters();
			// Skip empty parameter lists - assume the author is using default values for the RequestOptions
			if (parameters.isEmpty()) {
				continue;
			}
			Parameter lastParam = parameters.get(parameters.size() - 1);
			Class<?> finalParamType = lastParam.getType().getRawType();

			// Skip methods that have exactly one param which is a map.
			if (Map.class.equals(finalParamType) && parameters.size() == 1) {
				continue;
			}

			// Skip `public static Foo retrieve(String id) {...` helper methods
			if (String.class.equals(finalParamType) && parameters.size() == 1 && "retrieve".equals(method.getName())) {
				continue;
			}

			// Skip the `public static Card createCard(String id) {...` helper method on Customer.
			if (String.class.equals(finalParamType) && parameters.size() == 1 && "createCard".equals(method.getName())) {
				continue;
			}

			if (RequestOptions.class.isAssignableFrom(finalParamType)) {
				continue;
			}
			Assert.assertTrue(
					String.format("Methods on %ss like %s.%s should take a final parameter as a %s parameter.%n", APIResource.class.getSimpleName(), aClass.getSimpleName(), method.getName(), RequestOptions.class.getSimpleName()),
					RequestOptions.class.isAssignableFrom(finalParamType));
		}
	}
}
 

import com.google.common.reflect.Invokable; //导入方法依赖的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();
}