PATTERNS & BEST PRACTICES FOR CDI

Transcription

1 PATTERNS & BEST PRACTICES FOR CDI SESSION Ryan Cuprak e-formulation Analyst, Author, Connecticut Java Users Group President Reza Rahman Resin Developer, Java EE/EJB/JMS JCP expert, Author EJB 3 in Action

2 AGENDA CDI Overview XML Configuration vs. Annotations Qualifiers Naming Scoping Stereotypes Inceptors & Decorators Dependency vs. Resource Injection CDI Integration EJB JSF JPA Extensions Conclusion Q&A

3 OVERVIEW What is CDI? Dependency injection standard for Java EE. Based on Seam 2, Google Guice, and Spring. Defined in JSR-299. Why CDI? Improve Java EE dependency injection support. Provide a standard DI for both enterprise and web applications. Provide a Java-centric type safety injection using annotations. As adoption grows, it is important to understand how to leverage CDI effectively.

4 OVERVIEW Basic @All, Component Custom InjectionPoint

5 OVERVIEW Lightweight events: @Delegate Portable extensions SPI!

6 CONFIGURATION CDI is annotation centric: Annotations are ideal for type-safe dependency injection. Compact, semi-permanent, and semantically close to code, tools-friendly. CDI does support XML configuration (beans.xml): Override annotation configuration. Perform DI using JRE classes or third-party libraries. Plug-ins provide enhanced configuration and behavior support: Seam 3 XML CanDI XML Some developers prefer XML over annotations.

7 CONFIGURATION Let s look at a simple example leveraging XML configuration. Pieces: DefaultAccountService EJB stateless session bean. DefaultAccountDAO performs basic CRUD operations MockAccountDAO replaces DefaultAccountDAO for unit interceptor used for interceptor collecting profiling data Deployments types: Unit Testing, Integration Testing, Production

8 XML DEPLOYMENT EXAMPLE

9 META-INF/beans.xml UNIT TESTING

10 META-INF/beans.xml INTEGRATION TESTING

11 META-INF/beans.xml PRODUCTION

12 XML CONFIGURATION Using the beans-test.xml:

13 OVERRIDE JAVA/ANNOTATION DEFAULTS Override default values in a bean via XML:

14 WIRING THIRD-PARTY EXTENSIONS Configure a JRE class for injection, support multiple instances: new DecimalFormat( $0.00 );

15 XML OBJECT WIRING Define MailSender and define two different qualifiers for injecting two difference instances:

16 XML OBJECT WIRING Configure two instances of MailSender:

17 XML OBJECT WIRING Injecting the MailSupport MailSender instance:

18 QUALIFIER TYPE-SAFETY VS. VERBOSITY Benefits of Qualifiers? Type-safe Java-centric dependency resolution Enhances readability, fluency, maintainability Drawbacks: Can be verbose Qualifiers can be used with enumerations to verbosity reduce Best as Qualifier should be used sparingly because they are a lot more brittle.

19 @Target({ FIELD, TYPE }) @Target({ FIELD, TYPE }) private MailSender mailsender;

20 QUALIFIERS WITH ENUMERATIONS Qualifiers with enumerations @Target({ FIELD, TYPE }) MailSenderType { MailSenderTypes value(); } public enum MailSenderTypes { ADMIN, private MailSender mailsender;

21 @NAMED AS QUALIFIER Named can be used as a Qualifier admin ) public class AdminMailSender implements MailSender { support ) public class SupportMailSender implements MailSender support ) private MailSender mailsender;

22 COMPONENT NAMING Practices when using annotation: String based names not needed for dependency resolution. Only necessary to name components that are referenced outside of Java such as in JSF/Facelets via EL. Default names good enough in most cases. Be careful of naming conflicts name-based resolution not type-safe! Choose names that add to readability/api fluency.

23 SPECIFYING COMPONENT NAMES Implicit name using public class TransferWizard { <h:inputtext id="amount value="#{transferwizard.amount}"/> Explicit transfer public class TransferWizard { <h:inputtext id="amount" value="#{transfer.amount}"/>

24 COMPONENT SCOPING What are the scope? @Dependent What are the purposes and best practices? Components with appropriate scopes maximize memory usage. Scopes remove boilerplate state maintenance code especially at presentation tier. Make judicious use of conversations!

25 SCOPE GRANULARITY

26 CONVERSATION SCOPE

27 GROUPING METADATA IN STEREOTYPES Components self-organize into roles in wellarchitected systems. Roles get surfaced as groups of recurring metadata. CDI allows component roles to be articulated as stereotypes. Stereotypes encapsulate specialized behavior and can be cumulative.

28 STEREOTYPES FOR COMPONENT ROLES Examples of stereotypes: Dao, Service, Model, Mock, Model. Note: Model is built-in.

29 INTERCEPTORS VS. DECORATORS Interceptors and Decorators both geared towards cross-cutting logic. Bypass traditional complexity associated with AOP by avoiding point-cuts. Interceptors are designed for system-level crosscutting concerns very decoupled from business logic. Decorators intended for concerns that should be compartmentalized but are still very close to business logic.

30 INTERCEPTOR USAGE Defining public class AuditInterceptor public Object audit(invocationcontext context) throws Exception { System.out.print("Executing: + context.getmethod().getname()); System.out.println(" with args: + Arrays.toString(context.getParameters())); return context.proceed(); } } Using the public class DefaultAccountService implements AccountService public void addaccount(account account) {

31 DECORATOR USAGE

32 INJECTION AND LOOK-UP Declarative, static injection sufficient for used when objects must be programmatically created/destroyed Look-up using Instance used when decencies need to be resolved at runtime For very dynamic resolution, BeanManager.getBeans SPI can be used

33 PRODUCING OBJECTS private User private public Account getcurrentaccount() { return accountservice.getaccount(user.getid()); public Logger createlogger(injectionpoint injectionpoint) { return Logger.getLogger(injectionPoint.getMember().getDeclaringClass().getName()); }

34 private Instance<Discount> discount;... if (!discount.isunsatisfied()) { Discount currentdiscount = discount.get(); }

35 DEPENDENCY VS. RESOURCE INJECTION Java EE 5 introduced resource injection @PersistenceContext Limited, specialized, name-based injection Java EE 6 introduces CDI Powerful, general purpose, type-safe injection Mostly orthogonal functionality, some overlap Favor CDI for greater flexibility

36 JAVA EE INJECTION private AccountDao private AccountService private UserTransaction private EntityManager private DataSource private Queue transferqueue;

37 WHEN TO USE EJB? Use EJB for enterprise services like transactions Use CDI managed beans otherwise EJB does have overhead Avoid plain managed beans EJBs most appropriate for service/business logic tier CDI makes it possible to use EJBs as JSF managed beans only good practice for RAD/prototyping Using EJB services without EJB

38 CDI & EJB

39 CDI AND JSF CDI more powerful replacement to JSF managed beans Seam Faces excellent enhancement CDI naming, scopes, producers, qualifiers work in powerful ways with JSF CDI designed with JSF in mind, but not limited to JSF Wicket, Struts 2, Spring MVC, Swing Desktop application.

40 CDI & JSF

41 CDI & JSF

42 CDI AND JPA CDI/JPA bean life-cycle mismatch Life-cycle mismatch can be bridged by CDI producers Make judicious use of stateful session bean extended persistence context

43 PRODUCING ENTITY BEANS

44 USING PORTABLE EXTENSIONS Portable extensions perhaps most important part of CDI Rich CDI ecosystem already evolving Tools/utilities, extending Java EE, integration with Java EE APIs, integrating with non-standard APIs, making Java EE features available in non-java EE environments Arquillian possibly most important CDI extension Use portable extensions judiciously

45 CDI ECOSYSTEM SNAPSHOT Implementations Portable Extensions Runtimes Weld CanDI OpenWebBeans Tools

46 CDI PORTABLE EXTENSIONS SNAPSHOT

47 ARQUILLIAN UNIT TEST

48 SUMMARY CDI critical part of Java EE now and going forward CDI well-received by community Focus on loose-coupling, Java-centric type-safety, annotations, expressiveness, fluency and ease-ofuse Utilize CDI effectively to maximize benefits Continuously refactor to patterns Have fun!

49 REFERENCES JSR 299: Contexts and Dependency Injection for Java EE, Weld Reference, reference/1.0.0/en-us/html/ CDI Advocacy, Weld, the JBoss reference implementation for JSR 299, OpenWebBeans, Apache implementation of JSR 299, CanDI, the JSR 299 implementation for Caucho Resin,

50 REFERENCES Seam 3, Apache MyFaces CODI, myfaces.apache.org/extensions/cdi/ Arquillian, Seam Forge, Documentation/SeamForge