Java InjectionTarget.inject方法代码示例

import javax.enterprise.inject.spi.InjectionTarget; //导入方法依赖的package包/类
@Test
public void testInjectionTarget() {
	BeanManager beanManager = current().getBeanManager();
	// CDI uses an AnnotatedType object to read the annotations of a class
	AnnotatedType<String> type = beanManager.createAnnotatedType(String.class);
	// The extension uses an InjectionTarget to delegate instantiation,
	// dependency injection
	// and lifecycle callbacks to the CDI container
	InjectionTarget<String> it = beanManager.createInjectionTarget(type);
	// each instance needs its own CDI CreationalContext
	CreationalContext<String> ctx = beanManager.createCreationalContext(null);
	// instantiate the framework component and inject its dependencies
	String instance = it.produce(ctx); // call the constructor
	it.inject(instance, ctx); // call initializer methods and perform field
								// injection
	it.postConstruct(instance); // call the @PostConstruct method
	// destroy the framework component instance and clean up dependent
	// objects
	assertNotNull("the String instance is injected now", instance);
	assertTrue("the String instance is injected now but it's empty", instance.isEmpty());
	it.preDestroy(instance); // call the @PreDestroy method
	it.dispose(instance); // it is now safe to discard the instance
	ctx.release(); // clean up dependent objects
}
 

import javax.enterprise.inject.spi.InjectionTarget; //导入方法依赖的package包/类
@Override
public Producer createProducer() throws IllegalAccessException {
    // FIXME: to be replaced once event firing with dynamic parameterized type
    // is properly supported (see https://issues.jboss.org/browse/CDI-516)
    TypeLiteral<T> literal = new TypeLiteral<T>() {
    };
    for (Field field : TypeLiteral.class.getDeclaredFields()) {
        if (field.getType().equals(Type.class)) {
            field.setAccessible(true);
            field.set(literal, type);
            break;
        }
    }

    InjectionTarget<AnyEvent> target = manager.createInjectionTarget(manager.createAnnotatedType(AnyEvent.class));
    CreationalContext<AnyEvent> ctx = manager.createCreationalContext(null);
    AnyEvent instance = target.produce(ctx);
    target.inject(instance, ctx);
    return new CdiEventProducer<>(this, instance.event
        .select(literal, qualifiers.stream().toArray(Annotation[]::new)));
}
 

import javax.enterprise.inject.spi.InjectionTarget; //导入方法依赖的package包/类
private static <T> T newInstance(final OpenEjbConfig config, final Class<T> clazz) throws Exception {
    final WebBeansContext webBeansContext = AppFinder.findAppContextOrWeb(
            Thread.currentThread().getContextClassLoader(), AppFinder.WebBeansContextTransformer.INSTANCE);
    if (webBeansContext == null) {
        return clazz.newInstance();
    }

    final BeanManagerImpl beanManager = webBeansContext.getBeanManagerImpl();
    if (!beanManager.isInUse()) {
        return clazz.newInstance();
    }

    final AnnotatedType<T> annotatedType = beanManager.createAnnotatedType(clazz);
    final InjectionTarget<T> it = beanManager.createInjectionTarget(annotatedType);
    final CreationalContext<T> context = beanManager.createCreationalContext(null);
    final T instance = it.produce(context);
    it.inject(instance, context);
    it.postConstruct(instance);

    config.releasables.add(new Releasable<T>(context, it, instance));

    return instance;
}
 

import javax.enterprise.inject.spi.InjectionTarget; //导入方法依赖的package包/类
/**
 * Manually inject dependencies. Inspired by https://developer.jboss.org/thread/196807
 *
 * @param clazz
 * @param injectionObject
 * @throws NamingException
 */
public static <T> T programmaticInjection(Class<T> clazz, T injectionObject) throws NamingException {
	InitialContext initialContext = new InitialContext();
	Object lookup = initialContext.lookup("java:comp/BeanManager");
	BeanManager beanManager = (BeanManager) lookup;

	AnnotatedType<T> annotatedType = beanManager.createAnnotatedType(clazz);
	InjectionTarget<T> injectionTarget = beanManager.createInjectionTarget(annotatedType);
	CreationalContext<T> creationalContext = beanManager.createCreationalContext(null);
	injectionTarget.inject(injectionObject, creationalContext);

	injectionTarget.postConstruct(injectionObject); //call the @PostConstruct method
	creationalContext.release();

	return injectionObject;
}
 

import javax.enterprise.inject.spi.InjectionTarget; //导入方法依赖的package包/类
@Before
public final void setUp() throws Exception {
    System.out.printf("AbstractCdiContainerTest#setUp() containerRefCount=%d, cdiContainer=%s\n", containerRefCount.get(), cdiContainer );

    if ( cdiContainer != null ) {
        containerRefCount.incrementAndGet();

        final ContextControl ctxCtrl = BeanProvider.getContextualReference(ContextControl.class);

        //stop the RequestContext to dispose of the @RequestScoped EntityManager
        ctxCtrl.stopContext(RequestScoped.class);

        //immediately restart the context again
        ctxCtrl.startContext(RequestScoped.class);

        // perform injection into the very own test class
        final BeanManager beanManager = cdiContainer.getBeanManager();
        final CreationalContext creationalContext = beanManager.createCreationalContext(null);

        final AnnotatedType annotatedType = beanManager.createAnnotatedType(this.getClass());
        final InjectionTarget injectionTarget = beanManager.createInjectionTarget(annotatedType);
        injectionTarget.inject(this, creationalContext);
    }
}
 

import javax.enterprise.inject.spi.InjectionTarget; //导入方法依赖的package包/类
/**
 * Performs dependency injection on an instance. Useful for instances which aren't managed by CDI.
 * <p/>
 * <b>Attention:</b><br/>
 * The resulting instance isn't managed by CDI; only fields annotated with @Inject get initialized.
 *
 * @param instance current instance
 * @param <T>      current type
 *
 * @return instance with injected fields (if possible - or null if the given instance is null)
 */
@SuppressWarnings("unchecked")
public static <T> T injectFields(T instance)
{
    if (instance == null)
    {
        return null;
    }

    BeanManager beanManager = getBeanManager();

    CreationalContext<T> creationalContext = beanManager.createCreationalContext(null);

    AnnotatedType<T> annotatedType = beanManager.createAnnotatedType((Class<T>) instance.getClass());
    InjectionTarget<T> injectionTarget = beanManager.createInjectionTarget(annotatedType);
    injectionTarget.inject(instance, creationalContext);
    return instance;
}
 

import javax.enterprise.inject.spi.InjectionTarget; //导入方法依赖的package包/类
void inject() {
    BeanManager beanManager = container.getBeanManager();
    CreationalContext<Object> ctx = beanManager.createCreationalContext(null);
    @SuppressWarnings("unchecked")
    InjectionTarget<Object> injectionTarget = (InjectionTarget<Object>) beanManager
            .getInjectionTargetFactory(beanManager.createAnnotatedType(instance.getClass())).createInjectionTarget(null);
    injectionTarget.inject(instance, ctx);
    creationalContext = ctx;
}
 

import javax.enterprise.inject.spi.InjectionTarget; //导入方法依赖的package包/类
/**
 * Perform injection into a non-CDI managed bean.
 * <p>
 * An example of this is a JSP Tag
 * <p>
 * @param <T>
 * @param bean
 */
public static <T> T inject( T bean )
{
    BeanManager beanManager = getBeanManager();
    AnnotatedType<T> annotatedType = beanManager.<T>createAnnotatedType( (Class<T>) bean.getClass() );
    InjectionTarget<T> injectionTarget = beanManager.createInjectionTarget( annotatedType );
    CreationalContext ctx = beanManager.createCreationalContext( null );
    injectionTarget.inject( bean, ctx );
    return bean;
}
 

import javax.enterprise.inject.spi.InjectionTarget; //导入方法依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
public static <T> void programmaticInjection(Class clazz, T injectionObject) throws NamingException {
	InitialContext initialContext = new InitialContext();
	Object lookup = initialContext.lookup("java:comp/BeanManager");
	BeanManager beanManager = (BeanManager) lookup;
	AnnotatedType annotatedType = beanManager.createAnnotatedType(clazz);
	InjectionTarget injectionTarget = beanManager.createInjectionTarget(annotatedType);
	CreationalContext creationalContext = beanManager.createCreationalContext(null);
	injectionTarget.inject(injectionObject, creationalContext);
	creationalContext.release();
}
 

import javax.enterprise.inject.spi.InjectionTarget; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public static <T> T injectFields(final BeanManager beanManager, final T instance) {
	if (instance == null) {
		return null;
	}

	CreationalContext<T> creationalContext = beanManager.createCreationalContext(null);

	AnnotatedType<T> annotatedType = beanManager
			.createAnnotatedType((Class<T>) instance.getClass());
	InjectionTarget<T> injectionTarget = beanManager.createInjectionTarget(annotatedType);
	injectionTarget.inject(instance, creationalContext);
	return instance;
}
 

import javax.enterprise.inject.spi.InjectionTarget; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public void injectMembers(Object instance) {
	final BeanManager bm = getBeanManager();

	final CreationalContext creationalContext = getCreationalContext();
	InjectionTarget<Object> injectionTarget = (InjectionTarget<Object>) bm.createInjectionTarget(
			bm.createAnnotatedType(instance.getClass()));
	injectionTarget.inject(instance, creationalContext);
}