Designing Java EE Applications in the Age of CDI

Designing Java EE
Applications in the Age of CDI

Michael Nascimento Santos
Michel Graciano

JavaOne 2012

Michael Nascimento Santos
• +13 years of Java experience, from Java ME to
Java EE, and over 19 years of practical
programming experience
• JSR-310 (Date and Time API) co-leader and
expert at JSRs 207, 250, 270 (Java SE 6), 296
(Swing Application Framework), 303 (Bean
Validation), 349 (Bean Validation 1.1)
• genesis (http://java.net/projects/genesis) and
ThinNB (http://java.net/projects/thinnb) founder
• JavaOne Rock Star Speaker and speaker at
JustJava, Abaporu, FISL, COMDEX, BrasilOne
and Conexão Java

04/12/2012 Designing Java EE Applications in the Age of CDI 2

Michel Graciano
• +9 years of experience with the Java platform
• Former NetBeans translation project
coordenator and contributor
• Active open source member of NetBeans and
other projects
• Committer of genesis
(http://java.net/projects/genesis)
• Speaker at JustJava, The Developer's
Conference and JavaOne


Agenda
• CDI crash-course
• CDI unique features
• Putting it all together
 Demos
• Q&A


Terminology
• JSR 299 - CDI
 Contexts and Dependency Injection for the Java
EE platform
• Weld
 JSR-299 Reference Implementation


“CDI is more than a framework. It's a whole, rich
programming model. The theme of CDI is loose-
coupling with strong typing.”
Weld specification


CDI crash-course
• Beans can be injected using @Inject
• Injected beans can be filtered and/or
disambiguated using @Qualifier

@Inject
@Inject
Greeting greeting;
Greeting greeting;


CDI crash-course
• Beans can be injected using @Inject
• Injected beans can be filtered and/or
disambiguated using @Qualifier

@Informal
@Informal
@Inject
@Inject
Greeting greeting;
Greeting greeting;


CDI crash-course

@Qualifier
@Qualifier
@Retention(RUNTIME)
@Retention(RUNTIME)
@Target({METHOD, FIELD, PARAMETER, TYPE})
@Target({METHOD, FIELD, PARAMETER, TYPE})
public @interface Informal {
public @interface Informal {
}
}

04/12/2012 Designing Java EE Applications in the Age of CDI #ageofcdi 9

CDI crash-course
• Beans can be named using @Named

@Named(“pageModel”)
@Named(“pageModel”)
public class PageModel {
public class PageModel {
public getName() { ... }
public getName() { ... }
}
}

<h:body>
<h:body>
#{pageModel.name}
#{pageModel.name}
</h:body>
</h:body>


CDI crash-course
• Beans with special initialization can be
constructed using producers

public class Shop {
public class Shop {
@Produces
@Produces
PaymentProcessor getPaymentProcessor() { ... }
PaymentProcessor getPaymentProcessor() { ... }
@Produces
@Produces
List<Product> getProducts() { ... }
}
}


CDI crash-course
• Beans with special initialization can be
constructed using producers

public class Shop {
public class Shop {
@Produces
@Produces
@ApplicationScoped
@ApplicationScoped
@Catalog
@Catalog
@Named("catalog")
@Named("catalog")
}
}


CDI crash-course
• Activation and some configuration is done by
beans.xml file


But what's the point of
CDI anyway?


Unique features
• Clean scope combination
• Event system
• AOP without interfaces
• Access to injection point
• Portable extensions


Clean scope combination
• Scopes determine the bean instances lifecycle
and can be safely combined as needed

@SessionScoped
@SessionScoped
public class User implements Serializable
public class User implements Serializable
{ ... }
{ ... }
@ApplicationScoped
@ApplicationScoped
public class System implements Serializable
public class System implements Serializable
{
{
@Inject
@Inject
User user;
User user;
...
...
}
}


Custom scopes
• Seam
 RenderScoped
• MyFaces CODI
 @ConversationScoped
 @WindowScoped
 @ViewAccessScoped
• Apache DeltaSpike
 @TransactionScoped


Event system
• Loose-decoupled event producers from
consumers by the event notifications model
• Events can be filtered using qualifiers
public void onAnyDocumentEvent(
public void onAnyDocumentEvent(
@Observes Document document) { ... }
@Observes Document document) { ... }

public void afterDocumentUpdate(
@Observes @Updated Document document)
@Observes @Updated Document document)
{ ... }
{ ... }


Event system
@Inject @Any Event<Document> event;
@Inject @Any Event<Document> event;
...
...
public void someMethod() {
event.fire(document);
}
}


Event system
@Inject @Updated Event<Document> event;
@Inject @Updated Event<Document> event;
...
...
}
}


Event system
• Conditional observers
 IF_EXISTS
 ALWAYS

@Observes(receive=IF_EXISTS)
@Observes(receive=IF_EXISTS)
@Updated Document document) { ... }


Event system
• Transactional observers
 IN_PROGRESS,
 BEFORE_COMPLETION,
 AFTER_COMPLETION,
 AFTER_FAILURE,
 AFTER_SUCCESS

@Observes(during=AFTER_SUCCESS)
@Observes(during=AFTER_SUCCESS)


AOP without interfaces
• Interceptors decouple technical concerns from
business logic
 Orthogonal to the application and type system
• Decorators allow business concerns to be
compartmentalized using the interceptor concept
 Attached to a Java type, aware of business
semantics
• Configurable
 Enabled and ordered at beans.xml file, allowing
different behaviours for different environments


Interceptors

@Inherited
@Inherited
@InterceptorBinding
@InterceptorBinding
@Target({TYPE, METHOD})
@Target({TYPE, METHOD})
@Retention(RUNTIME)
@Retention(RUNTIME)
public @interface Secure {}
public @interface Secure {}


Interceptors

@Secure
@Secure
@Interceptor
@Interceptor
public class SecurityInterceptor {
public class SecurityInterceptor {
@AroundInvoke
@AroundInvoke
public Object manageSecurity(
public Object manageSecurity(
InvocationContext ctx) throws Exception {
InvocationContext ctx) throws Exception {
// manage security...
// manage security...
return ctx.proceed();
return ctx.proceed();
}
}
}
}


Interceptors

public class ShoppingCart {
public class ShoppingCart {
@Secure
@Secure
public void placeOrder() { ... }
public void placeOrder() { ... }
}
}

@Secure
@Secure
public class System {
public class System {
...
...
}
}


Decorators

@Decorator
@Decorator
class TimestampLogger implements
class TimestampLogger implements Logger {
Logger {
@Inject @Delegate @Any Logger
@Inject @Delegate @Any Logger logger;
logger;
@Override
@Override
void log(String message) {
void log(String message) {
logger.log( timestamp() + ": " +
logger.log( timestamp() + ": " +
message );
message );
}
}
...
...
}
}


Access to injection point
• Allowed at @Dependent scoped beans to obtain
information about the injection point to which they
belong
• Empowers producers with the ability to react
according to the injection point


Access to injection point

@Produces
@Produces
Logger createLogger(InjectionPoint ip) {
Logger createLogger(InjectionPoint ip) {
return Logger.getLogger(
return Logger.getLogger(
ip.getMember().getDeclaringClass().
ip.getMember().getDeclaringClass().
getName());
getName());
}
}

public class SomeClass {
public class SomeClass {
@Inject
@Inject
Logger logger;
Logger logger;
...
...
}
}


Portable extensions

<T> void processAnnotatedType(@Observes final
<T> void processAnnotatedType(@Observes final
ProcessAnnotatedType<T> pat) {
ProcessAnnotatedType<T> pat) {
final AnnotatedTypeBuilder builder =
final AnnotatedTypeBuilder builder =
new AnnotatedTypeBuilder().
new AnnotatedTypeBuilder().
readFromType(pat.getAnnotatedType(),
readFromType(pat.getAnnotatedType(),
true).addToClass(NamedLiteral.INSTANCE);
true).addToClass(NamedLiteral.INSTANCE);
pat.setAnnotatedType(builder.create());
pat.setAnnotatedType(builder.create());
}
}


Portable extensions

<X> void processInjectionTarget(@Observes
<X> void processInjectionTarget(@Observes
ProcessInjectionTarget<X> pit) {
ProcessInjectionTarget<X> pit) {
for (InjectionPoint ip :
for (InjectionPoint ip :
pit.getInjectionTarget().
pit.getInjectionTarget().
getInjectionPoints()) {
getInjectionPoints()) {
...
...
}
}
}
}


Putting it all together


Named queries are not safe


Typesafe @TypedQuery


Typesafe @TypedQuery

-------------------------------------------------------------
-------------------------------------------------------------
COMPILATION ERROR ::
COMPILATION ERROR
-------------------------------------------------------------
-------------------------------------------------------------
and returns false.
and returns false.
model/CustomerModel.java:[47,25] error: Named query 'Customer.findByNme' not defined yet.
model/CustomerModel.java:[47,25] error: Named query 'Customer.findByNme' not defined yet.
model/CustomerModel.java:[43,25] error: Named query 'Customer.findAl' not defined yet.
model/CustomerModel.java:[43,25] error: Named query 'Customer.findAl' not defined yet.
2 errors
2 errors
-------------------------------------------------------------
-------------------------------------------------------------


Demo


Features used
• CDI
 Dependency injection
 Producer methods
 Access to the injection point
• Annotation processors


Auto-generated MBeans
• Portable extensions and event system allow
deployed components to be easily detected
• Provide good entry point for enabling
management for CDI components
• Metadata can be used to generate JMX MBeans
on the fly


Auto-generated MBeans


Demo


Features used
• CDI
 Dependency injection
 Producer fields
 Portable extensions
 Callback events
 Interceptors
• JMX
 MXBean
 DynamicMBean


Conclusion
• CDI is more than a simple dependency injection
framework
• Unique features like access to injection point
information, events and portable extensions
enable creative typesafe solutions to be explored
• It is a new era, the age of CDI, so keep this in
mind when designing your JavaEE applications


Q&A
Michael N. Santos | @mr__m
http://blog.michaelnascimento.com.br/
michael.nascimento@tecsinapse.com.br
Michel Graciano | @mgraciano
http://www.summa.com.br/
michel.graciano@summa.com.br
https://github.com/mgraciano/javaone-2012/

Thank you

Michael N. Santos | @mr__m
http://blog.michaelnascimento.com.br/
michael.nascimento@tecsinapse.com.br
Michel Graciano | @mgraciano
http://www.summa.com.br/
michel.graciano@summa.com.br
https://github.com/mgraciano/javaone-2012/

Designing Java EE Applications in the Age of CDI

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (12)

Similaire à Designing Java EE Applications in the Age of CDI

Similaire à Designing Java EE Applications in the Age of CDI (20)

Plus de Michel Graciano

Plus de Michel Graciano (7)

Dernier

Dernier (20)

Designing Java EE Applications in the Age of CDI