import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
@Override
public Object resolve(Injectee injectee, ServiceHandle<?> serviceHandle) {

	if (injectee.getRequiredType() instanceof Class) {

		TypeLiteral<?> typeLiteral = TypeLiteral.get(injectee.getRequiredType());
		Errors errors = new Errors(injectee.getParent());
		Key<?> key;
		try {
			key = Annotations.getKey(typeLiteral, (Member) injectee.getParent(),
					injectee.getParent().getDeclaredAnnotations(), errors);
		} catch (ErrorsException e) {
			errors.merge(e.getErrors());
			throw new ConfigurationException(errors.getMessages());
		}

		return injector.getInstance(key);
	}

	throw new IllegalStateException("Can't process injection point: " + injectee.getRequiredType());
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
@Override
public MetricName buildName(MetricName metricName, AnnotatedElement injectionSite, Type metricType) {
    checkState(instantiationService != null, "instantiationService must be set");
    checkState(requestScope != null, "requestScope must be set");
    // Ensure we're inside a request scope
    Instance currentRequestScope = requestScope.suspendCurrent();
    if (currentRequestScope == null) {
        return metricName;
    } else {
        currentRequestScope.release();
    }
    // Verify that if we have injection information, we're not being injected into a singleton or per thread scoped object
    InstantiationData data = instantiationService.getInstantiationData();
    if (data != null) {
        Injectee injectee = data.getParentInjectee();
        if (injectee != null && injectee.getInjecteeDescriptor().getScopeAnnotation() != RequestScoped.class) {
            return metricName;
        }
    }
    return buildRequestScopedName(metricName, injectionSite, metricType);
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
@Override
@PerLookup
@Visibility(DescriptorVisibility.LOCAL)
public T provide() {
    Injectee injectee = instantiationService.getInstantiationData().getParentInjectee();
    String   name;
    if (injectee == null) {
        log.warn("Creating metric with no injection context; Use the metric registry directly instead of dynamically creating it "
                 + "through HK2", new Exception());
        name = UUID.randomUUID().toString();
    } else {
        AnnotatedElement parent = injectee.getParent();
        if (parent instanceof Constructor) {
            parent = ((Constructor) parent).getParameters()[injectee.getPosition()];
        }
        if (parent instanceof Method) {
            parent = ((Method) parent).getParameters()[injectee.getPosition()];
        }
        name = nameService.getFormattedMetricName(parent, injectee.getInjecteeClass());
    }
    return metricSupplier.apply(name);
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
/**
 * @return RxWebTarget or Proxy client of specified injectee interface
 * @throws IllegalStateException if uri is not correct or there is no sufficient injection resolved
 */
@Override
public Object resolve(Injectee injectee, ServiceHandle<?> root) {
    Remote remote = injectee.getParent().getAnnotation(Remote.class);
    UriInfo uriInfo = serviceLocator.getService(UriInfo.class);

    URI target = merge(remote.value(), uriInfo);
    WebTarget webTarget = client.target(target);
    Type type = injectee.getRequiredType();

    if (type instanceof Class) {
        Class<?> required = (Class) type;

        if (WebTarget.class.isAssignableFrom(required)) {
            return webTarget;
        }

        if (required.isInterface()) {
            return WebResourceFactory.newResource(required, webTarget, clientMethodInvoker);
        }
    }

    throw new IllegalStateException(format("Can't find proper injection for %s", type));
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
@Override
public Object resolve(Injectee injectee, ServiceHandle<?> root) {
  ActiveDescriptor<?> descriptor = locator.getInjecteeDescriptor(injectee);
  
  if (descriptor == null) {
    
    // Is it OK to return null?
    if (isNullable(injectee)) {
      return null;
    }
    
    throw new MultiException(new UnsatisfiedDependencyException(injectee));
  }
  
  return locator.getService(descriptor, root, injectee);
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
/**
 * NOTE: There can be only one {@link Annotation} that is a {@link Qualifier} or {@link BindingAnnotation}. 
 * They're the same but HK2 does not know about {@link BindingAnnotation}.
 * 
 * @see Qualifier
 * @see BindingAnnotation
 * @see javax.inject.Named
 * @see com.google.inject.name.Named
 */
private static Set<Annotation> getQualifiers(Injectee injectee) {
  // JSR 330's @Qualifier
  Set<Annotation> qualifiers = injectee.getRequiredQualifiers();
  if (!qualifiers.isEmpty()) {
    return qualifiers;
  }
  
  AnnotatedElement element = injectee.getParent();
  int position = injectee.getPosition();
  
  // Guice's @BindingAnnotation is the same as @Qualifier
  Annotation annotation = getBindingAnnotation(element, position);
  if (annotation != null) {
    return Collections.singleton(annotation);
  }
  
  return Collections.emptySet();
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
@Override
public boolean justInTimeResolution(Injectee injectee) {
  Type type = injectee.getRequiredType();
  Class<?> clazz = MoreTypes.getRawType(type);
  
  if (clazz != null) {
    Binding<?> binding = findBinding(injectee);
    if (binding != null) {
      Key<?> key = binding.getKey();
      Set<Annotation> qualifiers = BindingUtils.getQualifiers(key);
      
      GuiceBindingDescriptor<?> descriptor = new GuiceBindingDescriptor<>(
          type, clazz, qualifiers, binding);
      ServiceLocatorUtilities.addOneDescriptor(locator, descriptor);
      return true;
    }
  }
  
  
  return false;
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
/**
 * Returns a {@link Guice} {@link Binding} for the given HK2 {@link Injectee}
 * or {@code null} if there is no such binding (i.e. Guice doesn't have it and
 * doesn't know how to build it).
 */
private Binding<?> findBinding(Injectee injectee) {
  Key<?> key = BindingUtils.toKey(injectee);
  if (key == null) {
    return null;
  }
  
  // We can't do anything about HK2 @Contracts
  if (BindingUtils.isHk2Contract(injectee)) {
    return null;
  }
  
  // Classes with a @Contract annotation are SPIs. They either exist or
  // not. They must be explicit bindings in the world of Guice.
  if (BindingUtils.isJerseyContract(injectee)) {
    return injector.getExistingBinding(key);
  }
  
  // We've to use Injector#getBinding() to cover Just-In-Time bindings
  // which may fail with an Exception because Guice doesn't know how to
  // construct the requested object.
  return injector.getBinding(key);
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
public static String getInjecteeName(InstantiationService instantiationService) {
    InstantiationData instantiationData = instantiationService.getInstantiationData();
    Injectee parentInjectee = instantiationData.getParentInjectee();
    String name = null;
    Optional<Annotation> namedAnnotation = parentInjectee.getRequiredQualifiers().stream().filter(Named.class::isInstance).findFirst();
    if (namedAnnotation.isPresent()) {
        Named named = (Named) namedAnnotation.get();
        name = named.value();
    }

    if (name == null) {
        throw new RuntimeException("Named factory bound without name.");
    }
    return name;
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
@Override
public Object resolve(Injectee injectee, ServiceHandle<?> root) {
    ConfigProperty configProperty = injectee.getParent().getAnnotation(ConfigProperty.class);
    assert configProperty != null;

    if (StringUtils.isBlank(configProperty.name())) {
        throw new IllegalArgumentException("@ConfigProperty shouldn't have blank name");
    }

    if (configProperty.mustPresent() && !config.containsKey(configProperty.name())) {
        throw new IllegalArgumentException(configProperty.name() + " must be present in config properties");
    }

    String propValue = config.getString(configProperty.name(), configProperty.defaultValue()).trim();

    if (!configProperty.allowBlank() && StringUtils.isBlank(propValue)) {
        throw new IllegalArgumentException(configProperty.name() + " doesn't allow blank name");
    }

    if (injectee.getRequiredType().equals(String.class)) {
        return propValue;
    } else if (injectee.getRequiredType().equals(Integer.TYPE)) {
        return Integer.valueOf(propValue);
    } else if (injectee.getRequiredType().equals(Long.TYPE)) {
        return Long.valueOf(propValue);
    } else if (injectee.getRequiredType().equals(Boolean.TYPE)) {
        return Boolean.valueOf(propValue);
    }

    throw new IllegalArgumentException("Not acceptable injectin type : ${injectee.requiredType.typeName}");

}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
@Override
public Object resolve(Injectee injectee, ServiceHandle<?> serviceHandle) {
    Property annotation = injectee.getParent().getAnnotation(Property.class);

    String property = properties.get(annotation.value());
    if (isNull(property) || property.isEmpty()) {
        throw new HK2RuntimeException(String.format("Property %s does not exist.", property));
    }

    Function<String, ?> parser = parsers.get(injectee.getRequiredType());
    return parser.apply(property);
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
@Override
public Object resolve(Injectee injectee, ServiceHandle<?> root)
{
    if ((injectee.getRequiredType() instanceof Class)
    && ((Class<?>)injectee.getRequiredType()).isAssignableFrom(logInject.getLoggerClass()))
    {
        Class<?> injecteeClass = injectee.getInjecteeClass();
        Class<?> implementationClass = injectee.getInjecteeDescriptor().getImplementationClass();
        Class<?> logger = (injecteeClass.isAssignableFrom(implementationClass))? implementationClass:injecteeClass;
        return logInject.createLogger(logger);
    }
    return systemResolver.resolve(injectee, root);
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
@Override
public Object resolve(Injectee injectee, ServiceHandle<?> handle) {
    Class requiredClass = (Class) injectee.getRequiredType();
    log.info("Asked to inject a " + requiredClass.getSimpleName());
    if (requiredClass == CouchbaseClientFactory.class) {
        return factory;
    }
    return AccessorFactory.getFactory().getAccessor(requiredClass, factory);
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
@Override
public ActiveDescriptor<?> reifyDescriptor(Descriptor descriptor, Injectee injectee) throws MultiException {
    throw new UnsupportedOperationException("Will not be supported!");
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
@Override
public ActiveDescriptor<?> getInjecteeDescriptor(Injectee injectee) throws MultiException {
    throw new UnsupportedOperationException("Will not be supported!");
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
@Override
public <T> ServiceHandle<T> getServiceHandle(ActiveDescriptor<T> activeDescriptor, Injectee injectee) throws MultiException {
    throw new UnsupportedOperationException("Will not be supported!");
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
@Override
public <T> T getService(ActiveDescriptor<T> activeDescriptor,
    ServiceHandle<?> root, Injectee injectee) throws MultiException {
    throw new UnsupportedOperationException("Will not be supported!");
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
public Object resolve(Injectee injectee, ServiceHandle<?> serviceHandle) {
	final Class<?> loggerClass = injectee.getInjecteeClass();

	return new DefaultLogger(loggerClass);
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
@Override
public Object resolve(Injectee injectee, ServiceHandle<?> root) {
  InjectionResolver<?> resolver = descriptor.create(root);
  return resolver.resolve(injectee, root);
}
 

import org.glassfish.hk2.api.Injectee; //导入依赖的package包/类
/**
 * Creates and returns a {@link Key} from the given {@link Injectee}.
 */
public static Key<?> toKey(Injectee injectee) {
  Type type = injectee.getRequiredType();
  Set<Annotation> qualifiers = getQualifiers(injectee);
  return newKey(type, qualifiers);
}