athenz.shade.zts.org.glassfish.jersey.inject.hk2.AbstractHk2InjectionManager Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of athenz-zts-java-client Show documentation
ZTS Java Client Library
There is a newer version: 1.11.59
Show newest version
/*
 * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0, which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * This Source Code may also be made available under the following Secondary
 * Licenses when the conditions for such availability set forth in the
 * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
 * version 2 with the GNU Classpath Exception, which is available at
 * https://www.gnu.org/software/classpath/license.html.
 *
 * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 */

package athenz.shade.zts.athenz.shade.zts.org.glassfish.jersey.inject.hk2;

import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;

import athenz.shade.zts.athenz.shade.zts.org.glassfish.jersey.internal.inject.Binding;
import athenz.shade.zts.athenz.shade.zts.org.glassfish.jersey.internal.inject.ClassBinding;
import athenz.shade.zts.athenz.shade.zts.org.glassfish.jersey.internal.inject.ForeignDescriptor;
import athenz.shade.zts.athenz.shade.zts.org.glassfish.jersey.internal.inject.InjectionManager;
import athenz.shade.zts.athenz.shade.zts.org.glassfish.jersey.internal.inject.InstanceBinding;
import athenz.shade.zts.athenz.shade.zts.org.glassfish.jersey.internal.inject.ServiceHolder;
import athenz.shade.zts.athenz.shade.zts.org.glassfish.jersey.internal.inject.ServiceHolderImpl;

import athenz.shade.zts.athenz.shade.zts.org.glassfish.hk2.api.ActiveDescriptor;
import athenz.shade.zts.athenz.shade.zts.org.glassfish.hk2.api.Descriptor;
import athenz.shade.zts.athenz.shade.zts.org.glassfish.hk2.api.ServiceLocator;
import athenz.shade.zts.athenz.shade.zts.org.glassfish.hk2.api.ServiceLocatorFactory;
import athenz.shade.zts.athenz.shade.zts.org.glassfish.hk2.utilities.ServiceLocatorUtilities;

import athenz.shade.zts.athenz.shade.zts.org.jvnet.hk2.external.runtime.ServiceLocatorRuntimeBean;

/**
 * Abstract class dedicated to implementations of {@link InjectionManager} providing several convenient methods.
 *
 * @author Petr Bouda
 */
abstract class AbstractHk2InjectionManager implements InjectionManager {

    private static final Logger LOGGER = Logger.getLogger(AbstractHk2InjectionManager.class.getName());

    private static final ServiceLocatorFactory factory = ServiceLocatorFactory.getInstance();

    private ServiceLocator locator;

    /**
     * Private constructor.
     *
     * @param parent parent of type {@link athenz.shade.zts.athenz.shade.zts.org.glassfish.jersey.internal.inject.InjectionManager} or {@link ServiceLocator}.
     */
    AbstractHk2InjectionManager(Object parent) {
        ServiceLocator parentLocator = resolveServiceLocatorParent(parent);
        this.locator = createLocator(parentLocator);

        // Register all components needed for proper HK2 locator bootstrap
        ServiceLocatorUtilities.bind(locator, new Hk2BootstrapBinder(locator));

        this.locator.setDefaultClassAnalyzerName(JerseyClassAnalyzer.NAME);

        // clear HK2 caches
        ServiceLocatorRuntimeBean serviceLocatorRuntimeBean = locator.getService(ServiceLocatorRuntimeBean.class);
        if (serviceLocatorRuntimeBean != null) {
            if (LOGGER.isLoggable(Level.FINE)) {
                LOGGER.fine(LocalizationMessages.HK_2_CLEARING_CACHE(serviceLocatorRuntimeBean.getServiceCacheSize(),
                        serviceLocatorRuntimeBean.getReflectionCacheSize()));
            }
            serviceLocatorRuntimeBean.clearReflectionCache();
            serviceLocatorRuntimeBean.clearServiceCache();
        }
    }


    /**
     * Creates a new {@link ServiceLocator} instance from static {@link ServiceLocatorFactory} and adds the provided parent
     * locator if the instance is not null.
     *
     * @param parentLocator parent locator, can be {@code null}.
     * @return new instance of injection manager.
     */
    private static ServiceLocator createLocator(ServiceLocator parentLocator) {
        ServiceLocator result = factory.create(null, parentLocator, null, ServiceLocatorFactory.CreatePolicy.DESTROY);
        result.setNeutralContextClassLoader(false);
        ServiceLocatorUtilities.enablePerThreadScope(result);
        return result;
    }

    private static ServiceLocator resolveServiceLocatorParent(Object parent) {
        assertParentLocatorType(parent);

        ServiceLocator parentLocator = null;
        if (parent != null) {
            if (parent instanceof ServiceLocator) {
                parentLocator = (ServiceLocator) parent;
            } else if (parent instanceof AbstractHk2InjectionManager) {
                parentLocator = ((AbstractHk2InjectionManager) parent).getServiceLocator();
            }
        }
        return parentLocator;
    }

    /**
     * Checks if the parent is null then must be an instance of {@link ServiceLocator} or {@link InjectionManager}.
     *
     * @param parent object represented by {@code ServiceLocator} or {@code HK2InjectionManager}.
     */
    private static void assertParentLocatorType(Object parent) {
        if (parent != null && !(parent instanceof ServiceLocator || parent instanceof AbstractHk2InjectionManager)) {
            throw new IllegalArgumentException(
                    LocalizationMessages.HK_2_UNKNOWN_PARENT_INJECTION_MANAGER(parent.getClass().getSimpleName()));
        }
    }

    public ServiceLocator getServiceLocator() {
        return locator;
    }

    @Override
    public boolean isRegistrable(Class clazz) {
        return athenz.shade.zts.athenz.shade.zts.org.glassfish.hk2.utilities.Binder.class.isAssignableFrom(clazz);
    }

    @Override
    @SuppressWarnings("unchecked")
    public  List> getAllServiceHolders(Class contract, Annotation... qualifiers) {
        return getServiceLocator().getAllServiceHandles(contract, qualifiers).stream()
                .map(sh -> new ServiceHolderImpl<>(
                        sh.getService(),
                        (Class) sh.getActiveDescriptor().getImplementationClass(),
                        sh.getActiveDescriptor().getContractTypes(),
                        sh.getActiveDescriptor().getRanking()))
                .collect(Collectors.toList());
    }

    @Override
    public  T getInstance(Class clazz, Annotation... annotations) {
        return getServiceLocator().getService(clazz, annotations);
    }

    @Override
    public  T getInstance(Type clazz) {
        return getServiceLocator().getService(clazz);
    }

    @Override
    public Object getInstance(ForeignDescriptor foreignDescriptor) {
        return getServiceLocator().getServiceHandle((ActiveDescriptor) foreignDescriptor.get()).getService();
    }

    @Override
    public  T getInstance(Class clazz) {
        return getServiceLocator().getService(clazz);
    }

    @Override
    public  T getInstance(Class clazz, String classAnalyzer) {
        return getServiceLocator().getService(clazz, classAnalyzer);
    }

    @Override
    public  List getAllInstances(Type clazz) {
        return getServiceLocator().getAllServices(clazz);
    }

    @Override
    public void preDestroy(Object preDestroyMe) {
        getServiceLocator().preDestroy(preDestroyMe);
    }

    @Override
    public void shutdown() {
        if (factory.find(getServiceLocator().getName()) != null) {
            factory.destroy(getServiceLocator().getName());
        } else {
            getServiceLocator().shutdown();
        }
    }

    @Override
    public  U createAndInitialize(Class clazz) {
        return getServiceLocator().createAndInitialize(clazz);
    }

    @Override
    public ForeignDescriptor createForeignDescriptor(Binding binding) {
        ForeignDescriptor foreignDescriptor = createAndTranslateForeignDescriptor(binding);
        ActiveDescriptor