Adding legacy beans to CDI context: a CDI extension sample

Adding a bean which is not a CDI bean into the CDI context can easily be done through a CDI extension. However in some cases (typically when these beans are configuration aware) you need to extract their creation from the code (= configure them without updating the code. A common sample is an URL to configure.).

As a Proof Of Concept (PoC) i pushed on github cdi-light-config extension: https://github.com/rmannibucau/cdi-light-config.

It mainly relies on Apache DeltaSpike to add to CDI context configured beans.

The way it works is described in the README on the github project so I’ll deal with the internals here and more generally how to add your own beans to CDI.

The CDI extension

First we need to add a src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension file (i use maven) containing the qualified name of our extension to register it automatically as a CDI extension. In our case it just contains:

com.github.rmannibucau.cdi.configuration.LightConfigurationExtension

Then we need to make this class implementing javax.enterprise.inject.spi.Extension:

public class LightConfigurationExtension implements Extension {
...
}

This interface is just a marking interface (to be able to rely on ServiceLoader to let the CDI container load it). The method needs to be CDI observers (@Observes) matching startup/shutdown events.

In our case we just want to read a XML file containing a list of beans then register them as CDI beans. So the event we need to observe is the one after the scanning and before the validation: AfterBeanDiscovery.

public class LightConfigurationExtension implements Extension {
    void readAllConfigurations(final @Observes AfterBeanDiscovery abd, final BeanManager bm) {
        // ...
    }
}

As you can see the bean manager can be injected automatically as second parameter. It will be useful to create our beans.

Registering custom beans

I’ll not detail the configuration reading since it depends your goal (you can even imagine reading spring xml configuration if you are a bit vicious ;)). However i’ll suppose you have the following information for each bean you want to register:

• the bean name (if one)
• the qualifier(s) of the bean
• the bean class and bean types
• the way to create/destroy the bean

Once you get these information it is quite trivial to register the beans in the CDI context since Apache DeltaSpike provides a BeanBuilder utility class to simplify it.

Basically creating a CDI bean looks like:

// clazz is the bean class, types the matching types, qualifiers the corresponding set of qualifiers
final Bean<Object> bean = new BeanBuilder<Object>(beanManager)
                    .passivationCapable(true) // you can add some logic it to check it or configure it
                    .beanClass(clazz)
                    .name(name)
                    .types(types)
                    .scope(ApplicationScoped.class) // can be configurable
                    .qualifiers(qualifiers)
                    .beanLifecycle(new InstanceFactory<Object>(...))
                    .create();

Then the question is what is InstanceFactory? It is simply the hook asking you to create/destroy the bean respecting its scope:

public class InstanceFactory<T> implements ContextualLifecycle<T> {
    @Override
    public T create(final Bean<T> bean, final CreationalContext<T> creationalContext) {
        return ...; // here you really create the instance from the parameters you got when creating the bean
    }

    @Override
    public void destroy(final Bean<T> bean, final T instance, final CreationalContext<T> creationalContext) {
        // here you destroy the created instance if needed, can be calling close() if it is a Closeable for instance or nothing if not needed
    }
}

Now you have your bean you just need to register it in the CDI context. To do so simply use AfterBeanDiscovery API and addBean method:

afterBeanDiscovery.addBean(bean);

Next?

Now you know how to register an extension and how to create beans so you can add all the beans you want reading your own model. Apache DeltaSpike will propose a configuration for CDI in version 0.6 (we are working on 0.5 at the moment). However since it is really easy to read its own configuration you can already write your own extension (my PoC is about 30Ko once built and already supports some extensibility and advanced features). It allows you to integrate very quickly legacy libraries (without beans.xml) and export configuration (but take care to not export your whole IoC in configuration files which will make your application hard to maintain).

Want more content ? Keep up-to-date on my new blog

Or stay in touch on twitter @rmannibucau

Advertisement