Java ProcessInjectionTarget类代码示例

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
/**
 * Prepares the injection process of properties from a property file.
 *
 * @param pit
 * 		The actual target of process injection
 * @param <T>
 * 		the generic type of the injection target
 */
public <T> void initializePropertyLoading(@Observes final ProcessInjectionTarget<T> pit) throws IOException {
	AnnotatedType<T> at = pit.getAnnotatedType();
	if (!at.isAnnotationPresent(PropertyFile.class)) {
		return;
	}
	try {
		PropertyFile propertyFile = at.getAnnotation(PropertyFile.class);
		Properties properties = loadProperties(propertyFile, pit.getAnnotatedType().getJavaClass());
		Map<Field, Object> fieldValues = assignPropertiesToFields(at.getFields(), properties);
		InjectionTarget<T> wrapped = new PropertyInjectionTarget<T>(fieldValues, pit, pit.getInjectionTarget());
		pit.setInjectionTarget(wrapped);
	} catch (Exception e) {
		pit.addDefinitionError(e);
	}
}
 

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
@SuppressWarnings("element-type-mismatch")
   <T> void processInjectionPoint(@Observes ProcessInjectionTarget<T> pit, BeanManager beanManager) {
	for (InjectionPoint point : pit.getInjectionTarget().getInjectionPoints()) {
           if (repositoryInterfaces.contains(point.getType())) {
               log.fine(String.format("... found InjectionPoint in Class: %s with name: %s for the repository with type: %s%n", point.getBean().getBeanClass().getName(), point.getMember().getName(), point.getType()));
               String technology = "default";
               if (point.getAnnotated().isAnnotationPresent(Technology.class)) {
                   technology = point.getAnnotated().getAnnotation(Technology.class).value();
               }
               RepositoryKey key = new RepositoryKey((Class<?>) point.getType(), technology);
               if (!repositoryBeans.containsKey(key)) {
                   log.fine(String.format("... create Bean for Repository: %s with technology: %s%n", point.getType(), technology));
                   repositoryBeans.put(key, new RepositoryBean(beanManager, key));
               }
           }
	}
}
 

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
private <T> void projectInjectionTarget(MybatisExtension extension, Type type) {
  ProcessInjectionTarget<T> event = mock(ProcessInjectionTarget.class);
  InjectionTarget<T> injectTarget = mock(InjectionTarget.class);
  Set<InjectionPoint> injectionPoints = new HashSet<InjectionPoint>();

  InjectionPoint injectionPoint = mock(InjectionPoint.class);
  Annotated annotated = mock(Annotated.class);

  when(injectionPoint.getAnnotated()).thenReturn(annotated);

  when(annotated.getBaseType()).thenReturn(type);
  when(annotated.getAnnotations()).thenReturn(new HashSet<Annotation>());

  injectionPoints.add(injectionPoint);

  when(event.getInjectionTarget()).thenReturn(injectTarget);
  when(injectTarget.getInjectionPoints()).thenReturn(injectionPoints);

  extension.processInjectionTarget(event);
}
 

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
@SuppressWarnings("unused")
<T> void processInjectionTarget(@Observes ProcessInjectionTarget<T> pit, BeanManager beanManager) throws Exception {
    try (AutoCloseable handle = Performance.accumulate("ConfigurationExtension.processInjectionTarget")) {
        if (isApplicable(pit.getAnnotatedType())) {
            pit.setInjectionTarget(new ConfigurableInjectionTarget<T>(pit.getInjectionTarget(), this.configurableManager));
        }
    }
}
 

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
/**
 * Observer to a CDI lifecycle event to correctly setup the XML backed "injection".
 * @param pit CDI lifecycle callback payload
 * @param <X> Type of the Injection to observe
 */
<X extends Creature> void processInjectionTarget(@Observes ProcessInjectionTarget<X> pit) {
    Class<? extends Creature> klass = pit.getAnnotatedType().getJavaClass();
    log.info("Setting up injection target for " + klass);
    final Element entry = (Element) document.getElementsByTagName(klass.getSimpleName().toLowerCase()).item(0);
    pit.setInjectionTarget(new XmlBackedWrappedInjectionTarget<X>(pit.getInjectionTarget(), entry));
}
 

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
<T> void processInjectionPoint(@Observes ProcessInjectionTarget<T> pit) {
	for (InjectionPoint point : pit.getInjectionTarget().getInjectionPoints()) {
           if (messageBundleInterfaces.containsKey(point.getType())) {
               System.out.printf("... found InjectionPoint for MessageBundle: %s of type %s%n", point.getMember().getName(), point.getType());
		}
	}
}
 

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
/**
 * Collect all targets to match Mappers and Session providers dependency.
 *
 * @param <X> the generic type
 * @param event the event
 */
protected <X> void processInjectionTarget(@Observes ProcessInjectionTarget<X> event) {
  final InjectionTarget<X> it = event.getInjectionTarget();
  for (final InjectionPoint ip : it.getInjectionPoints()) {
    injectionPoints.add(ip);
  }
}
 

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
<T> void processInjectionTarget(@Observes ProcessInjectionTarget<T> pit) {
	logger.info("finished the scanning process");
	processInjectionTarget++;
}
 

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
private <T extends CamelContext> void camelContextBeans(@Observes ProcessInjectionTarget<T> pit, BeanManager manager) {
    pit.setInjectionTarget(environment.camelContextInjectionTarget(pit.getInjectionTarget(), pit.getAnnotatedType(), manager, this));
}
 

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
private <T> void camelBeansPostProcessor(@Observes ProcessInjectionTarget<T> pit, BeanManager manager) {
    if (camelBeans.contains(pit.getAnnotatedType())) {
        pit.setInjectionTarget(new CamelBeanInjectionTarget<>(pit.getInjectionTarget(), manager));
    }
}
 

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
private <T extends CamelContextAware> void camelContextAware(@Observes ProcessInjectionTarget<T> pit, BeanManager manager) {
    pit.setInjectionTarget(new CamelBeanInjectionTarget<>(pit.getInjectionTarget(), manager));
}
 

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
<X> void logLifecycleEvent(@Observes ProcessInjectionTarget<X> event) {
    LOGGER.info("ProcessInjectionTarget: annotatedType=" + event.getAnnotatedType());
}
 

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
private <T extends CamelContext> void camelContextBeans(@Observes ProcessInjectionTarget<T> pit, BeanManager manager) {
    pit.setInjectionTarget(environment.camelContextInjectionTarget(pit.getInjectionTarget(), pit.getAnnotatedType(), manager));
}
 

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
private <T> void camelBeansPostProcessor(@Observes ProcessInjectionTarget<T> pit, BeanManager manager) {
    if (camelBeans.contains(pit.getAnnotatedType()))
        pit.setInjectionTarget(new CamelBeanInjectionTarget<>(pit.getInjectionTarget(), manager));
}
 

import javax.enterprise.inject.spi.ProcessInjectionTarget; //导入依赖的package包/类
/**
 * Handle all injections
 * 
 * @param pit ProcessInjectionTarget to inspect.
 **/
@SuppressWarnings({ "unchecked", "rawtypes" })
public void processInjectorTarger(@Observes ProcessInjectionTarget<Object> pit) {
     pit.setInjectionTarget(new RegisterWebSocketEventListenerInjectionTarget(pit.getInjectionTarget(), listenerCandidates, servletConfigs));         
   
}