CDI 2.0 (JSR 365)

Copyright © 2017, Oracle and/or its affiliates. All rights reserved.
| CDI 2.0 (JSR 365) Contexts and Dependency Injection for Java 2.0 Akihiro Nishikawa Cloud Technology Business Unit Oracle Corporation Japan 17, May, 2017 Java Day Tokyo 2017 #JavaDayTokyo

| Safe Harbor Statement The following is intended to outline our general product direction. It is intended for information purposes only, and may not be incorporated into any contract. It is not a commitment to deliver any material, code, or functionality, and should not be relied upon in making purchasing decisions. The development, release, and timing of any features or functionality described for Oracle’s products remains at the sole discretion of Oracle. 2

| Program Agenda 3 What’s CDI ? What’s new in CDI 2.0? Summary 1 2 3

| What’s CDI? 4

| What’s CDI? • Lifecycle for stateful objects bound to lifecycle contexts • Type-safe dependency injection mechanism • Event notification • Integration with the Unified Expression Language (EL) • ... 5 Major theme of CDI is “loose coupling”

| CDI 2.0 (JSR-365) • Major evolution of the CDI 1.2 (JSR 346) specification • Spec Lead – Antoine Sabot-Durand (Red Hat Inc.) (@antoine_sd) • Reference Implementation – Weld : http://download.jboss.org/weld/3.0.0.Final/ 6 http://www.cdi-spec.org (@cdispec)

| 7

| 8 CDI Timeline December 2009 CDI 1.0 (Java EE 6) June 2013 CDI 1.1 (Java EE 7) April 2014 CDI 1.2 (1.1 Maintenance Release) September 2014 CDI 2.0 starts… May 2017 CDI 2.0

| CDI 1.0 (JSR-299) • A well-defined lifecycle for stateful objects bound to lifecycle contexts – Where the set of contexts is extensible • A type-safe dependency injection mechanism without verbose configuration – Dependencies can be selected at development or deployment time • Type-safe decorators and interceptors • An event notification model • An SPI allowing portable extensions to integrate cleanly with the container 9 Contexts and Dependency Injection for the Java EE platform 1.0

| CDI 1.1/1.2 (JSR-346) • Add automatic enablement of CDI in Java EE (beans.xml is not required) • Add introspection with event, bean, decorator and interceptor meta data • Ease access to bean manager from outside CDI with CDI class • Add global enablement of interceptors using the @Priority annotation • Add unmanaged allowing easy access to non-contexutal instances • Spec clarification of CDI Lifecycle and Events 10 Contexts and Dependency Injection for the Java EE platform 1.1/1.2

| CDI 1.1/1.2 (JSR-346) • Reworking Bean defining annotation to avoid conflict with other JSR 330 frameworks • Clarification on conversation resolution • OSGi official support in the API 11 Contexts and Dependency Injection for the Java EE platform 1.1/1.2

| 12 CDI is associated with the following specs DI (Dependency Injection) EJB (Enterprise JavaBeans) Bean Validation Interceptors Managed Beans Common Annotation CDI JSF (JavaServer Faces)

| What’s new in CDI 2.0? 13

| Major Changes • Spec was split into 3 parts • Java SE Support – Using CDI outside Java EE • Alignment on Java 8 features (streams, lambdas, repeating qualifiers) • Event enhancement • Configurators for major SPI elements • Possibility to configure or veto observer methods • Add built-in annotation literals • Make possible to apply interceptor on producers 14

| Spec was split into 3 parts 15

| 16 Structure CDI Core Java SE Java EE

| Why the spec was split? • To align on many other Java EE spec which support Java SE bootstrapping – JAX-RS, JPA... • To boost CDI adoption for Spec and Frameworks – Java SE has been already supported by Weld, Apache OpenWebBeans, Apache DeltaSpike and so on, but API is different from each implementation. – Programming model should be defined to avoid user confusion. • To provide a mean of building new stacks out of Java EE (MicroProfile) 17

| Name was changed... • JSR 346 Contexts and Dependency Injection for Java EE • JSR 365 Contexts and Dependency Injection for Java 18

| Java SE support Using CDI outside Java EE 19

| CDI 1.x • Not specified • Depending upon each implementation – Weld – Apache DeltaSpike – ... CDI 2.0 • Standard API is specified • Must explicitly boot CDI container 20 API to boot CDI in Java SE

| API to boot CDI in Java SE import javax.enterprise.inject.se.SeContainer; import javax.enterprise.inject.se.SeContainerInitializer; public class Sample { public static void main(String... args) { try (SeContainer container = SeContainerInitializer .newInstance() .initialize()) { ... } } } 21

| 22 SeContainerInitializer

| SeContainer interface • Handle for CDI Interface – The handle is used to access the BeanManager • AutoCloseable • Extends javax.enterprise.inject.Instance – Able to use SeContainer to look up Instance programatically – If no qualifier is passed to SeContainer#select(), the @Default qualifier is assumed. – If no required type is given, the required type is the same as the parent’s one. • Able to use CDI#current() 23 javax.enterprise.inject.se.SeContainer

| Controlling the classpath try (SeContainer container = SeContainerInitializer.newInstance() .addPackages(Pojo.class) .disableDiscovery() .initialize()) { ... } 24 When adding Beans explicitly, bean discovery should be disabled

| Configurable try (SeContainer container = SeContainerInitializer.newInstance() .addExtensions() .enableDecorators() .selectAlternativeStereotypes() .selectAlternatives() .addProperty() .initialize()) { ... } 25 Able to add Alternatives, Stereotypes, Decorators, and Extensions

| Request Context Management • In Java SE, most of built-in contexts is unavailable… –Request context –Session context –Conversation context –... 26 Why is this feature required?

| Request Context Management • Start and stop request context programmatically through built-in bean • Provide built-in Interceptor to handle it automatically • This feature is also available for Java EE. 27 How to manage request contexts

| Request Context Management @ApplicationScoped public class MyBean { @Inject RequestContextController requestContextController; public void doRequest(String body) { boolean started = requestContextController.activate(); ... if( started ) { requestContextController.deactivate(); } } } 28 1) Built-in Beans to activate/deactivate Request Context

| Request Context Management @ApplicationScoped public class MyBean { @ActivateRequestContext public void doRequest(String body) { // Request context is activated during this invocation ... } } Priority Interceptor.Priority.PLATFORM_BEFORE + 100 (100) 29 2) Built-in Interceptor for automatically processing

| Java 8 Alignment 30

| Java 8 Alignment • Use Java 8 feature and functionalities heavily – Functional Interface – Stream • For example, Instance directly supports Stream API – Previously, unable to use Stream API along with Instance • Custom libraries using CDI 1.x might be built again to align with CDI 2.0 31

| Example @Inject @Any private Instance<Object> objects; public void onBean(@Observers AfterBeanDiscovery abd) { abd.addBean().produceWith(instance -> new Object()) .destroyWith((o, cc) -> {}); objects.stream().filter(Objects::nonNull) .forEach(o->o.notify()); ... 32 Builder-based Bean Configuration, Lambda expression, and Stream API

| Repeating Qualifier • Able to qualify classes and methods using the same annotation – Supported by language level • In case of get all annotations… 33 javax.enterprise.inject.spi.Annotated.getAnnotations()

| Event Enhancement Event ordering Asynchronous events 34

| Event Ordering • Event ordering using @Priority – The lowest value is first – Observers with no explicit priority have a middle range priority for allowing observer to be called last – Observer with the same priority are called in an undefined order • Only applicable to synchronous events – @Priority does not work for ordering asynchronous events 35

| Event Ordering import javax.enterprise.inject.spi.ObserverMethod; import javax.interceptor.Interceptor; ... // ObserverMethod.DEFAULT_PRIORITY // = Interceptor.Priority.APPLICATION + 500 System.out.println(ObserverMethod.DEFAULT_PRIORITY); // 2500 System.out.println(Interceptor.Priority.APPLICATION); // 2000 36 Default Priority

| Event Ordering public void observer1( @Observes @Priority(1) Payload p) { ... } public void observer2( @Observes @Priority(2) Payload p) { ... } 37 Example 1

| Event Ordering public class MyExtension implements Extension { public void firstProcessAnnotatedType( @Observes @Priority(1) ProcessAnnotatedType<?> pat) { ... } public void secondProcessAnnotatedType( @Observes @Priority(2) ProcessAnnotatedType<?> pat) { ... } } 38 Example 2 – along with portable extensions

| Events in CDI 1.x • Sync/Async is not specified, but implementation uses Synchronous model – Observers are called in the firing thread (i.e. synchronous event) without particular order specified • Immutable status of the payload is not specified – Payload is mutated in some implements and framework • Observers may inject beans • Observers are aware of Transactional and security contexts 39

| Synchronous Events @Inject Event<Payload> event; public void syncCaller() { // Fire an event synchronously event.fire(new Payload()); } public void syncCallee(@Observes Payload p) { // Do something } 40 Firing and Observing events

| Asynchronous Events • Unable to mutate payload • Unable to access CDI contexts state at the firing point • Not transactional Event#fireAsync() @ObservesAsync 41 CDI 2.0

| Asynchronous Events @Inject Event<Payload> event; public void asyncCaller() { // Fire an event asynchronously event.fireAsync(new Payload()); } public void syncCallee(@ObservesAsync Payload p) { // Do something } 42 Firing and observing events

| Asynchronous Events @Inject Event<PanelUpdater> event; public void someMethod() { event.fireAsync( new PanelUpdater(green), executor); ... } 43 Example 1 – Executor

| Asynchronous Events @Inject Event<PanelUpdater> event; public void someMethod() { event.fireAsync( new PanelUpdater(green), SwingUtilities::invokeLater ); ... } 44 Example 2 – Asynchronous event in GUI thread

| Asynchronous Events • Exception raised in one async observer does not stop execution as in sync observer. – One of the reasons why firing async event does not trigger sync observers. • Event.fireAsync returns CompletionStage – Exception in fireAsync returned CompletionStage is CompletionException, which holds all the exceptions in the suppressed exception set. • Allowing integration of async events in standard Java 8 async pipeline. 45 Exception handling

| Asynchronous Events @Inject Event<PanelUpdater> event; public void someMethod() { ... CompleteionStage<PanelUpdater> stage = event.fireAsync( new PanelUpdater(green), SwingUtilities::invokeLater ); ... } 46 Example 3 – Exception handing

| Asynchronous Events • stage.whenComplete() – To handle result or exception • stage.handle() – Same as above but allows transformation of stage. • stage.exceptionally() – Used in the only case for treating exception 47 Exception handling with standard Java 8 Asynchronous API

| 48 Synchronous Events and Asynchronous Events event.fire() @Observes event.fireAsync() @ObservesAsync

| Are you planning migration to asynchronous events? • Simple replacement might raise problems! • Recommendation – In case of using sync events as of now, you should keep as it is. – Some limitation should be recognized. – Going sync/async should be a decision taken from firing side. – Being sync should be possible from observing side. 49

| Threading and Events in Java SE • Async events – Able to use Custom Executor • Sync events – Always within the same thread – When observers handle synchronous event in Java SE, request scope activation might be required. 50 @Inject Event <Pojo> event; @ActivateRequestContext public void syncSender() { event.fire(event); ... } public void syncReceiver( @Observes Pojo event ) { ... }

| Previous • BeanManager#fireEvent() CDI 2.0 • BeanManager#getEvent() – Able to get Event object – Event is typed to Object and implicitly annotated with @Default qualifier • BeanManager#fireEvent() is deprecated since CDI 2.0. 51 Programmatic Events

| Add built-in annotation literals 52

| 53 Indeed AnnotationLiteral is helpful if there is no member in an annotation. Standard Annotation Instances Annotation instance = new AnnotationLiteral<ApplicationScoped>(){};

| 54 But we have to create a class when an annotation has members... Standard Annotation Instances public class NamedLiteral extends AnnotationLiteral<Named> implements Named{ private String value; public NamedLiteral(String value) { this.value = value; } @Override public String value() { return null; } }

| • javax.enterprise.inject. – Any – Default – New – Specialized – Vetoed • javax.enterprise.util. – Nonbinding • javax.enterprise.inject. – Alternative – Typed • javax.enterprise.context. – Initialized – Destroyed – RequestScoped – SessioScoped – ApplicationScoped – Dependent – ConversationScoped 55 Built-in annotation literals

| Built-in annotation literals Default defaultLiteral = new Default.Literal(); // No members ApplicationScoped literal = ApplicationScoped.Literal.INSTANCE; // If annotation have members Initialized initializedForApplicationScoped = new Initialized.Literal(ApplicationScoped.class); Initialized initializedForRequestScoped = Initialized.Literal.of(RequestScoped.class); 56 Example

| Configurators for major SPI elements 57

| Configurators for metadata • AnnotatedType • InjectionPoint • Bean • ObserverMethod 58 Even if adding info to an existing metadata, quite verbose work is required.

| 59 In CDI 1.2 Configurators for metadata I want to modify some legacy framework which contains @CacheContext annotations in order to adapt CDI. What should I do? If I were you, I would create some extension to replace @CacheContext annotation with @Inject in AnnotatedTypes... But Do I have to create huge codes to do so? Exactly...

| Configurators interfaces • AnnotatedType – AnnotatedTypeConfigurator • InjectionPoint – InjectionPointConfigurator • BeanAttributes – BeanAttributesConfigurator • Bean – BeanConfigurator • ObserverMethod – ObserverMethodConfigurator • Producer – ProducerConfigurator 60 Newly introduced in CDI 2.0

| 61 In CDI 2.0 Configurators for meta-data What do you do when you want to adapt CDI to some legacy framework? If I were you, I would create metadata with “configurators”, which are accessible through container lifecycle events and automatically built by the container at the end of observer invocation. Oh, it sounds nice…

| CDI 2.0 public class AutoInjectExtension implements Extension { public <T> void CreateIP( @Observes @WithAnnotations(CacheContext.class) ProcessAnnotatedType<T> pat) { pat.configureAnnotatedType().filterFields( f -> f.isAnnotationPresent(CacheContext.class) ).forEach(f -> f.add(InjectLiteral.INSTANCE)); } } 62

| Configure or veto observer methods 63

| Application Lifecycle Events (fired only one time) • Startup – BeforeBeanDiscovery – AfterTypeDiscovery – AfterBeanDiscovery – AfterDeploymentValidation • Shutdown – BeforeShutdown Bean Discovery Events (might be fired multiple times) – ProcessAnnotatedType – ProcessInjectionPoint – ProcessInjectionTarget – ProcessBeanAttributes – ProcessBean – ProcessProducer – ProcessObserverMethod 64 Container lifecycle events

| Directing requests Type Discovery Search service providers Bean Discovery 65 Container Startup Application Lifecycle Events BeforeBeanDiscovery Detect deployment problems AfterTypeDiscovery AfterBeanDiscovery AfterDeploymentValidation

| destroy all contexts 66 Container Shutdown Application Lifecycle Events BeforeShutdown

| Add new methods in ProcessObserverMethod public interface ProcessObserverMethod<T, X> { ... // Replaces the ObserverMethod public void setObserverMethod(ObserverMethod<T> observerMethod); // Returns a ObserverMethodConfigurator initialized with the ObserverMethod processed by this event public ObserverMethodConfigurator<T> configureObserverMethod(); // forces the container to ignore the ObserverMethod public void veto(); } 67 javax.enterprise.inject.spi.ProcessSyntheticObserverMethod<T, X>

| Apply interceptor on producers 68

| 69 Able to apply @Transactional to a producer method Interceptor is not bound to a produced Bean in CDI 1.x @Produces @Transactional public MyService produceService() { ... }

| IntereptionFactory Interface public interface InterceptionFactory<T> { InterceptionProxyFactory<T> ignoreFinalMethods(); AnnotatedTypeConfigurator<T> configure(); <T> T createInterceptedInstance(T InstanceToWrap); } 70 javax.enterprise.inject.spi.InterceptionFactory<T>

| Add @transactional on one produced bean method @Produces @RequestScoped public MyClass createJpaEmAssumed(InterceptionFactory<MyClass> f) { AnnotatedTypeConfigurator<MyClass> atc = f.configure(); atc.filterMethods(m -> m.getJavaMember() .getName() .equals("doSomething")) .findFirst() .ifPresent(m -> m.add( new AnnotationLiteral<Transactional>(){ })); return f.createInterceptedInstance(new MyClass()); } 71 CDI 2.0

| Others 72

| Programmatic lookup – Instance Enhancement Instance obj; ... if( !obj.isAmbiguous() && !obj.isUnsatisfied() ) { ... } 73 Previous isUnsatisfied() Returns true if there is no bean found, or false otherwise. isAmbiguous() Returns true if there is more than one bean found, or false otherwise.

| Programmatic lookup – Instance Enhancement Instance obj; ... if(obj.isResolvable()) { ... } 74 CDI 2.0 isResolvable() Returns true if there is exactly one bean found, or false otherwise.

| Summary 75

| Key takeaway • Able to use CDI 2.0 on Java EE as well as Java SE. • Enhancements and new features help increase developer productivity. • Weld 3.0, reference Implementation of CDI, will be integrated with GlassFish 5 soon! 76

| Appendix 77

| Deprecated methods When? Method Alternatives CDI 2.0 BeanManager#fireEvent() BeanManager#getEvent() CDI 1.1 BeanManager#createInjectionTarget() BeanManager#getInjectionTargetFactory() CDI 1.1 javax.enterprise.inject .spi.Bean#isNullable() No alternatives CDI 1.1 AnnotatedMember#isStatic() Check with AnnotatedMember#getJavaMember().getModi fiers() CDI 1.1 BeforeBeanDiscovery#addAnnotatedType( AnnotatedType<?> type) eforeBeanDiscovery#addAnnotatedType( AnnotatedType<?> type, String id) 78

| Safe Harbor Statement The preceding is intended to outline our general product direction. It is intended for information purposes only, and may not be incorporated into any contract. It is not a commitment to deliver any material, code, or functionality, and should not be relied upon in making purchasing decisions. The development, release, and timing of any features or functionality described for Oracle’s products remains at the sole discretion of Oracle. 79

CDI 2.0 (JSR 365)

CDI 2.0 (JSR 365)

More Decks by Akihiro Nishikawa

Other Decks in Technology

Featured

Transcript