import javax.interceptor.AroundConstruct; //导入依赖的package包/类
@AroundConstruct
public Object aroundConstruct(InvocationContext ic) throws Exception {
	logger.info("Executing " + ic.getConstructor());
	Map<String, Object> data = ic.getContextData();
	data.forEach((k, v) -> logger.info("data key: " + k + " - value: " + v));
	return ic.proceed();
}
 

import javax.interceptor.AroundConstruct; //导入依赖的package包/类
@AroundConstruct
Object aroundConstruct(InvocationContext ctx) throws Exception {
    try {
        return ctx.proceed();
    } finally {
        if (log.isTraceEnabled()) {
            log.trace("[Lifecycle][@AroundConstruct] {}", ctx.getTarget().toString());
        }
    }
}
 

import javax.interceptor.AroundConstruct; //导入依赖的package包/类
@AroundConstruct
public Object onConstruct(InvocationContext context) throws Exception {
	// null before the InvocationContext.proceed() returns
	Object target = context.getTarget();
	isNull(target);
	// null in case of AroundConstruct
	Method method = context.getMethod();
	isNull(method);
	// NOT null in case of AroundConstruct
	Constructor ctor = context.getConstructor();
	isNotNull(ctor);

	// perform the constructor injection
	Object result = context.proceed();
	isNull(result);

	// NOT null after the InvocationContext.proceed() completes
	target = context.getTarget();
	isNotNull(target);
	// a constructor should have been called
	GreetingBean bean = (GreetingBean) target;
	isBoolean(bean.isConstructed(), true);
	isBoolean(bean.isInitialized(), false);
	// constructor injection should have been done
	isNotNull(bean.getParam());

	return null;
}
 

import javax.interceptor.AroundConstruct; //导入依赖的package包/类
@AroundConstruct
public void constructorLogger(InvocationContext ctx) throws Exception {
	System.out.println("Logging constructor: about to call the constructor at " + System.currentTimeMillis());
	// we must proceed to constructor before call getTarget(), otherwise we'll get a NullPointerException
	ctx.proceed();
	
	// now we can get the created object
	System.out.println("Logging constructor: " + ctx.getTarget() + " at " + System.currentTimeMillis());
}
 

import javax.interceptor.AroundConstruct; //导入依赖的package包/类
@AroundConstruct
public void aroundConstructed(InvocationContext ctx) throws Exception {
    LOG.log(Level.INFO, "invoke constructor:" + ctx.getConstructor() + ", arguments:" + ctx.getContextData());
    Object o = ctx.proceed();
    counter.increase();
}
 

import javax.interceptor.AroundConstruct; //导入依赖的package包/类
@AroundConstruct
private Object meteredConstructor(InvocationContext context) throws Exception {
    return meteredCallable(context, context.getConstructor());
}
 

import javax.interceptor.AroundConstruct; //导入依赖的package包/类
@AroundConstruct
private Object countedConstructor(InvocationContext context) throws Exception {
    return countedCallable(context, context.getConstructor());
}
 

import javax.interceptor.AroundConstruct; //导入依赖的package包/类
@AroundConstruct
private Object timedConstructor(InvocationContext context) throws Exception {
    return timedCallable(context, context.getConstructor());
}
 

import javax.interceptor.AroundConstruct; //导入依赖的package包/类
@AroundConstruct
public void validateConstructor(InvocationContext context) {
    System.out.println("MyAroundConstructInterceptor.validateConstructor");
}
 

import javax.interceptor.AroundConstruct; //导入依赖的package包/类
@AroundConstruct
public Object ac(InvocationContext ic) throws Exception {
    constructured = true;
    return ic.proceed();
}
 

import javax.interceptor.AroundConstruct; //导入依赖的package包/类
@AroundConstruct
private Object meteredConstructor(InvocationContext context) throws Throwable {
    return meteredCallable(context, context.getConstructor());
}
 

import javax.interceptor.AroundConstruct; //导入依赖的package包/类
@AroundConstruct
public void createCdiFXMLComponent(final InvocationContext invocationContext) throws Exception {

    // Performs c-tor invocation. Afterwards "invocationContext.getTarget()" will no longer return "null".
    invocationContext.proceed();

    // Fetches the newly created annotated object and it's class.
    final Object target = invocationContext.getTarget();
    final Class<?> targetClass = target.getClass();

    final FXMLComponent annotation = targetClass.getAnnotation(FXMLComponent.class);
    if (annotation == null) {
        throw new IllegalStateException(String.format("No @FXMLComponent annotation could be retrieved from class %s.", targetClass.getName()));
    }
    final FXMLLoader fxmlLoader = new CdiFXMLLoader();
    CdiFXMLLoaderFactory.initializeFXMLLoader(
            fxmlLoader,
            targetClass,
            annotation.location(),
            annotation.resources(),
            annotation.charset());
    fxmlLoader.setRoot(target);
    fxmlLoader.setController(target);

    // We now have to perform the actual loading of the FXML document.
    // ... we have to make sure that this happens on the right (thus: FX application) thread, though!
    if (Platform.isFxApplicationThread()) {
        fxmlLoader.load();
    } else {
        final CountDownLatch latch = new CountDownLatch(1);
        Platform.runLater(() -> {
            try {
                final Object loaded = fxmlLoader.load();
                latch.countDown();
            } catch (final IOException e) {
                throw new IllegalStateException("Loading of FXML file failed.", e);
            }
        });
        latch.await();
    }

}