import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
@Override
protected Object createTest() throws Exception
{
    BeanManager beanManager = BeanManagerProvider.getInstance().getBeanManager();

    Class<?> type = getTestClass().getJavaClass();
    Set<Bean<?>> beans = beanManager.getBeans(type);

    Object result;
    if (!USE_TEST_CLASS_AS_CDI_BEAN || beans == null || beans.isEmpty())
    {
        result = super.createTest();
        BeanProvider.injectFields(result); //fallback to simple injection
    }
    else
    {
        Bean<Object> bean = (Bean<Object>) beanManager.resolve(beans);
        CreationalContext<Object> creationalContext = beanManager.createCreationalContext(bean);
        result = beanManager.getReference(bean, type, creationalContext);
    }
    return result;
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
private synchronized void initGlobalEntityManager()
{
    // switch into paranoia mode
    if (this.globalEntityManagerInitialized == null)
    {
        this.globalEntityManagerInitialized = true;
        
        BeanManager beanManager = BeanManagerProvider.getInstance().getBeanManager();
        Set<Bean<?>> beans = beanManager.getBeans(EntityManager.class);
        Bean<?> bean = beanManager.resolve(beans);

        if (bean == null)
        {
            throw new IllegalStateException("Could not find EntityManager with default qualifier.");
        }
        
        globalEntityManagerIsNormalScope = beanManager.isNormalScope(bean.getScope());
        if (globalEntityManagerIsNormalScope)
        {
            globalEntityManager = (EntityManager) beanManager.getReference(bean,
                    EntityManager.class,
                    beanManager.createCreationalContext(bean));       
        }
    }
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
@Override
public Properties getEntityManagerFactoryConfiguration(String persistenceUnitName)
{
    Properties unitProperties = PropertyLoader.getProperties("persistence-" + persistenceUnitName);

    if (unitProperties == null)
    {
        unitProperties = new Properties();
    }

    // apply ConfigFilters to the configured values.
    for (Map.Entry entry : unitProperties.entrySet())
    {
        String key = (String) entry.getKey();
        String value = (String) entry.getValue();

        entry.setValue(ConfigResolver.filterConfigValue(key, value));
    }

    unitProperties = addConfigProperties(unitProperties, persistenceUnitName);

    // add spec expected attributes
    unitProperties.put("javax.persistence.bean.manager", BeanManagerProvider.getInstance().getBeanManager());

    return unitProperties;
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public Object redefineParameterValue(ParameterValue value)
{
    CreationalContext<?> ctx = BeanManagerProvider.getInstance().getBeanManager()
            .createCreationalContext(declaringBean);

    try
    {
        if (value.getPosition() == handlerMethod.getHandlerParameter().getPosition())
        {
            return event;
        }
        return value.getDefaultValue(ctx);
    }
    finally
    {
        if (ctx != null)
        {
            ctx.release();
        }
    }
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
@Override
public void sessionDestroyed(ClientSession dolphinSession) {
    Assert.requireNonNull(dolphinSession, "dolphinSession");
    BeanManager bm = BeanManagerProvider.getInstance().getBeanManager();
    ClientScopeContext clientContext = (ClientScopeContext) bm.getContext(ClientScoped.class);
    clientContext.destroy();
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
public String getCdiVersion() {
    try {
        return ClassUtils.getJarVersion(BeanManagerProvider.getInstance().getBeanManager().getClass());
    } catch (Exception e) {
        e.printStackTrace();
        return "Failed to get CDI Version: " + e.getMessage();
    }
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
@Override
public void evaluate() throws Throwable
{
    BeanManager beanManager = BeanManagerProvider.getInstance().getBeanManager();
    Class<?> type = this.method.getMethod().getDeclaringClass();
    Set<Bean<?>> beans = beanManager.getBeans(type);

    if (!USE_TEST_CLASS_AS_CDI_BEAN || beans == null || beans.isEmpty())
    {
        if (!ALLOW_INJECTION_POINT_MANIPULATION)
        {
            BeanProvider.injectFields(this.originalTarget); //fallback to simple injection
        }
        invokeMethod(this.originalTarget);
    }
    else
    {
        Bean<Object> bean = (Bean<Object>) beanManager.resolve(beans);

        CreationalContext<Object> creationalContext = beanManager.createCreationalContext(bean);

        Object target = beanManager.getReference(bean, type, creationalContext);

        try
        {
            invokeMethod(target);
        }
        finally
        {
            if (bean.getScope().equals(Dependent.class))
            {
                bean.destroy(target, creationalContext);
            }
        }
    }
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
protected BeanManager getBeanManager()
{
    if (beanManager == null)
    {
        synchronized (this)
        {
            if (beanManager == null)
            {
                beanManager = BeanManagerProvider.getInstance().getBeanManager();
            }
        }
    }

    return beanManager;
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
@PrePersist
public void persist(Object entity)
{
    BeanManager beanManager = BeanManagerProvider.getInstance().getBeanManager();
    Set<Bean<?>> beans = beanManager.getBeans(PrePersistAuditListener.class);
    for (Bean<?> bean : beans)
    {
        PrePersistAuditListener result = (PrePersistAuditListener) beanManager.getReference(
                bean, PrePersistAuditListener.class, beanManager.createCreationalContext(bean));
        result.prePersist(entity);
    }
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
@PreUpdate
public void update(Object entity)
{
    BeanManager beanManager = BeanManagerProvider.getInstance().getBeanManager();
    Set<Bean<?>> beans = beanManager.getBeans(PreUpdateAuditListener.class);
    for (Bean<?> bean : beans)
    {
        PreUpdateAuditListener result = (PreUpdateAuditListener) beanManager.getReference(
                bean, PreUpdateAuditListener.class, beanManager.createCreationalContext(bean));
        result.preUpdate(entity);
    }
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
@Test
public void testPersistenceConfigurationProvider()
{
    Properties myUnitConfig = persistenceConfigurationProvider.getEntityManagerFactoryConfiguration("MyUnit");
    Assert.assertEquals(4, myUnitConfig.size());
    Assert.assertEquals(BeanManagerProvider.getInstance().getBeanManager(), myUnitConfig.get("javax.persistence.bean.manager"));
    Assert.assertEquals("blub", myUnitConfig.get("javax.persistence.jdbc.password"));
    Assert.assertEquals("sa", myUnitConfig.get("javax.persistence.jdbc.user"));
    Assert.assertEquals("some.jdbc.Driver", myUnitConfig.get("javax.persistence.jdbc.driver"));
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
public static Converter resolveManagedConverter(Class<? extends Converter> converterClass)
{
    if (JAVAX_FACES_CONVERT_PACKAGE_NAME.equals(converterClass.getPackage().getName()))
    {
        return null;
    }

    return getContextualReference(BeanManagerProvider.getInstance().getBeanManager(), converterClass);
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
public static Validator resolveManagedValidator(Class<? extends Validator> validatorClass)
{
    if (JAVAX_FACES_VALIDATOR_PACKAGE_NAME.equals(validatorClass.getPackage().getName()))
    {
        return null;
    }

    return getContextualReference(BeanManagerProvider.getInstance().getBeanManager(), validatorClass);
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
@Override
public void processEvent(SystemEvent e) throws AbortProcessingException
{
    if (!this.isActivated)
    {
        return;
    }

    BeanManager beanManager = BeanManagerProvider.getInstance().getBeanManager();
    beanManager.fireEvent(e);
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
private synchronized void init()
{
    if (this.beanManager == null)
    {
        this.beanManager = BeanManagerProvider.getInstance().getBeanManager();
        this.navigationParameterContext =
                BeanProvider.getContextualReference(NavigationParameterContext.class);
        this.viewConfigResolver =
                BeanProvider.getContextualReference(ViewConfigResolver.class);
    }
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
private List<Interceptor<?>> resolveInterceptors(Object instance, Method method)
{
    BeanManager beanManager = BeanManagerProvider.getInstance().getBeanManager();
    
    Annotation[] interceptorBindings = extractInterceptorBindings(beanManager, instance, method);
    if (interceptorBindings.length > 0)
    {
        return beanManager.resolveInterceptors(InterceptionType.AROUND_INVOKE, interceptorBindings);
    }

    return new ArrayList<Interceptor<?>>();
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
private synchronized Object instance()
{
    final ClassLoader oldCl = Thread.currentThread().getContextClassLoader();
    Thread.currentThread().setContextClassLoader(classloader);
    try
    {
        if (instance != null)
        {
            return instance;
        }

        if (normalScope)
        {
            instance = BeanProvider.getContextualReference(clazz, qualifiers);
        }
        else
        {
            final BeanManager bm = BeanManagerProvider.getInstance().getBeanManager();
            final Set<Bean<?>> beans = bm.getBeans(clazz, qualifiers);
            if (beans == null || beans.isEmpty())
            {
                throw new IllegalStateException("Could not find beans for Type=" + clazz
                        + " and qualifiers:" + Arrays.toString(qualifiers));
            }

            final Bean<?> resolvedBean = bm.resolve(beans);
            final CreationalContext<?> creationalContext = bm.createCreationalContext(resolvedBean);
            instance = bm.getReference(resolvedBean, clazz, creationalContext);
            creationalContext.release();
        }
        return instance;
    }
    finally
    {
        Thread.currentThread().setContextClassLoader(oldCl);
    }
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
@Test
public void testBeanManagerProvider() throws Exception
{
    BeanManagerProvider bmp = BeanManagerProvider.getInstance();
    Assert.assertNotNull(bmp);

    BeanManager bm = bmp.getBeanManager();
    Assert.assertNotNull(bm);
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
public static BeanManager getBeanManager()
{
	return BeanManagerProvider.getInstance().getBeanManager();
}
 

import org.apache.deltaspike.core.api.provider.BeanManagerProvider; //导入依赖的package包/类
public String getDeltaSpikeVersion() {
    return ClassUtils.getJarVersion(BeanManagerProvider.class);
}