Presentation is loading. Please wait.

Presentation is loading. Please wait.

Professional Java EE Design Patterns Alex alextheedom.com.

Published byJunior Dawson Modified over 8 years ago

Similar presentations

Presentation on theme: "Professional Java EE Design Patterns Alex alextheedom.com."— Presentation transcript:

1 #JavaEE @alextheedom Professional Java EE Design Patterns Alex Theedom @alextheedom alextheedom.com

2 @alextheedom #JavaEE Speaker’s Bio Senior Java Developer Author: Professional Java EE Design Patterns E-learning Platforms Cash Machine Software Microservice Based Lottery Systems Spring and Java EE

3 @alextheedom #JavaEE What to expect What’s the story Why am I here? What’s the message? Whistle stop tour Design Patterns: what, when and why Context Dependency Injection

4 @alextheedom #JavaEE What to expect Deep Dive Singleton Pattern Factory Pattern Harnessing the power (something special) Quickie Patterns Façade, Decorator, Observer Q&A

5 @alextheedom #JavaEE What’s the story Java EE changed design pattern implementation Implementation has simplified Implementation has been enhanced Greater creativity How? I will show you today Change is part of Java EE continued development

6 @alextheedom #JavaEE How did we get here? Java Enterprise Edition EJBs, a panacea? 1.4 greatest milestone in Java History But was bloated: XML, JDNI, heavy containers Too complex, promise not delivered Spring was the response Java EE 5 back on the agenda Now EE 7

7 @alextheedom #JavaEE Design patterns: 3W’S What are design patterns? Why do we need them? When to use them?

8 @alextheedom #JavaEE Context Dependency Injection Simplifies programming model Annotations have replaced XML config files Convention over Configuration Resources are injected by type @Inject and disambiguation @Qualifier POJO (JSR 299 managed bean) Otherwise @Producer

9 @alextheedom #JavaEE Singleton Pattern Ubiquitous and controversial but inescapable Instantiated once Not normally destroy during application life cycle

10 @alextheedom #JavaEE Conventional Implementation public class Logger { private static Logger instance; private Logger() { // Creation code here } public static synchronized Logger getInstance() { if(instance == null) { instance = new Logger(); } return instance; } public class Logger { private static Logger instance; private Logger() { // Creation code here } public static synchronized Logger getInstance() { if(instance == null) { instance = new Logger(); } return instance; }

11 @alextheedom #JavaEE Conventional Implementation Only one instance of Logger created Created by first call the getInstance() Thread safe creation Use it like so: Logger logger = Logger.getInstance();

12 @alextheedom #JavaEE Java EE Implementation @Singleton public class Logger { private Logger() { // Creation code here } @Singleton public class Logger { private Logger() { // Creation code here }

13 @alextheedom #JavaEE Java EE Implementation Only one instance of Logger created Created by container (lazily) Knows it’s a singleton because @Singleton Use it like so: @Inject Logger logger; @Inject Logger logger;

14 @alextheedom #JavaEE Java EE Implementation Eager instantiation @Startup Perform startup tasks @PostConstruct

15 @alextheedom #JavaEE Java EE Implementation @Startup @Singleton public class Logger { private Logger() { // Creation code here } @PostConstruct void startUpTask() { // Perform start up tasks } @Startup @Singleton public class Logger { private Logger() { // Creation code here } @PostConstruct void startUpTask() { // Perform start up tasks }

16 @alextheedom #JavaEE Java EE Implementation Specify dependent instantiation @DependsOn("PrimaryBean") @Startup @Singleton public class Logger {... } @DependsOn("PrimaryBean") @Startup @Singleton public class Logger {... }

17 @alextheedom #JavaEE Java EE Implementation @DependsOn("PrimaryBean") @Startup @Singleton public class Logger { private Logger() { // Creation code here } @PostConstruct void startUpTask() { // Perform start up tasks } @DependsOn("PrimaryBean") @Startup @Singleton public class Logger { private Logger() { // Creation code here } @PostConstruct void startUpTask() { // Perform start up tasks }

18 @alextheedom #JavaEE Java EE Implementation Conclusions so far Very different implementation Substantially less boilerplate code Enhancements via specialized annotations

19 @alextheedom #JavaEE Java EE Implementation Further enhancements Fine grain concurrency management Container vs. bean managed @Singleton @ConcurrencyManagement(ConcurrencyManagementType.BEAN) public class Logger {... } @Singleton @ConcurrencyManagement(ConcurrencyManagementType.BEAN) public class Logger {... } What about method access?

20 @alextheedom #JavaEE Java EE Implementation Method access LockType.WRITE and LockType.READ @Lock(LockType.WRITE) public void addMessage(String message) { // Add message to log } @Lock(LockType.READ) public String getMessage() { // Get message } @Lock(LockType.WRITE) public void addMessage(String message) { // Add message to log } @Lock(LockType.READ) public String getMessage() { // Get message }

21 @alextheedom #JavaEE Java EE Implementation Method access timeout ConcurrentAccessTimeoutException Defined by annotation @AccessTimeout Class and method level @AccessTimeout(value = 30, unit=TimeUnit.SECONDS) @Lock(LockType.WRITE) public void addMessage(String message) { // Add message to log } @AccessTimeout(value = 30, unit=TimeUnit.SECONDS) @Lock(LockType.WRITE) public void addMessage(String message) { // Add message to log }

22 @alextheedom #JavaEE Conclusion Substantially different manner of implementation Marked reduction in code (~50%) Implementation improved via specialized annotations Startup behavioural characteristics Fine grain control over concurrency and access timeout

23 @alextheedom #JavaEE Factory Pattern Creational pattern Interface for creating family of objects Clients are decoupled from the creation

24 @alextheedom #JavaEE Conventional Implementation public class DrinksMachineFactory implements AbstractDrinksMachineFactory{ public DrinksMachine createCoffeeMachine() { return new CoffeeMachine(); } public class DrinksMachineFactory implements AbstractDrinksMachineFactory{ public DrinksMachine createCoffeeMachine() { return new CoffeeMachine(); } Use it like so: AbstractDrinksMachineFactory factory = new DrinksMachineFactory(); DrinksMachine coffeeMachine = factory.createCoffeeMachine(); AbstractDrinksMachineFactory factory = new DrinksMachineFactory(); DrinksMachine coffeeMachine = factory.createCoffeeMachine(); Abstract factory

25 @alextheedom #JavaEE Java EE Implementation CDI framework is a factory public class CoffeeMachine implements DrinksMachine { // Implementation code } public class CoffeeMachine implements DrinksMachine { // Implementation code } Use it like so: @Inject DrinksMachine drinksMachine; @Inject DrinksMachine drinksMachine;

26 @alextheedom #JavaEE Java EE Implementation Problem! Multiple concrete implementations public class CoffeeMachine implements DrinksMachine { // Implementation code } public class SoftDrinksMachine implements DrinksMachine { // Implementation code } public class CoffeeMachine implements DrinksMachine { // Implementation code } public class SoftDrinksMachine implements DrinksMachine { // Implementation code } @Inject DrinksMachine drinksMachine; @Inject DrinksMachine drinksMachine; Which DrinksMachine to inject?

27 @alextheedom #JavaEE Java EE Implementation Solution! Qualifiers @Qualifier @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD, ElementType.FIELD}) public @interface SoftDrink @Qualifier @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD, ElementType.FIELD}) public @interface SoftDrink @Qualifier @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD, ElementType.FIELD}) public @interface Coffee @Qualifier @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD, ElementType.FIELD}) public @interface Coffee

28 @alextheedom #JavaEE Java EE Implementation Annotate respective classes @Coffee public class CoffeeMachine implements DrinksMachine { // Implementation code } @Coffee public class CoffeeMachine implements DrinksMachine { // Implementation code } @SoftDrink public class SoftDrinksMachine implements DrinksMachine { // Implementation code } @SoftDrink public class SoftDrinksMachine implements DrinksMachine { // Implementation code }

29 @alextheedom #JavaEE Java EE Implementation Annotate injection points @Inject @SoftDrink DrinksMachine softDrinksMachine; @Inject @SoftDrink DrinksMachine softDrinksMachine; @Inject @Coffee DrinksMachine coffeeDrinksMachine ; @Inject @Coffee DrinksMachine coffeeDrinksMachine ;

30 @alextheedom #JavaEE Java EE Implementation Conclusions so far No boilerplate code Container does all the hard work Disambiguation via qualifiers Remember Only JSR299 beans are ‘injectable’

31 @alextheedom #JavaEE Java EE Implementation Dive deeper Producer methods Use it like so: @Produces @Library public List getLibrary(){ // Generate a List of books called 'library' return library; } @Produces @Library public List getLibrary(){ // Generate a List of books called 'library' return library; } @Inject @Library List library; @Inject @Library List library;

32 @alextheedom #JavaEE Java EE Implementation Scope Determines when method called Life of object: @RequestScoped -> @ApplicationScoped @SessionScoped @Produces @Library public List getLibrary(){ // Generate a List of books called 'library' return library; } @SessionScoped @Produces @Library public List getLibrary(){ // Generate a List of books called 'library' return library; }

33 @alextheedom #JavaEE Java EE Implementation Parameterized creation Use it like so: public class LoggerFactory{ @Produces public Logger logger(InjectionPoint injectionPoint) { return Logger.getLogger( injectionPoint.getMember().getDeclaringClass().getName()); } } public class LoggerFactory{ @Produces public Logger logger(InjectionPoint injectionPoint) { return Logger.getLogger( injectionPoint.getMember().getDeclaringClass().getName()); } } @Inject private transient Logger logger;

34 @alextheedom #JavaEE Java EE Implementation Conclusions so far Virtually any object can be made injectable Automatic per class configuration

35 @alextheedom #JavaEE Harnessing the power of CDI A variation on the factory pattern Imaginative use of CDI Multiple implementations of the same interface Collect and select pattern Uses @Any, enums, annotation literals and Instance class

36 @alextheedom #JavaEE Harnessing the power of CDI @Any @Inject private Instance messages @Any @Inject private Instance messages

37 @alextheedom #JavaEE Harnessing the power of CDI Distinguish between message types using qualifiers @Qualifier @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.FIELD, ElementType.TYPE}) public @interface Message { Type value(); enum Type{ SHORT, LONG } } @Qualifier @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.FIELD, ElementType.TYPE}) public @interface Message { Type value(); enum Type{ SHORT, LONG } }

38 @alextheedom #JavaEE Harnessing the power of CDI Annotate our classes @Message(Message.Type.SHORT) public class ShortMessage implements MessageType{ // Short message implementation code } @Message(Message.Type.SHORT) public class ShortMessage implements MessageType{ // Short message implementation code } @Message(Message.Type.LONG) public class LongMessage implements MessageType{ // Long message implementation code } @Message(Message.Type.LONG) public class LongMessage implements MessageType{ // Long message implementation code }

39 @alextheedom #JavaEE Harnessing the power of CDI Create an annotation literal for messages public class MessageLiteral extends AnnotationLiteral implements Message { private Type type; public MessageLiteral(Type type) { this.type = type; } public Type value() { return type; } public class MessageLiteral extends AnnotationLiteral implements Message { private Type type; public MessageLiteral(Type type) { this.type = type; } public Type value() { return type; }

40 @alextheedom #JavaEE Harnessing the power of CDI Putting the puzzle together @Inject @Any private Instance messages; public MessageType getMessage(Message.Type type) { MessageLiteral literal = new MessageLiteral(type); Instance typeMessages = messages.select(literal); return typeMessages.get(); } @Inject @Any private Instance messages; public MessageType getMessage(Message.Type type) { MessageLiteral literal = new MessageLiteral(type); Instance typeMessages = messages.select(literal); return typeMessages.get(); }

41 @alextheedom #JavaEE Harnessing the power of CDI Use it like so: @Inject private MessageFactory mf; public void doMessage(){ MessageType m = mf.getMessage(Message.Type.SHORT); } @Inject private MessageFactory mf; public void doMessage(){ MessageType m = mf.getMessage(Message.Type.SHORT); }

42 @alextheedom #JavaEE Conclusion CDI removes need for factory pattern Container does all the hard work Substantially less boilerplate code Disambiguation via qualifiers Increased creativity Collect and select

43 @alextheedom #JavaEE Other Patterns Facade Decorator Observer

44 @alextheedom #JavaEE Fa ç ade Pattern Encapsulates complicated logic @Stateless, @Stateful @Stateless public class BankServiceFacade{ @Inject private AccountService accountService; } @Stateless public class BankServiceFacade{ @Inject private AccountService accountService; } @Stateless public class AccountService{} @Stateless public class AccountService{}

45 @alextheedom #JavaEE Decorator Pattern Dynamically adds logic to an object

46 @alextheedom #JavaEE Decorator Pattern @Decorator @Priority(Interceptor.Priority.APPLICATION) public class PriceDiscountDecorator implements Product { @Any @Inject @Delegate private Product product; public String generateLabel() { product.setPrice(product.getPrice() * 0.5); return product.generateLabel(); } } @Decorator @Priority(Interceptor.Priority.APPLICATION) public class PriceDiscountDecorator implements Product { @Any @Inject @Delegate private Product product; public String generateLabel() { product.setPrice(product.getPrice() * 0.5); return product.generateLabel(); } }

47 @alextheedom #JavaEE Observer Pattern Notifies dependents of state change public void trace(@Observes String message){ // Response to String event } public void trace(@Observes String message){ // Response to String event }

48 @alextheedom #JavaEE Final Conclusion Efficiency savings Greater control over behaviour New features enhance implementation Opens doors to new pattern design

49 #JavaEE @alextheedom 40% discount with promo code VBK43 when ordering through wiley.com valid until 1st September

50 @YourTwitterHandle#DVXFR14{session hashtag} @alextheedom #JavaEE Q & A

51 #JavaEE @alextheedom Professional Java EE Design Patterns Alex Theedom @alextheedom alextheedom.com Thank You

Download ppt "Professional Java EE Design Patterns Alex alextheedom.com."

Similar presentations

Design Patterns.

Design Patterns.
Creational Design Patterns. Creational DP: Abstracts the instantiation process Helps make a system independent of how objects are created, composed, represented.

Creational Design Patterns. Creational DP: Abstracts the instantiation process Helps make a system independent of how objects are created, composed, represented.
ISE 390 Dynamic Web Development Java EE Web Applications.

ISE 390 Dynamic Web Development Java EE Web Applications.
Spring, Hibernate and Web Services 13 th September 2014.

Spring, Hibernate and Web Services 13 th September 2014.
Introduction to Spring Matt Wheeler. Notes This is a training NOT a presentation Please ask questions Prerequisites – Introduction to Java Stack – Basic.

Introduction to Spring Matt Wheeler. Notes This is a training NOT a presentation Please ask questions Prerequisites – Introduction to Java Stack – Basic.
10/8/12http://free.smartbiz.vn1 JSR-299 CDI Java Contexts & Dependency Injection JBoss Weld Implementation.

10/8/12http://free.smartbiz.vn1 JSR-299 CDI Java Contexts & Dependency Injection JBoss Weld Implementation.
George Blank University Lecturer. CS 602 Java and the Web Object Oriented Software Development Using Java Chapter 4.

George Blank University Lecturer. CS 602 Java and the Web Object Oriented Software Development Using Java Chapter 4.
1 Scenario: Audio Clip Imagine that your application played an audio clip Based on user action, a different audio clip may begin playing You want only.

1 Scenario: Audio Clip Imagine that your application played an audio clip Based on user action, a different audio clip may begin playing You want only.
Design Patterns Module Name - Object Oriented Modeling By Archana Munnangi S R Kumar Utkarsh Batwal (17040771) (17040037) (17040842)

Design Patterns Module Name - Object Oriented Modeling By Archana Munnangi S R Kumar Utkarsh Batwal ( ) ( ) ( )
CERN – European Organization for Nuclear Research GS Department – Administrative Information Services Design Patterns in Groovy Nicolas Décrevel Advanced.

CERN – European Organization for Nuclear Research GS Department – Administrative Information Services Design Patterns in Groovy Nicolas Décrevel Advanced.
What Is a Factory Pattern?.  Factories are classes that create or construct something.  In the case of object-oriented code languages, factories construct.

What Is a Factory Pattern?.  Factories are classes that create or construct something.  In the case of object-oriented code languages, factories construct.
Java Frameworks Indy Java Users Group January 29, 2003.

Java Frameworks Indy Java Users Group January 29, 2003.
Singleton Christopher Chiaverini Software Design & Documentation September 18, 2003.

Singleton Christopher Chiaverini Software Design & Documentation September 18, 2003.
Design Patterns.

Design Patterns.
Spring core v3.x Prepared by: Nhan Le. History v3.0 Spring Expression Language Java based bean metadata v3.1 Cache Abstraction Bean Definition Profile.

Spring core v3.x Prepared by: Nhan Le. History v3.0 Spring Expression Language Java based bean metadata v3.1 Cache Abstraction Bean Definition Profile.
CSSE 374: Introduction to Gang of Four Design Patterns

CSSE 374: Introduction to Gang of Four Design Patterns
Software Engineering 1 Object-oriented Analysis and Design Applying UML and Patterns An Introduction to Object-oriented Analysis and Design and Iterative.

Software Engineering 1 Object-oriented Analysis and Design Applying UML and Patterns An Introduction to Object-oriented Analysis and Design and Iterative.
Design Pattern. The Observer Pattern The Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all.

Design Pattern. The Observer Pattern The Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all.
Tech Talk Go4 Factory Patterns Presented By: Matt Wilson.

Tech Talk Go4 Factory Patterns Presented By: Matt Wilson.
Patterns in programming 1. What are patterns? “A design pattern is a general, reusable solution to a commonly occurring problem in software. A design.

Patterns in programming 1. What are patterns? “A design pattern is a general, reusable solution to a commonly occurring problem in software. A design.

Similar presentations

Ads by Google