Top Banner
@alextheedom #JavaEE Professional Java EE Design Patterns Alex Theedom @alextheedom alextheedom.com
35

Devoxx UK 2015: How Java EE has changed pattern implementation

Aug 13, 2015

Download

Technology

atheedom
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Page 1: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Professional Java EE Design PatternsProfessional Java EE Design Patterns

Alex Theedom@alextheedom alextheedom.com

Alex Theedom@alextheedom alextheedom.com

Page 2: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Speaker’s BioSpeaker’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

Page 3: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

What to expectWhat to expect

•What’s the story

•Deep Dive

•Singleton Pattern

•Factory Pattern

•Quickie Patterns

•Façade, Decorator, Observer and more…

Page 4: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

What’s the storyWhat’s the story

•Java EE changed design pattern implementation

• Implementation has simplified

• Implementation has been enhanced

•Greater creativity

Page 5: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Singleton PatternSingleton Pattern

•Ubiquitous and controversial but inescapable

•Instantiated once

•Not normally destroyed during application life cycle

Page 6: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Conventional ImplementationConventional 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;     } }

Page 7: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Conventional ImplementationConventional Implementation

•Only one instance of Logger created

•Created by first call to getInstance()

•Thread safe creation

•Use it like so:

Logger logger = Logger.getInstance(); Logger logger = Logger.getInstance();

Page 8: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava EE Implementation @Singleton public class Logger {

     private Logger() {          // Creation code here     }

}

@Singleton public class Logger {

     private Logger() {          // Creation code here     }

}

Page 9: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava 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;

Page 10: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava EE Implementation

•Eager instantiation @Startup

•Perform startup tasks @PostConstruct

Page 11: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava 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     } }

Page 12: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava EE Implementation

•Specify dependent instantiation

@DependsOn("MyBean") @Startup @Singleton public class Logger {     ... }

@DependsOn("MyBean") @Startup @Singleton public class Logger {     ... }

Page 13: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava EE Implementation

@DependsOn("MyBean") @Startup @Singleton public class Logger{

     private Logger(){          // Creation code here     }

     @PostConstruct     void startUpTask(){          // Perform start up tasks     } }

@DependsOn("MyBean") @Startup @Singleton public class Logger{

     private Logger(){          // Creation code here     }

     @PostConstruct     void startUpTask(){          // Perform start up tasks     } }

Page 14: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava EE Implementation

•Conclusions so far

•Very different implementation

•Substantially less boilerplate code

•Enhancements via specialized annotations

Page 15: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava 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?

Page 16: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava EE Implementation•Method access

•LockType.WRITE and LockType.READ

•Method access timeout

@AccessTimeout(value = 30, unit=TimeUnit.SECONDS) @Lock(LockType.WRITE) public void addMessage(String message) {    // Add message to log }

 @Lock(LockType.READ) public String getMessage() {     // Get message }

@AccessTimeout(value = 30, unit=TimeUnit.SECONDS) @Lock(LockType.WRITE) public void addMessage(String message) {    // Add message to log }

 @Lock(LockType.READ) public String getMessage() {     // Get message }

Page 17: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

ConclusionConclusion

•Substantially different manner of implementation

•Marked reduction in code

•Implementation improved via specialized annotations

•Startup behavioural characteristics

•Fine grain control over concurrency and access timeout

Page 18: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Factory PatternFactory Pattern

•Creational pattern

•Interface for creating family of objects

•Clients are decoupled from the creation

Page 19: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava EE Implementation

•CDI framework is a factory

public class CoffeeMachine implements DrinksMachine {} public class CoffeeMachine implements DrinksMachine {}

•Use it like so:

@Inject DrinksMachine drinksMachine; @Inject DrinksMachine drinksMachine;

Page 20: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava EE Implementation

•Problem! Multiple concrete implementations

public class CoffeeMachine implements DrinksMachine{…}

public class SoftDrinksMachine implements DrinksMachine{…}

public class CoffeeMachine implements DrinksMachine{…}

public class SoftDrinksMachine implements DrinksMachine{…}

@Inject DrinksMachine drinksMachine; @Inject DrinksMachine drinksMachine;

•Which DrinksMachine to inject?

Page 21: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava 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

Page 22: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava EE Implementation•Annotate respective classes

@Coffee public class CoffeeMachine implements DrinksMachine {} @Coffee public class CoffeeMachine implements DrinksMachine {}

@SoftDrink public class SoftDrinksMachine implements DrinksMachine {} @SoftDrink public class SoftDrinksMachine implements DrinksMachine {}

•Annotate injection points @Inject @SoftDrink DrinksMachine softDrinksMachine; @Inject @SoftDrink DrinksMachine softDrinksMachine;

@Inject @Coffee DrinksMachine coffeeDrinksMachine; @Inject @Coffee DrinksMachine coffeeDrinksMachine;

Page 23: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava EE Implementation

•Conclusions so far

•No boilerplate code

•Container does all the hard work

•Disambiguation via qualifiers

•Remember

•Only JSR299 beans are ‘injectable’

Page 24: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava EE Implementation

•Dive deeper

•Producer methods

•Use it like so:

@Produces @Library public List<Book> getLibrary(){     // Generate a List of books called 'library'     return library; }

@Produces @Library public List<Book> getLibrary(){     // Generate a List of books called 'library'     return library; }

@Inject @Library List<Books> library; @Inject @Library List<Books> library;

Page 25: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava EE Implementation

•Scope

•Determines when method called

•Life of object: @RequestScoped -> @ApplicationScoped @RequestScoped @Produces @Library public List<Book> getLibrary(){     // Generate a List of books called 'library'     return library; }

@RequestScoped @Produces @Library public List<Book> getLibrary(){     // Generate a List of books called 'library'     return library; }

Page 26: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Java EE ImplementationJava 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; @Inject private transient Logger logger;

Page 27: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

ConclusionConclusion

•CDI removes need for factory pattern

•Container does all the hard work

•Substantially less boilerplate code

•Disambiguation via qualifiers

•Virtually any object can be made injectable

•Automatic per class configuration

Page 28: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Other PatternsOther Patterns

•Façade

•Decorator

•Observer

•and more…

Page 29: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Façade PatternFaç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{}

Page 30: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Decorator PatternDecorator Pattern

•Dynamically adds logic to an object

Page 31: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Decorator PatternDecorator 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();    } }

Page 32: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Observer PatternObserver 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 }

Page 33: Devoxx UK 2015: How Java EE has changed pattern implementation

@alextheedom@alextheedom#JavaEE#JavaEE

Final ConclusionFinal Conclusion

•Efficiency savings

•Greater control over behaviour

•New features enhance implementation

•Opens doors to new pattern design

Page 34: Devoxx UK 2015: How Java EE has changed pattern implementation

#JavaEE#JavaEE @alextheedom@alextheedom

40% discount with promo

code VBK43when ordering through

wiley.comvalid until 1st September

Page 35: Devoxx UK 2015: How Java EE has changed pattern implementation

@YourTwitterHandle#DVXFR14{session hashtag} @alextheedom@alextheedom#JavaEE#JavaEE

Q&A