Removing an injection from Param-Value Providers and Injection Resolvers.

Change-Id: I8ba11148c66fd07d9c74718025c49d0cc26fb306

Author: Petr Bouda

core-client/src/main/java/org/glassfish/jersey/client/ClientBinder.java

@@ -56,8 +56,6 @@
 import org.glassfish.jersey.internal.JerseyErrorService;
 import org.glassfish.jersey.internal.PropertiesDelegate;
 import org.glassfish.jersey.internal.ServiceFinderBinder;
-import org.glassfish.jersey.internal.inject.ContextInjectionResolver;
-import org.glassfish.jersey.internal.inject.JerseyClassAnalyzer;
 import org.glassfish.jersey.internal.inject.ReferencingFactory;
 import org.glassfish.jersey.internal.inject.SupplierFactory;
 import org.glassfish.jersey.internal.spi.AutoDiscoverable;
@@ -116,8 +114,6 @@ public PropertiesDelegate provide() {
     protected void configure() {
         install(new RequestScope.Binder(), // must go first as it registers the request scope instance.
                 new JerseyErrorService.Binder(),
-                new ContextInjectionResolver.Binder(),
-                new JerseyClassAnalyzer.Binder(),
                 new MessagingBinders.MessageBodyProviders(clientRuntimeProperties, RuntimeType.CLIENT),
                 new MessagingBinders.HeaderDelegateProviders(),
                 new MessageBodyFactory.Binder(),

core-client/src/main/java/org/glassfish/jersey/client/ClientConfig.java

@@ -113,12 +113,7 @@ public State onChange(final State state) {
         private volatile ConnectorProvider connectorProvider;
 
 
-        private final LazyValue<ClientRuntime> runtime = Values.lazy(new Value<ClientRuntime>() {
-            @Override
-            public ClientRuntime get() {
-                return initRuntime();
-            }
-        });
+        private final LazyValue<ClientRuntime> runtime = Values.lazy((Value<ClientRuntime>) this::initRuntime);
 
         /**
          * Configuration state change strategy.

core-common/src/main/java/org/glassfish/jersey/internal/inject/ContextInjectionResolver.java renamed to core-common/src/main/java/org/glassfish/jersey/hk2/ContextInjectionResolverImpl.java

@@ -1,7 +1,7 @@
 /*
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
  *
- * Copyright (c) 2012-2017 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
  *
  * The contents of this file are subject to the terms of either the GNU
  * General Public License Version 2 only ("GPL") or the Common Development
@@ -38,7 +38,7 @@
  * holder.
  */
 
-package org.glassfish.jersey.internal.inject;
+package org.glassfish.jersey.hk2;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Type;
@@ -52,12 +52,15 @@
 import javax.inject.Inject;
 import javax.inject.Singleton;
 
+import org.glassfish.jersey.internal.inject.ForeignRequestScopeBridge;
+import org.glassfish.jersey.internal.inject.SupplierFactory;
 import org.glassfish.jersey.internal.util.ReflectionHelper;
 import org.glassfish.jersey.internal.util.collection.LazyValue;
 import org.glassfish.jersey.internal.util.collection.Value;
 import org.glassfish.jersey.internal.util.collection.Values;
 import org.glassfish.jersey.process.internal.RequestScoped;
 import org.glassfish.jersey.spi.inject.AbstractBinder;
+import org.glassfish.jersey.spi.inject.ContextInjectionResolver;
 
 import org.glassfish.hk2.api.ActiveDescriptor;
 import org.glassfish.hk2.api.Factory;
@@ -78,7 +81,7 @@
  * @author Jakub Podlesak (jakub.podlesak at oracle.com)
  */
 @Singleton
-public class ContextInjectionResolver implements InjectionResolver<Context> {
+public class ContextInjectionResolverImpl implements InjectionResolver<Context>, ContextInjectionResolver {
 
     /**
      * Context injection resolver binder.
@@ -87,9 +90,11 @@ public static final class Binder extends AbstractBinder {
 
         @Override
         protected void configure() {
-            // @Context
-            bind(ContextInjectionResolver.class).to(new GenericType<InjectionResolver<Context>>() {
-            }).in(Singleton.class);
+            bind(ContextInjectionResolverImpl.class)
+                    .to(new GenericType<InjectionResolver<Context>>() {})
+                    .to(new GenericType<org.glassfish.jersey.spi.inject.InjectionResolver<Context>>() {})
+                    .to(ContextInjectionResolver.class)
+                    .in(Singleton.class);
         }
     }
 
@@ -131,6 +136,31 @@ public Object resolve(Injectee injectee, ServiceHandle<?> root) {
         return null;
     }
 
+    /**
+     * Jersey Injection Resolver method that just populate HK2 injectee object and delegates the processing to HK2 Injection
+     * Resolver.
+     *
+     * @param injectee The injection point this value is being injected into
+     * @return result of the injection processing.
+     */
+    @Override
+    public Object resolve(org.glassfish.jersey.spi.inject.Injectee injectee) {
+        InjecteeImpl hk2injectee = new InjecteeImpl() {
+            @Override
+            public Class<?> getInjecteeClass() {
+                return injectee.getInjecteeClass();
+            }
+        };
+        hk2injectee.setRequiredType(injectee.getRequiredType());
+        hk2injectee.setRequiredQualifiers(injectee.getRequiredQualifiers());
+        if (injectee.getInjecteeDescriptor() != null) {
+            hk2injectee.setInjecteeDescriptor((ActiveDescriptor<?>) injectee.getInjecteeDescriptor().get());
+        }
+
+        // Delegate the call to HK2 Resolver, Service Handle is not need in the delegated processing.
+        return resolve(hk2injectee, null);
+    }
+
     private Factory asFactory(final ServiceHandle handle) {
         return new SupplierFactory() {
             @Override
@@ -145,19 +175,13 @@ private Injectee getFactoryInjectee(final Injectee injectee, final Type required
     }
 
     private static class RequiredTypeOverridingInjectee extends InjecteeImpl {
-
-        private static final long serialVersionUID = -3740895548611880187L;
-
         private RequiredTypeOverridingInjectee(final Injectee injectee, final Type requiredType) {
             super(injectee);
             setRequiredType(requiredType);
         }
     }
 
     private static class DescriptorOverridingInjectee extends InjecteeImpl {
-
-        private static final long serialVersionUID = -3740895548611880189L;
-
         private DescriptorOverridingInjectee(final Injectee injectee, final ActiveDescriptor descriptor) {
             super(injectee);
             setInjecteeDescriptor(descriptor);
@@ -174,9 +198,13 @@ public boolean isMethodParameterIndicator() {
         return false;
     }
 
+    @Override
+    public Class<Context> getAnnotation() {
+        return Context.class;
+    }
 
     private final Cache<Injectee, Injectee> foreignRequestScopedInjecteeCache =
-            new Cache<Injectee, Injectee>(new Computable<Injectee, Injectee>() {
+            new Cache<>(new Computable<Injectee, Injectee>() {
         @Override
         public Injectee compute(Injectee injectee) {
             if (injectee.getParent() != null) {
@@ -200,12 +228,8 @@ public Injectee compute(Injectee injectee) {
         }
     });
 
-    LazyValue<Set<Class<?>>> foreignRequestScopedComponents = Values.lazy(new Value<Set<Class<?>>>() {
-        @Override
-        public Set<Class<?>> get() {
-            return getForeignRequestScopedComponents();
-        }
-    });
+    private LazyValue<Set<Class<?>>> foreignRequestScopedComponents = Values.lazy(
+            (Value<Set<Class<?>>>) this::getForeignRequestScopedComponents);
 
     private Set<Class<?>> getForeignRequestScopedComponents() {
         final List<ForeignRequestScopeBridge> scopeBridges = serviceLocator.getAllServices(ForeignRequestScopeBridge.class);

core-common/src/main/java/org/glassfish/jersey/hk2/HK2InstanceManager.java

@@ -51,11 +51,16 @@
 import org.glassfish.jersey.spi.ServiceHolder;
 import org.glassfish.jersey.spi.ServiceHolderImpl;
 import org.glassfish.jersey.spi.inject.Binder;
+import org.glassfish.jersey.spi.inject.ClassBeanDescriptor;
 import org.glassfish.jersey.spi.inject.CompositeBinder;
 import org.glassfish.jersey.spi.inject.Descriptor;
 import org.glassfish.jersey.spi.inject.Descriptors;
+import org.glassfish.jersey.spi.inject.ForeignDescriptor;
+import org.glassfish.jersey.spi.inject.ForeignDescriptorImpl;
+import org.glassfish.jersey.spi.inject.InstanceBeanDescriptor;
 import org.glassfish.jersey.spi.inject.InstanceManager;
 
+import org.glassfish.hk2.api.ActiveDescriptor;
 import org.glassfish.hk2.api.ServiceLocator;
 import org.glassfish.hk2.api.ServiceLocatorFactory;
 import org.glassfish.hk2.utilities.ServiceLocatorUtilities;
@@ -136,16 +141,20 @@ public ServiceLocator getServiceLocator() {
     }
 
     @Override
-    public void initialize(String name, InstanceManager parent, String defaultClassAnalyzer, Binder... binders) {
+    public void initialize(String name, InstanceManager parent, Binder... binders) {
         this.locator = createLocator(name, parent);
+        ServiceLocatorUtilities.bind(locator, new JerseyClassAnalyzer.Binder(locator));
 
         // First service the current BeanManager to be able to inject itself into other services.
         Hk2Helper.bind(locator, Descriptors.service(this).to(InstanceManager.class));
 
+        // Add support for Context annotation.
+        Hk2Helper.bind(locator, new ContextInjectionResolverImpl.Binder());
+
         // Compose together the initialization binders and bind them as a whole.
         Hk2Helper.bind(locator, CompositeBinder.wrap(binders));
 
-        this.locator.setDefaultClassAnalyzerName(defaultClassAnalyzer);
+        this.locator.setDefaultClassAnalyzerName(JerseyClassAnalyzer.NAME);
 
         // clear HK2 caches
         ServiceLocatorRuntimeBean serviceLocatorRuntimeBean = locator.getService(ServiceLocatorRuntimeBean.class);
@@ -223,6 +232,32 @@ public <T> T getInstance(Type clazz) {
         return locator.getService(clazz);
     }
 
+    @Override
+    public Object getInstance(ForeignDescriptor foreignDescriptor) {
+        return locator.getServiceHandle((ActiveDescriptor<?>) foreignDescriptor.get()).getService();
+    }
+
+    @Override
+    public ForeignDescriptor createForeignDescriptor(Descriptor descriptor) {
+        ForeignDescriptor foreignDescriptor = createAndTranslateForeignDescriptor(descriptor);
+        ActiveDescriptor<Object> activeDescriptor = ServiceLocatorUtilities
+                .addOneDescriptor(locator, (org.glassfish.hk2.api.Descriptor) foreignDescriptor.get(), false);
+        return new ForeignDescriptorImpl(activeDescriptor);
+    }
+
+    private ForeignDescriptor createAndTranslateForeignDescriptor(Descriptor descriptor) {
+        ActiveDescriptor<?> activeDescriptor;
+        if (ClassBeanDescriptor.class.isAssignableFrom(descriptor.getClass())) {
+            activeDescriptor = Hk2Helper.translateToActiveDescriptor((ClassBeanDescriptor<?>) descriptor);
+        } else if (InstanceBeanDescriptor.class.isAssignableFrom(descriptor.getClass())) {
+            activeDescriptor = Hk2Helper.translateToActiveDescriptor((InstanceBeanDescriptor<?>) descriptor);
+        } else {
+            throw new RuntimeException(LocalizationMessages.UNKNOWN_DESCRIPTOR_TYPE(descriptor.getClass().getSimpleName()));
+        }
+
+        return new ForeignDescriptorImpl(activeDescriptor);
+    }
+
     @Override
     public <T> T getInstance(Class<T> clazz) {
         return locator.getService(clazz);

core-common/src/main/java/org/glassfish/jersey/hk2/Hk2Helper.java

@@ -42,19 +42,23 @@
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Type;
+import java.util.Set;
 
 import org.glassfish.jersey.internal.LocalizationMessages;
 import org.glassfish.jersey.spi.inject.AliasDescriptor;
 import org.glassfish.jersey.spi.inject.ClassBeanDescriptor;
 import org.glassfish.jersey.spi.inject.ClassFactoryDescriptor;
 import org.glassfish.jersey.spi.inject.Descriptor;
+import org.glassfish.jersey.spi.inject.Descriptors;
+import org.glassfish.jersey.spi.inject.InjectionResolverDescriptor;
 import org.glassfish.jersey.spi.inject.InstanceBeanDescriptor;
 import org.glassfish.jersey.spi.inject.InstanceFactoryDescriptor;
 
 import org.glassfish.hk2.api.ActiveDescriptor;
 import org.glassfish.hk2.api.DynamicConfiguration;
 import org.glassfish.hk2.api.DynamicConfigurationService;
 import org.glassfish.hk2.api.Factory;
+import org.glassfish.hk2.api.InjectionResolver;
 import org.glassfish.hk2.api.ServiceLocator;
 import org.glassfish.hk2.utilities.AbstractActiveDescriptor;
 import org.glassfish.hk2.utilities.ActiveDescriptorBuilder;
@@ -132,10 +136,17 @@ private static void bindDescriptor(ServiceLocator locator, Descriptor<?, ?> desc
      */
     private static void bindDescriptor(ServiceLocator locator, DynamicConfiguration dc, Descriptor<?, ?> descriptor) {
         if (ClassBeanDescriptor.class.isAssignableFrom(descriptor.getClass())) {
-            bindClassDescriptor(locator, dc, (ClassBeanDescriptor<?>) descriptor);
+            ActiveDescriptor<?> activeDescriptor = translateToActiveDescriptor((ClassBeanDescriptor<?>) descriptor);
+            bindDescriptor(locator, dc, activeDescriptor, descriptor.getAliases());
 
         } else if (InstanceBeanDescriptor.class.isAssignableFrom(descriptor.getClass())) {
-            bindInstanceDescriptor(locator, dc, (InstanceBeanDescriptor<?>) descriptor);
+            ActiveDescriptor<?> activeDescriptor = translateToActiveDescriptor((InstanceBeanDescriptor<?>) descriptor);
+            bindDescriptor(locator, dc, activeDescriptor, descriptor.getAliases());
+
+        } else if (InjectionResolverDescriptor.class.isAssignableFrom(descriptor.getClass())) {
+            InjectionResolverDescriptor resolverDescriptor = (InjectionResolverDescriptor) descriptor;
+            bindDescriptor(locator, dc, wrapInjectionResolver(resolverDescriptor), descriptor.getAliases());
+            bindDescriptor(locator, dc, translateToActiveDescriptor(resolverDescriptor), descriptor.getAliases());
 
         } else if (ClassFactoryDescriptor.class.isAssignableFrom(descriptor.getClass())) {
             bindClassFactoryDescriptor(dc, (ClassFactoryDescriptor<?>) descriptor);
@@ -148,6 +159,13 @@ private static void bindDescriptor(ServiceLocator locator, DynamicConfiguration
         }
     }
 
+    @SuppressWarnings("unchecked")
+    private static ActiveDescriptor<?> wrapInjectionResolver(InjectionResolverDescriptor resolverDescriptor) {
+        InjectionResolverWrapper<?> wrappedResolver = new InjectionResolverWrapper<>(resolverDescriptor.getResolver());
+        return translateToActiveDescriptor(Descriptors.service(wrappedResolver),
+                new ParameterizedTypeImpl(InjectionResolver.class, resolverDescriptor.getResolver().getAnnotation()));
+    }
+
     /**
      * Binds a new instance {@link org.glassfish.hk2.api.FactoryDescriptors} using the information from the Jersey descriptor
      * {@link InstanceFactoryDescriptor}.
@@ -244,16 +262,7 @@ private static void bindClassFactoryDescriptor(DynamicConfiguration dc, ClassFac
         dc.bind(new FactoryDescriptorsImpl(factoryDescriptorBuilder.build(), descriptorBuilder.buildProvideMethod()));
     }
 
-    /**
-     * Binds a new instance {@link Descriptor} using the information from the Jersey descriptor {@link ClassBeanDescriptor}.
-     * <p>
-     * Along with a new instance, the method is able to register aliases belonging to the new service.
-     *
-     * @param locator HK2 instance manager.
-     * @param dc      HK2 Dynamic configuration to bind the object.
-     * @param desc    Jersey descriptor as a holder of information about an injection point.
-     */
-    private static void bindClassDescriptor(ServiceLocator locator, DynamicConfiguration dc, ClassBeanDescriptor<?> desc) {
+    static ActiveDescriptor<?> translateToActiveDescriptor(ClassBeanDescriptor<?> desc) {
         ActiveDescriptorBuilder binding = BuilderHelper.activeLink(desc.getService())
                 .named(desc.getName())
                 .analyzeWith(desc.getAnalyzer());
@@ -286,23 +295,35 @@ private static void bindClassDescriptor(ServiceLocator locator, DynamicConfigura
             binding.asType(desc.getImplementationType());
         }
 
-        ActiveDescriptor<Object> activeDescriptor = dc.bind(binding.build());
-        for (AliasDescriptor alias : desc.getAliases()) {
-            dc.bind(createAlias(locator, activeDescriptor, alias));
-        }
+        return binding.build();
     }
 
     /**
      * Binds a new instance {@link Descriptor} using the information from the Jersey descriptor {@link InstanceBeanDescriptor}.
      * <p>
      * Along with a new instance, the method is able to register aliases belonging to the new service.
      *
-     * @param locator HK2 instance manager.
-     * @param dc      HK2 Dynamic configuration to bind the object.
-     * @param desc    Jersey descriptor as a holder of information about an injection point.
+     * @param locator          HK2 instance manager.
+     * @param dc               HK2 Dynamic configuration to bind the object.
+     * @param activeDescriptor HK2 active descriptor.
+     * @param aliases          aliases belonging to the given descriptor.
      */
-    private static void bindInstanceDescriptor(ServiceLocator locator, DynamicConfiguration dc, InstanceBeanDescriptor<?> desc) {
-        AbstractActiveDescriptor<?> binding = BuilderHelper.createConstantDescriptor(desc.getService());
+    private static void bindDescriptor(ServiceLocator locator, DynamicConfiguration dc, ActiveDescriptor<?> activeDescriptor,
+            Set<AliasDescriptor> aliases) {
+        ActiveDescriptor<Object> boundDescriptor = dc.bind(activeDescriptor);
+        for (AliasDescriptor alias : aliases) {
+            dc.bind(createAlias(locator, boundDescriptor, alias));
+        }
+    }
+
+    static ActiveDescriptor<?> translateToActiveDescriptor(InstanceBeanDescriptor<?> desc, Type... contracts) {
+        AbstractActiveDescriptor<?> binding;
+        if (contracts.length == 0) {
+            binding = BuilderHelper.createConstantDescriptor(desc.getService());
+        } else {
+            binding = BuilderHelper.createConstantDescriptor(desc.getService(), null, contracts);
+        }
+
         binding.setName(desc.getName());
         binding.setClassAnalysisName(desc.getAnalyzer());
 
@@ -330,10 +351,14 @@ private static void bindInstanceDescriptor(ServiceLocator locator, DynamicConfig
             binding.setProxyForSameScope(desc.isProxiedForSameScope());
         }
 
-        ActiveDescriptor<Object> activeDescriptor = dc.bind(binding);
-        for (AliasDescriptor alias : desc.getAliases()) {
-            dc.bind(createAlias(locator, activeDescriptor, alias));
-        }
+        return binding;
+    }
+
+    private static ActiveDescriptor<?> translateToActiveDescriptor(InjectionResolverDescriptor<?> desc) {
+        ParameterizedTypeImpl parameterizedType = new ParameterizedTypeImpl(
+                org.glassfish.jersey.spi.inject.InjectionResolver.class, desc.getResolver().getAnnotation());
+
+        return BuilderHelper.createConstantDescriptor(desc.getResolver(), null, parameterizedType);
     }
 
     /**