Java Errors.throwConfigurationExceptionIfErrorsExist方法代码示例

import com.google.inject.internal.Errors; //导入方法依赖的package包/类
@Override
protected void configure()
{
	final Errors errors = new Errors(testClass);

	for (FrameworkField field : fields)
	{
		try
		{
			final Field f = field.getField();
			final Key key = Annotations.getKey(TypeLiteral.get(f.getGenericType()), f, field.getAnnotations(), errors);

			bindMock(key, f.getType(), "Automock[" + field.getName() + "] " + key);
		}
		catch (ErrorsException e)
		{
			// Add it to the error list and hold them all until the end
			errors.merge(e.getErrors());
		}
	}

	errors.throwConfigurationExceptionIfErrorsExist();
}
 

import com.google.inject.internal.Errors; //导入方法依赖的package包/类
private void matchMethods(Key<?> factoryKey) throws ErrorsException {
    Errors errors = new Errors();
    dependencies.add(new Dependency(Dependency.GINJECTOR, factoryKey, getContext()));
    Class<?> factoryRawType = factoryType.getRawType();

    // getMethods() includes inherited methods from super-interfaces.
    for (Method method : factoryRawType.getMethods()) {
        Key<?> returnType = getKey(factoryType.getReturnType(method), method, method.getAnnotations(), errors);

        // Get parameters with annotations.
        List<TypeLiteral<?>> params = factoryType.getParameterTypes(method);
        Annotation[][] paramAnnotations = method.getParameterAnnotations();
        int p = 0;
        List<Key<?>> paramList = new ArrayList<Key<?>>();
        for (TypeLiteral<?> param : params) {
            Key<?> paramKey = getKey(param, method, paramAnnotations[p++], errors);
            paramList.add(assistKey(method, paramKey, errors));
        }

        // Try to match up the method to the constructor.
        TypeLiteral<?> implementation = collector.get(returnType);
        if (implementation == null) {
            implementation = returnType.getTypeLiteral();
        }
        Constructor<?> constructor = findMatchingConstructor(method, implementation, paramList, errors);

        if (constructor == null) {
            continue; // Errors are collected and thrown below.
        }

        // Calculate a map from method to constructor parameters and required
        // keys.
        String[] parameterNames = extractConstructorParameters(factoryKey, implementation, constructor, paramList, errors, dependencies);

        TypeLiteral<?> methodDeclaringType = factoryType.getSupertype(method.getDeclaringClass());
        assistData.add(new AssistData(implementation, MethodLiteral.get(constructor, implementation), MethodLiteral.get(method, methodDeclaringType),
                parameterNames));
        implementations.add(implementation);

        dependencies.addAll(guiceUtil.getMemberInjectionDependencies(factoryKey, implementation));
    }

    errors.throwConfigurationExceptionIfErrorsExist();
}
 

import com.google.inject.internal.Errors; //导入方法依赖的package包/类
private void matchMethods(Key<?> factoryKey) throws ErrorsException {
  Errors errors = new Errors();
  dependencies.add(new Dependency(Dependency.GINJECTOR, factoryKey, getContext()));
  Class<?> factoryRawType = factoryType.getRawType();

  // getMethods() includes inherited methods from super-interfaces.
  for (Method method : factoryRawType.getMethods()) {
    Key<?> returnType = getKey(factoryType.getReturnType(method), method,
        method.getAnnotations(), errors);

    // Get parameters with annotations.
    List<TypeLiteral<?>> params = factoryType.getParameterTypes(method);
    Annotation[][] paramAnnotations = method.getParameterAnnotations();
    int p = 0;
    List<Key<?>> paramList = new ArrayList<Key<?>>();
    for (TypeLiteral<?> param : params) {
      Key<?> paramKey = getKey(param, method, paramAnnotations[p++], errors);
      paramList.add(assistKey(method, paramKey, errors));
    }

    // Try to match up the method to the constructor.
    TypeLiteral<?> implementation = collector.get(returnType);
    if (implementation == null) {
      implementation = returnType.getTypeLiteral();
    }
    Constructor<?> constructor =
        findMatchingConstructor(method, implementation, paramList, errors);

    if (constructor == null) {
      continue; // Errors are collected and thrown below.
    }

    // Calculate a map from method to constructor parameters and required
    // keys.
    String[] parameterNames = extractConstructorParameters(factoryKey, 
        implementation, constructor, paramList, errors, dependencies);

    TypeLiteral<?> methodDeclaringType = factoryType.getSupertype(method.getDeclaringClass());
    assistData.add(new AssistData(implementation, MethodLiteral.get(constructor, implementation),
        MethodLiteral.get(method, methodDeclaringType), parameterNames));
    implementations.add(implementation);

    dependencies.addAll(guiceUtil.getMemberInjectionDependencies(factoryKey, implementation));
  }

  errors.throwConfigurationExceptionIfErrorsExist();
}
 

import com.google.inject.internal.Errors; //导入方法依赖的package包/类
/**
 * Returns a new injection point for the injectable constructor of {@code type}.
 *
 * @param type a concrete type with exactly one constructor annotated {@literal @}{@link Inject},
 *     or a no-arguments constructor that is not private.
 * @throws ConfigurationException if there is no injectable constructor, more than one injectable
 *     constructor, or if parameters of the injectable constructor are malformed, such as a
 *     parameter with multiple binding annotations.
 */
public static InjectionPoint forConstructorOf(TypeLiteral<?> type) {
  Class<?> rawType = getRawType(type.getType());
  Errors errors = new Errors(rawType);

  Constructor<?> injectableConstructor = null;
  for (Constructor<?> constructor : rawType.getDeclaredConstructors()) {

    boolean optional;
    Inject guiceInject = constructor.getAnnotation(Inject.class);
    if (guiceInject == null) {
      javax.inject.Inject javaxInject = constructor.getAnnotation(javax.inject.Inject.class);
      if (javaxInject == null) {
        continue;
      }
      optional = false;
    } else {
      optional = guiceInject.optional();
    }

    if (optional) {
      errors.optionalConstructor(constructor);
    }

    if (injectableConstructor != null) {
      errors.tooManyConstructors(rawType);
    }

    injectableConstructor = constructor;
    checkForMisplacedBindingAnnotations(injectableConstructor, errors);
  }

  errors.throwConfigurationExceptionIfErrorsExist();

  if (injectableConstructor != null) {
    return new InjectionPoint(type, injectableConstructor);
  }

  // If no annotated constructor is found, look for a no-arg constructor instead.
  try {
    Constructor<?> noArgConstructor = rawType.getDeclaredConstructor();

    // Disallow private constructors on non-private classes (unless they have @Inject)
    if (Modifier.isPrivate(noArgConstructor.getModifiers())
        && !Modifier.isPrivate(rawType.getModifiers())) {
      errors.missingConstructor(rawType);
      throw new ConfigurationException(errors.getMessages());
    }

    checkForMisplacedBindingAnnotations(noArgConstructor, errors);
    return new InjectionPoint(type, noArgConstructor);
  } catch (NoSuchMethodException e) {
    errors.missingConstructor(rawType);
    throw new ConfigurationException(errors.getMessages());
  }
}