Merge "Splitting RequestScope class into Jersey specific part and HK2 Context implementation for a creation and destroying instances." into 2.x

Author: Petr Bouda

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

@@ -53,13 +53,13 @@
 import org.glassfish.jersey.internal.inject.ClassBinding;
 import org.glassfish.jersey.internal.inject.CompositeBinder;
 import org.glassfish.jersey.internal.inject.ForeignDescriptor;
-import org.glassfish.jersey.internal.inject.ForeignDescriptorImpl;
 import org.glassfish.jersey.internal.inject.InjectionManager;
 import org.glassfish.jersey.internal.inject.InstanceBinding;
 import org.glassfish.jersey.internal.inject.ServiceHolder;
 import org.glassfish.jersey.internal.inject.ServiceHolderImpl;
 
 import org.glassfish.hk2.api.ActiveDescriptor;
+import org.glassfish.hk2.api.Descriptor;
 import org.glassfish.hk2.api.ServiceLocator;
 import org.glassfish.hk2.api.ServiceLocatorFactory;
 import org.glassfish.hk2.utilities.ServiceLocatorUtilities;
@@ -233,12 +233,13 @@ public Object getInstance(ForeignDescriptor foreignDescriptor) {
     public ForeignDescriptor createForeignDescriptor(Binding binding) {
         ForeignDescriptor foreignDescriptor = createAndTranslateForeignDescriptor(binding);
         ActiveDescriptor<Object> activeDescriptor = ServiceLocatorUtilities
-                .addOneDescriptor(locator, (org.glassfish.hk2.api.Descriptor) foreignDescriptor.get(), false);
-        return new ForeignDescriptorImpl(activeDescriptor);
+                .addOneDescriptor(locator, (Descriptor) foreignDescriptor.get(), false);
+        return ForeignDescriptor.wrap(activeDescriptor, activeDescriptor::dispose);
     }
 
+    @SuppressWarnings("unchecked")
     private ForeignDescriptor createAndTranslateForeignDescriptor(Binding binding) {
-        ActiveDescriptor<?> activeDescriptor;
+        ActiveDescriptor activeDescriptor;
         if (ClassBinding.class.isAssignableFrom(binding.getClass())) {
             activeDescriptor = Hk2Helper.translateToActiveDescriptor((ClassBinding<?>) binding);
         } else if (InstanceBinding.class.isAssignableFrom(binding.getClass())) {
@@ -247,7 +248,7 @@ private ForeignDescriptor createAndTranslateForeignDescriptor(Binding binding) {
             throw new RuntimeException(LocalizationMessages.UNKNOWN_DESCRIPTOR_TYPE(binding.getClass().getSimpleName()));
         }
 
-        return new ForeignDescriptorImpl(activeDescriptor);
+        return ForeignDescriptor.wrap(activeDescriptor, activeDescriptor::dispose);
     }
 
     @Override

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

@@ -72,6 +72,8 @@ protected void configure() {
                 new HK2InjectionManagerBinder(injectionManager),
                 // Jersey-like class analyzer that is able to choose the right services' construtor.
                 new JerseyClassAnalyzer.Binder(injectionManager),
+                // Activate possibility to start Request Scope.
+                new RequestContext.Binder(),
                 // Add support for Context annotation.
                 new ContextInjectionResolverImpl.Binder(),
                 // Compose together the initialization binders and bind them as a whole.

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

@@ -0,0 +1,128 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * 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
+ * and Distribution License("CDDL") (collectively, the "License").  You
+ * may not use this file except in compliance with the License.  You can
+ * obtain a copy of the License at
+ * http://glassfish.java.net/public/CDDL+GPL_1_1.html
+ * or packager/legal/LICENSE.txt.  See the License for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing the software, include this License Header Notice in each
+ * file and include the License file at packager/legal/LICENSE.txt.
+ *
+ * GPL Classpath Exception:
+ * Oracle designates this particular file as subject to the "Classpath"
+ * exception as provided by Oracle in the GPL Version 2 section of the License
+ * file that accompanied this code.
+ *
+ * Modifications:
+ * If applicable, add the following below the License Header, with the fields
+ * enclosed by brackets [] replaced by your own identifying information:
+ * "Portions Copyright [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ * If you wish your version of this file to be governed by only the CDDL or
+ * only the GPL Version 2, indicate your decision by adding "[Contributor]
+ * elects to include this software in this distribution under the [CDDL or GPL
+ * Version 2] license."  If you don't indicate a single choice of license, a
+ * recipient has the option to distribute your version of this file under
+ * either the CDDL, the GPL Version 2 or to extend the choice of license to
+ * its licensees as provided above.  However, if you add GPL Version 2 code
+ * and therefore, elected the GPL Version 2 license, then the option applies
+ * only if the new code is made subject to such option by the copyright
+ * holder.
+ */
+
+package org.glassfish.jersey.hk2;
+
+import java.lang.annotation.Annotation;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.glassfish.jersey.internal.inject.AbstractBinder;
+import org.glassfish.jersey.internal.inject.ForeignDescriptor;
+import org.glassfish.jersey.process.internal.RequestScope;
+import org.glassfish.jersey.process.internal.RequestScoped;
+
+import org.glassfish.hk2.api.ActiveDescriptor;
+import org.glassfish.hk2.api.Context;
+import org.glassfish.hk2.api.ServiceHandle;
+import org.glassfish.hk2.api.TypeLiteral;
+
+/**
+ * Class is able to communicate with {@link RequestScope} and provide request-scoped descriptors to HK2 DI provider to create or
+ * destroy instances.
+ */
+@Singleton
+public class RequestContext implements Context<RequestScoped> {
+
+    private final RequestScope requestScope;
+
+    @Inject
+    public RequestContext(RequestScope requestScope) {
+        this.requestScope = requestScope;
+    }
+
+    @Override
+    public Class<? extends Annotation> getScope() {
+        return RequestScoped.class;
+    }
+
+    @Override
+    public <U> U findOrCreate(ActiveDescriptor<U> activeDescriptor, ServiceHandle<?> root) {
+        final RequestScope.Instance instance = requestScope.current();
+
+        U retVal = instance.get(ForeignDescriptor.wrap(activeDescriptor));
+        if (retVal == null) {
+            retVal = activeDescriptor.create(root);
+            instance.put(ForeignDescriptor.wrap(activeDescriptor, obj -> activeDescriptor.dispose((U) obj)), retVal);
+        }
+        return retVal;
+    }
+
+    @Override
+    public boolean containsKey(ActiveDescriptor<?> descriptor) {
+        RequestScope.Instance instance = requestScope.current();
+        return instance.contains(ForeignDescriptor.wrap(descriptor));
+    }
+
+    @Override
+    public boolean supportsNullCreation() {
+        return true;
+    }
+
+    @Override
+    public boolean isActive() {
+        return requestScope.isActive();
+    }
+
+    @Override
+    public void destroyOne(ActiveDescriptor<?> descriptor) {
+        RequestScope.Instance instance = requestScope.current();
+        instance.remove(ForeignDescriptor.wrap(descriptor));
+    }
+
+    @Override
+    public void shutdown() {
+        requestScope.shutdown();
+    }
+
+    /**
+     * Request scope injection binder.
+     */
+    public static class Binder extends AbstractBinder {
+
+        @Override
+        protected void configure() {
+            bindAsContract(RequestContext.class)
+                    .to(new TypeLiteral<Context<RequestScoped>>() {}.getType())
+                    .in(Singleton.class);
+        }
+    }
+}

core-common/src/main/java/org/glassfish/jersey/internal/inject/ForeignDescriptor.java

@@ -40,6 +40,8 @@
 
 package org.glassfish.jersey.internal.inject;
 
+import java.util.function.Consumer;
+
 /**
  * The descriptor holder for an externally provided DI providers. Using this interface DI provider is able to provider his own
  * descriptor which can be used and returned to the DI provider in further processing.
@@ -56,4 +58,33 @@ public interface ForeignDescriptor {
      */
     Object get();
 
+    /**
+     * Disposes this instance. All the PerLookup objects that were created for this instance will be destroyed after this
+     * object has been destroyed.
+     *
+     * @param instance The instance to destroy.
+     */
+    void dispose(Object instance);
+
+    /**
+     * Wraps incoming descriptor instance and provides a default implementation of {@link ForeignDescriptor}.
+     *
+     * @param descriptor incoming foreign descriptor.
+     * @return wrapped foreign descriptor.
+     */
+     static ForeignDescriptor wrap(Object descriptor) {
+        return new ForeignDescriptorImpl(descriptor);
+    }
+
+    /**
+     * Wraps incoming descriptor instance and provides a default implementation of {@link ForeignDescriptor} along with a
+     * {@link Consumer} for a disposing an instance created using a given descriptor.
+     *
+     * @param descriptor      incoming foreign descriptor.
+     * @param disposeInstance consumer which is able to dispose an instance created with the given descriptor.
+     * @return wrapped foreign descriptor.
+     */
+    static ForeignDescriptor wrap(Object descriptor, Consumer<Object> disposeInstance) {
+        return new ForeignDescriptorImpl(descriptor, disposeInstance);
+    }
 }

core-common/src/main/java/org/glassfish/jersey/internal/inject/ForeignDescriptorImpl.java

@@ -40,6 +40,9 @@
 
 package org.glassfish.jersey.internal.inject;
 
+import java.util.Objects;
+import java.util.function.Consumer;
+
 /**
  * The descriptor holder for an externally provided DI providers. Using this interface DI provider is able to provider his own
  * descriptor which can be used and returned to the DI provider in further processing.
@@ -49,19 +52,55 @@
  */
 public class ForeignDescriptorImpl implements ForeignDescriptor {
 
-    private Object foreignDescriptor;
+    private static final Consumer<Object> NOOP_DISPOSE_INSTANCE = instance -> {};
+
+    private final Object foreignDescriptor;
+    private final Consumer<Object> disposeInstance;
 
     /**
      * Constructor accepts a descriptor of the DI provider and to be able to provide it in further processing.
      *
      * @param foreignDescriptor DI provider's descriptor.
      */
     public ForeignDescriptorImpl(Object foreignDescriptor) {
+        this(foreignDescriptor, NOOP_DISPOSE_INSTANCE);
+    }
+
+    /**
+     * Constructor accepts a descriptor of the DI provider and to be able to provide it in further processing along with
+     * dispose mechanism to destroy the objects corresponding the given {@code foreign key}.
+     *
+     * @param foreignDescriptor DI provider's descriptor.
+     */
+    public ForeignDescriptorImpl(Object foreignDescriptor, Consumer<Object> disposeInstance) {
         this.foreignDescriptor = foreignDescriptor;
+        this.disposeInstance = disposeInstance;
     }
 
     @Override
     public Object get() {
         return foreignDescriptor;
     }
+
+    @Override
+    public void dispose(Object instance) {
+        disposeInstance.accept(instance);
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof ForeignDescriptorImpl)) {
+            return false;
+        }
+        final ForeignDescriptorImpl that = (ForeignDescriptorImpl) o;
+        return foreignDescriptor.equals(that.foreignDescriptor);
+    }
+
+    @Override
+    public int hashCode() {
+        return foreignDescriptor.hashCode();
+    }
 }