Introduction to cdi given at java one 2014

INTRODUCTION TO CONTEXTS AND
DEPENDENCY INJECTION (CDI)
@antoine_sd

ANTOINE SABOT-DURAND
• Senior Software Engineer @Red Hat
• Java & OSS :
• CDI co-spec lead
• CDI community development
• Tech Lead on Agorava
• @antoine_sd

WHAT IS CDI ?
• Java EE dependency injection standard
• Strong typed and type safe
• Context management
• Observer pattern included (Event bus)
• Highly extensible

A BIT OF HISTORY
CDI 1.0 (Java EE 6)
CDI 1.1 (Java EE 7)
CDI 1.2 (1.1 MR)
CDI 2.0 Starts
Dec 2009 June 2013 Apr 2014 Sep 2014
CDI 2.0 released
Q1 2016

IMPLEMENTATIONS
JBoss Weld (Reference Implementation) Apache Open WebBeans

CDI ACTIVATION
• In CDI 1.0, you must add a beans.xml file to your archive
• Since CDI 1.1, it’s activated by default:
• All classes having a “bean defining annotation” become a bean
• You can still use beans.xml file to activate CDI explicitly or
deactivate it

THE CDI BEAN
• In Java EE 6 and 7 everything is a Managed Bean
• Managed beans are basic components
• They are managed by the container
• They all have a lifecycle
• They can be intercepted (AOP)
• They can be injected
• Accessible from outside CDI code.

BASIC DEPENDENCY INJECTION
@Inject

THIS IS A BEAN
public class HelloService {
public String hello() {
return "Hello World!";
}
}

DI IN CONSTRUCTOR
public class MyBean {
private HelloService service;
@Inject
public MyBean(HelloService service) {
this.service = service;
}
}

DI IN SETTER
@Inject
public void setService(HelloService service) {
this.service = service;
}
}

DI IN FIELD
@Inject
public void displayHello() {
display(service.hello();
}
}

NO TYPE ERASURE IN CDI
@Inject Service<User> userService;
@Inject Service<Staff> staffService;
}
This works

USING QUALIFIERS TO DISTINGUISH
BEANS OF THE SAME TYPE

2 SERVICE IMPLEMENTATIONS…
public interface HelloService {
public String hello();
}
public class FrenchHelloService implements HelloService {
return "Bonjour tout le monde!";
}
}
public class EnglishHelloService implements HelloService {
}
}

…NEED QUALIFIERS…
@Qualifier
@Retention(RUNTIME)
@Target({FIELD, TYPE, METHOD, PARAMETER})
public @interface French {}
@Qualifier
@Retention(RUNTIME)
public @interface English {}

…TO BE DISTINGUISHED.
@French
}
}
@English
}
}

QUALIFIED INJECTION POINTS
@Inject @French HelloService service;
display( service.hello();
}
}
@Inject @English HelloService service;
}
}

QUALIFIERS CAN HAVE MEMBERS
@Qualifier
@Retention(RUNTIME)
public @interface Language {
Languages value();
@Nonbinding String description() default "";
public enum Languages {
FRENCH, ENGLISH
}
}

QUALIFIERS WITH MEMBERS 1/2
@Language(FRENCH)
}
}
@Language(ENGLISH)
}
}

QUALIFIERS WITH MEMBERS 2/2
@Inject @Language(ENGLISH) HelloService service;
}
}
@Inject @Language(FRENCH) HelloService service;
}
}

MULTIPLE QUALIFIERS
@Inject @French
HelloService service;
}
@French @Console @Secured
}

MULTIPLE QUALIFIERS
@Inject @French @Console
}
}

MULTIPLE QUALIFIERS
@Inject @French @Console @Secured
}
}

MULTIPLE QUALIFIERS
@Inject @French @Console @Secured
}
@French @Secured
}

RESERVED QUALIFIERS
@Default
@Any
@Named

SOMETIMES CALLED “LAZY INJECTION”
@Inject Instance<HelloService> service;
display( service.get().hello() );
}
}

CHECK BEAN EXISTENCE AT RUNTIME
@Inject Instance<HelloService> service;
if (!service.isUnsatisfied()) {
display( service.get().hello() );
}
}
}

INSTANCE<T> IS ITERABLE
public interface Instance<T> extends Iterable<T>, Provider<T> {
public Instance<T> select(Annotation... qualifiers);
public Instance select(Class subtype, Annotation... qualifiers);
public Instance select(TypeLiteral subtype, Annotation... qualifiers);
public boolean isUnsatisfied();
public boolean isAmbiguous();
public void destroy(T instance);
}

LOOP ON ALL BEANS OF A GIVEN TYPE
@Inject @Any Instance<HelloService> services;
for (HelloService service : services) {
display( service.hello() );
}
}
}

SELECT A QUALIFIER AT RUNTIME
@Inject @Any Instance<HelloService> services;
display(
service.select(
new AnnotationLiteral()<French> {})
.get() );
}
}

CONTEXTS MANAGE BEANS LIFECYCLE
• They helps container to choose when a bean should be instantiated and destroyed
• They enforce the fact that a given bean is a singleton for a given context
• Built-in CDI contexts :
• @Dependent (default)
• @ApplicationScoped, @SessionScoped, @RequestScoped
• @ConversationScoped
• @Singleton
• You can create your own scope

CHOOSING THE RIGHT CONTEXT
@SessionScoped
public class CartBean {
public void addItem(Item item) {
...
}
}

CHOOSING THE RIGHT CONTEXT
@ApplicationScoped
...
}
}
FAIL !!!

CONVERSATION IS MANAGE BY DEV
@ConversationScoped
...
}
}

NEW CONTEXTS CAN BE CREATED
@ThreadScoped
...
}
}

CREATING BEAN FROM ANY CLASS
@Produces
public MyNonCDIClass myProducer() {
return new MyNonCdiClass();
}
...
@Inject
MyNonCDIClass bean;

PRODUCERS MAY HAVE A SCOPE
@Produces
@RequestScoped
public FacesContext produceFacesContext() {
return FacesContext.getCurrentInstance();
}

GETTING INFO FROM INJECTION POINT
@Produces
public Logger produceLog(InjectionPoint injectionPoint) {
return Logger.getLogger(injectionPoint.getMember()
.getDeclaringClass().getName());
}

REMEMBER : “NO TYPE ERASURE”
@Produces
public <K, V> Map<K, V> produceMap(InjectionPoint ip) {
if (valueIsNumber(ip.getType())) {
return new TreeMap<K, V>();
}
return new HashMap<K, V>();
}

A NICE WAY TO ADD DECOUPLING
public class FirstBean {
@Inject Event<Post> postEvent;
public void saveNewPost(Post myPost) {
postEvent.fire(myPost);
}
}
public class SecondBean {
public void listenPost(@Observes Post post) {
System.out.println("Received : " + evt.message());
}
}

EVENTS CAN BE QUALIFIED
public class FirstBean {
@Inject Event<Post> postEvent;
public void saveNewPost(Post myPost) {
postEvent.select(
new AnnotationLiteral()<French> {}).fire(myPost);
}
}
// these 3 observers will be called
public void listenFrPost(@Observes @French Post post) {}
public void listenPost(@Observes Post post) {}
public void listenObject(@Observes Object obj) {}
// This one won’t be called
public void listenEnPost(@Observes @English Post post) {}
}

AS ALWAYS “NO TYPE ERASURE”
// these observers will be resolved depending
// on parameter in event payload type
public void listenStrPost(@Observes Post<String> post) {}
public void listenNumPost(@Observes Post<Number> post) {}
}

SOME BUILT-IN EVENTS
public void beginRequest(@Observes @Initialized(RequestScoped.class)
ServletRequest req) {}
public void endRequest(@Observes @Destroyed(RequestScoped.class)
ServletRequest req) {}
public void beginSession(@Observes @Initialized(SessionScoped.class)
HttpSession session) {}
public void endSession(@Observes @Destroyed(SessionScoped.class)
HttpSession session) {}
}

A DECORATOR
@Decorator
@Priority(Interceptor.Priority.APPLICATION)
public class HelloDecorator implements HelloService {
// The decorated service may be restricted with qualifiers
@Inject @Delegate HelloService service;
return service.hello() + "-decorated";
}
}

INTERCEPTOR BINDING…
@InterceptorBinding
@Target({METHOD, TYPE})
@Retention(RUNTIME)
public @interface Loggable {}

…IS USED TO BIND AN INTERCEPTOR
@Interceptor @Loggable
@Priority(Interceptor.Priority.APPLICATION)
public class LogInterceptor {
@AroundInvoke
public Object log(InvocationContext ic) throws Exception {
System.out.println("Entering " + ic.getMethod().getName());
try {
return ic.proceed();
} finally {
System.out.println("Exiting " + ic.getMethod().getName());
}
}
}

IT CAN BE PUT ON CLASS OR METHOD
@Loggable
@Inject HelloService service;
}
}

THAT’S ALL FOR BASIC CDI
• If you want to learn advanced stuff come to :
Going Farther with CDI 1.2 [CON5585] Monday 5:30pm
• visit : http://cdi-spec.org
• follow @cdispec and @antoine_sd on twitter
• Questions ?

Introduction to cdi given at java one 2014

More Related Content

What's hot

Viewers also liked

Similar to Introduction to cdi given at java one 2014

Recently uploaded

Introduction to cdi given at java one 2014