This article provides an introduction to Enterprise Java design Patterns.
Model represents application’s data and business logic.
View is the visual representation of data in model.
Controller links the view to the model and directs application flow.
In Java EE, model is located in business layer, usually in form of an EJB module.
Controller and view are in web tier.
View is likely constructed in html, jsp, jsf etc.
Controller is normally a servlet that receives HTTP requests from user.
Data Access Pattern
This pattern uses Data Access Objects to abstract all access to data source. All data access operations happen through the DAO layer.
Dao pattern has following components :
- DAO Interface
- DAO interface implementation
- DAO factory
- Data Transfer Object (DTO)
DTO is also called the value object. It carries data from data access layer to web layer.
In Java EE, Java persistence API(JPA) is used for data access using Object relational mapping.
The tables are mapped to a POJO annotated as @Entity. The members of this POJO class are also annotated and mapped to fields(columns).
Façade provides the full power of subsystem via as easy to use interface
Façade pattern is commonly used in following scenarios:
- provide interface to legacy backend system
- to reduce n/w calls. Façade makes many calls to subsystems, but remote client makes only one call to façade
- to encapsulate flow and inner details for data security
Facades can be implemented using Stateful/Stateless session beans .
The façade class can be injected with the actual services using @Inject and it can have the logic to call the appropriate service/EJB.
Ensure a class has only instance and provide a global point of access to it.
Used in following scenarios:
- to access shared data across whole application, such as configuration data
- to create logger instance.. usually only one instance is needed in application
- to implement cache that can cache static data/resources and improve performance
Spring creates singleton beans by default.
Java uses singleton pattern in the implementation of runtime class.
In Java EE, just by adding @Singleton annotation to a class, you can turn it into a singleton bean.
In DI, instead of creating hard dependencies and creating new objects using new or lookups, the required resource is injected to the object through xml configuration or annotations.
Spring provides Dependency injection.
Java EE and EJB 3 provides several annotations for this :
@Resource for injecting data source, url etc
@EJB for injecting EJB
@WebServiceRef for injecting webservices
EJB 3.1 added a new annotation @Inject. This provided a common interface for injection between other J2EE frameworks and Java env.
Abstracts the logic of object creation from where the objects are used
Often factory is implemented as a singleton or static class because normally only one instance of factory is required.
In Java EE, you can use @Produces annotation to create an object and @Inject to inject the cretated object where its required.
In decorator pattern, purpose is to wrap an object so that you can dynamically add responsibilities at runtime.
Java BufferedInputsteam is a good example of decorator.
Decorator implementation in Java EE introduces annotations @Decorator & @Delegate.
@Decorator annotates the Decorator class.
@Delegate annotates delegate injection point where the decorated class is injected
In Observer pattern, the object that changes its state informs other objects about it. The objects that are notified are called observers and the object that notified them is called Subject.
Example of this is chat room application. Observer is the chat server and each client is a subject.
Java EE offers observer implementation using @Observes annotation and Events interface.
Any method annotated with @Observes listens for certain type of events.
GOF Design Patterns
Professional Java EE Design Patterns
Head First Design Patterns
© 2015, www.topjavatutorial.com. All rights reserved. On republishing this post, you must provide link to original post