Context and Dependency Injection 2.0

Context and Dependency Injection 2.0
Brian S Paskin, Senior Application Architect, R&D Services, IBM Cloud Innovations Lab
Updated 17 January 2019
WebSphere Liberty Lunch and Learn

What is Context and Dependency Injection?
2
 Context and Dependency Injection (CDI) is part of the Java Enterprise Edition (JEE)
specification (JSR-299 and JSR-330)
– Context: Manage the lifecycle of stateful components using domain specific lifecycle
contexts (Application, Request, Session, et cetera)
– Dependency Injection: Injection of loosely coupled components into client Objects
 CDI provides
– Type safety by injecting objects using a String name and is resolved by using Java types
 Qualifiers can further distinguish Objects
– Nearly all Objects can be injected (POJOs, EJBs, PersistenceUnit, et cetera)
– Allows for extending the of JEE platform without changing core behavior using the
Service Provider Interface (SPI) that is vendor independent
– Using Interceptors to inject code without having to changing the original code, but cannot
do business logic
– Using Decorators to inject code without having to change the original code, and can do
business logic
– Multiple Events can be triggered synchronously or asynchronous that are loosely coupled
– Integrated support for Expression Language (EL)

Configuration file
3
 CDI does require a configuration file called beans.xml under certain circumstances
– Belongs under the WEB-INF directory for web applications
– Belongs under META-INF directory for jar or EJB applications
– Needed for Interceptors, Decorators and Alternatives
– Needed for changing default discovery mode, which is annotated.
 Bean discover modes
– None – CDI is disabled
– Annotated (default) – only class level annotations are processed
– All – All components are processed

Configuration file
4
<beans bean-discovery-mode="all"
xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/beans_2_0.xsd">
<interceptors>
<class>com.ibm.example.cdi.interceptor.LoggingInterceptor</class>
</interceptors>
<decorators>
<class>com.ibm.example.cdi.decorator.LoggingDecorator</class>
</decorators>
<alternatives>
<class>com.ibm.example.cdi.alternative.FavoriteDoctorAlternative</class>
</alternatives>
</beans>

Simple Injection
5
 @Inject is used to specify that an Object is to be injected into the current client Object
 An Object that implements an Interface can be injected
– An interface can be injected in cases where there is only one Object implementing it
@Inject private City city;

Retrieving Beans By Name
6
 When more than one Object implements an Interface @Named should be used
– Class should be annotated with @Named
– If no @Named is found, then the class name is used by default
– @Inject must include @Named
@Named("Rome")
public class Rome implements City {
@Named("Cologne")
public class Cologne implements City {
@Inject @Named("Rome") private City city;

Lazy Injection
7
 When the Interface is known, but not Objects that implement the interface are not known
– Dynamically obtain instances of Beans using Instance<T>
– Each instance can be acted upon
@Inject private Instance<City> instance;

Context Scopes
8
 Tells the container when a Bean is created and destroyed
 Objects are annotated with a context scope
– Objects not annotated are given the default annotation @Dependent
 @Dependent – serves exactly one client Bean and has the same lifecycle of the client Bean
 @RequestScoped – lasts through a single HTTP request
 @SessionScoped – lasts through multiple HTTP requests
 @ApplicationScoped – lasts through the entire life of the application for all users
 @ConversationScope – exists in developer controlled boundaries across multiple
requests and long running conversations.
– Session boundaries cannot be crossed
 Developers can create their own scopes @RequestScoped
public class ScopeBean1 {
@ApplicationScoped
public class ScopeBean2 {

Qualifiers
9
 Provides various implementations of a particular type of bean
– Uses @Qualifer with the @Retention policy and @Target elements
 @Retention is how long annotations with the annotated type are to be retained
– Usually Runtime, the default, since CDI works with injection at runtime
 @Target specifies the program elements that the Qualifier can apply
 The name of the Qualifier is the annotation that is applied to a bean
@Qualifier
@Target({ TYPE, FIELD, METHOD, PARAMETER })
@Retention(RetentionPolicy.RUNTIME)
public @interface Favorite {
@Favorite
public class NewFavoriteDoctor extends FavoriteDoctor {
@Inject @Favorite private FavoriteDoctor doctor2;

Producers
10
 Provides a way to inject Objects that are not Beans
 Executes the @Produces annotated method when the Object is injected
– Can include a scope
 Requires a Qualifier to specify that the injection will run the annotated method on the Bean
 Disposers are optional and are called at end of life and take the parameter of the Object that
is produced and is annotated with @Disposes
@Retention(RUNTIME)
public @interface Favorite {
public @Produces @Favorite String getDoctor() {
@Inject @Favorite String name;
public void regenerate(@Disposes String instance) {

Events
11
 CDI Events are based on the Observer/Observable pattern
– Does not require compile time dependencies
– Events can be synchronous or asynchronous
– Can trigger multiple events with priority
 A Qualifier is required
 An Object is created that represents the Event type
– The methods would define if the events are intercepted synchronously or asynchronously
and their priority
 The Event<T> is injected with the Qualifier in an Object that needs to fire events
 There are built in events
– beginRequest, endRequest, beginSession, endSession

Events
12
@Qualifier
@Retention(RUNTIME)
public @interface Doctor {
public void firstObserver(@Observes
@Priority(Interceptor.Priority.APPLICATION) @Doctor Regenerate doctor)
public void secondObserver(@Observes
@Priority(Interceptor.Priority.APPLICATION+1) @Doctor Regenerate doctor)
@Inject @Doctor private Event<Regenerate> doctor;
doctor.fire(new Regenerate());

Interceptors and Decorators
13
 Both are part of aspect oriented mechanism
 Interceptors are technically oriented and used mainly for transactions, security, and logging
– Can be bound to any bean or bean method
 Decorators are business oriented and are used to chain the behavior of a bean
– Bound to a bean class
 Both require entries in the beans.xml to active or @Priority to specify globally
<interceptors>
<class>com.ibm.example.cdi.interceptor.LoggingInterceptor</class>
</interceptors>
<decorators>
<class>com.ibm.example.cdi.decorator.LoggingDecorator</class>
</decorators>

Interceptors
14
 Interceptors usually contain the annotation @AroundInvoke which specifies the method to
be run when the interceptor is invoked
 The methods @PostConstruct, @PreDestroy, @PrePassivate, and @PostActivate
to specify lifecycle callback interceptors
 The method @AroundTimeout can be used to specify an EJB timeout interceptor
 Interceptor classes can contain more than one Interceptor methods but only one of each type
 One or more Interceptor Binding Types must be defined
– Associate annotation with target bean or method
– Similar to Qualifiers but annotated with @InterceptorBinding
– Can include the annotation @Inherited to specify it can be inherited by the superclass
– May declare other Interceptor Bindings
 Interceptor classes are annotated with @Interceptor and the Interceptor Binding
 @AroundInvoke takes an InovationContext parameter and can throw an Exception

Interceptors
15
@InterceptorBinding
@Inherited
@Target({TYPE, METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Logging {
@Interceptor
@Logging
public class LoggingInterceptor {
@AroundInvoke
public Object doLog (InvocationContext ctx)
throws Exception {
@RequestScoped
public class InterceptorBean {
@Logging
public String doHello() {
@Inject InterceptorBean bean;

Interceptors
16
@RequestScoped
public class DoctorWho {
@PostConstruct
private void setDoctor() {
@PreDestroy
private void regenerate() {
@Inject private DoctorWho doctor;
doctor.getDoctor();

Decorators
17
 Decorators implement an interface and are annotated with the annotation @Decorator
 More than Decorator can be called with the annotation @Priority and providing the order
 A Delegate injection entry point is required using @Delegate
– Can be field, constructor parameter, or initializer method
– Allows to get handle of called Object
– Only one Delegate is allowed per Decorator
 The code in Decorator overrides the code in the actual class using the Delegate

Decorators
18
public interface Logging {
public class LoggingEntry implements Logging {
@Decorator
public class LoggingDecorator implements Logging {
@Inject @Delegate @Any
private Logging logging;
@Inject private LoggingEntry entry;

Alternatives
19
 Used when there is more than one version of a Bean and is determined at deployment time
 The class that is a different version is annotated with @Alternative
 The Alternative class must be placed in the beans.xml to activate
 Multiple Alternative classes can be invoked using @Priority and providing the order

Alternatives
20
public interface Doctor {
public class FavoriteDoctor implements Doctor {
@Alternative
public class FavoriteDoctorAlternative implements Doctor {
@Inject private Doctor doctor;
<alternatives>
<class>com.ibm.example.cdi.alternative.FavoriteDoctorAlternative</class>
</alternatives>

Utilizing the BeanManager
21
 The BeanManager allows for extensions to interact with the container
 Any Bean can injected the BeanManager
 An instance of the BeanManager can be obtained using JNDI looking up
java:comp/BeanManager
 Once obtained can use introspection on Beans or change certain behaviors of CDI
@Inject private BeanManager bm;

More information
22
 Context and Dependency Injection for Java EE (JEE 8)
 Examples used for this presentations from GitHub
 Learning CDI

Context and Dependency Injection 2.0

Context and Dependency Injection 2.0

Recommended

More Related Content

What's hot (20)

Similar to Context and Dependency Injection 2.0 (20)

Recently uploaded (20)

Context and Dependency Injection 2.0