Java Design Patterns Part - 2

Design Pattern In Java

Hibernate                                                                                       Core Java

Structural : This design patterns describes how classes and objects can be composed, to form larger structures. These patterns teaches us about how the classes inherit from each other and how they are composed from other classes.This patterns simplifies the structure by identifying the relationships.

1. Adapter – This pattern work as a connector or helps to join two unrelated interfaces so that they can work together.

For example :

A well defined example for Adapter design pattern is Laptop charger. When we are using our laptop then to charge the laptop battery we are connecting this to mainline socket but using adapter in between. Because normally laptop requires least voltage(20 V) in order to charge its battery and mainline is supplying more voltage(240 V). So we need a power adapter which converts and provide the required voltage in order to charge the Laptop battery. This pattern combines the capability of two independent interfaces. The Adapter pattern which is a Structural Design pattern can be used to realize relationship between entities. This pattern can be implemented in two ways, either by Inheritance(is-a) or by Composition(has-a).

The description given by Gof(Gang of four) about this pattern is below:

"Convert the interface of class into another interface clients expect.Adapter lets class work together that couldn't otherwise because of incompatible interfaces".

Examples as per java API :

• java.util.Arrays#asList()
• java.io.InputStreamReader(InputStream) (returns a Reader)
• java.io.OutputStreamWriter(OutputStream) (returns a Writer)
• javax.xml.bind.annotation.adapters.XmlAdapter#marshal() and #unmarshal()

2. Bridge – The Bridge pattern is known as Structural pattern and GOF states that pattern tells that :

As per GOF:-
“Decouple an abstraction from its implementation so that the two can vary independently”

Mainly this pattern is useful in graphic toolkits that needs to run on a variety of platforms. The display of various image formats on different OS is the best example of the Bridge pattern. The image structure is the same across all OS, but how they are viewed (the implementation) is different on each OS. This is the type of decoupling that the Bridge pattern allows. This pattern allows us to separate the abstraction and the implementation. It means to say that this pattern allows the Abstraction and the Implementation to be developed independently.This layer provides a two layer of abstraction. The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

For example:

The example of TV and Remote Control(typo in diagram) can demonstrate the two layers of abstraction. We have an interface for TV and an abstract class for remote control. It is not a good idea to make a concrete class for either of them, because other vendors may make different implementations.

• This creates 2 hierarchies i.e. One for abstraction and another for implementation.

• This avoids permanent binding by removing the dependency between abstraction & Implementation.
• It should be used when we need to switch between the various implementations.
• Client should not be impacted if there is any modification in abstraction implementation.
• Abstraction and Implementation can be extended separately.
• When we are dealing with multiple implementations then we can use Bridge Design Pattern.
• Bridge will coordinates between Abstraction and Implementation.

Example as per java API : Object Persistence API is the example of Bridge Design pattern.

A classic example of Bridge is Drivers. Each driver is an instance of the Adapter pattern, providing the interface a client expects, using the services of a class with a different interface. An overall design that uses drivers is an instance of Bridge. The JDBC architecture decouples an abstraction from its implementation so that the two can vary independently—an excellent example of Bridge e.g. JDBC ODBC Bridge driver.

3. Composite – This design pattern is represents as a partitioning design pattern. This pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The purpose of composite is to "compose" objects into tree structures to represent part-whole hierarchies.

As per Gof:-

"Compose objects into tree structure to represent part-whole hierarchies.Composite lets client treat individual objects and compositions of objects uniformly".

Questions : What is the meaning of part-whole hierarchies?

Answer:- A system is a combination of subsystem or components. Components are the combinations of smaller components. Similarly, Smaller components are the combination of smaller elements. This is known as part-whole hierarchy.

This design pattern allows as to have a tree structure and each node of that tree structure will perform a specific task.

Real World example : We can think about our company. There are Project Director, Project Director will further categorized into Project managers, Project managers can be further divided into Project leads, then Project lead can have many Team leads, then Team leads may have many Developers.

This is making a tree structure and composing an organization and each node of this tree structure is performing some task for that they are getting salary.

Example as per API : - Tiles framework in Struts, which help us to compose a webpage using multiple JSP pages. This is actually an implementation of CompositeView Pattern and this pattern itself based on Composite pattern.

Another example as per Java API :-

java.awt.Container#add(Component) (In awt, we have containers and components, the best example for Composite pattern)

javax.faces.component.UIComponent#getChildren() (In JSF UI)

4. Decorater – Decorater design pattern is used to change or extend the behavior of an object. This is used to attach or add responsibities to an individual object dynamically, without affecting the behavior of other objects from the same class. Alternatively this is also known as Wrapper. In different words, this pattern uses composition instead of inheritance to extend the functionality of an object at runtime.

When to use decorator design pattern?

Answer :- we can use this design pattern when :

When we need to attach responsibilities to individual objects dynamically without affecting other objects.

For adding the beviour which can be withdrawn in future.

Extending functionality by sub-classing is no longer possible.

Decorators are very flexible alternative of inheritance.

Example in java API :-

[I] In Java Collection API, the checkedXXX(), synchronizedXXX() and unmodifiableXXX() methods.

e.g. checkedCollection(), checkedSet(), checkedSortedSet(), checkedList(), checkedMap(), checkedSortedMap() are the examples of decorator design pattern.

[II] javax.servlet.http.HttpServletRequestWrapper and HttpServletResponseWrapper.

[III] All subclasses of java.io.InputStream, OutputStream, Reader and Writer constructors because

These classes are abstract since in that way they can be easily extended and the implementor classes could use the Decorator Pattern. With the decorator pattern, the implementor class can add dynamic functionality at runtime. For example: we can have an InputStream which will read a File using FileInputStream or it can also be read serialized objects using ObjectInputStream.

ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("/project/resources/test.dat"));

5. Facade – A facade is generally the face of a building, especially the principal face. This word comes from the French Language, which means frontage or face. During a building creation it is having many complexities like boring, wiring, pipelining or others, but we are seeing only the frontface of the building because it hides all the complexities.

This is the way we can use Facade design pattern. This pattern provides a simplified interface to a set of interfaces within the system and thus it hides the complexities of the subsystem from the client.

As per GoF:- definition facade design pattern is, “Provide a unified interface to a set of interfaces in a subsystem. Facade Pattern defines a higher-level interface that makes the subsystem easier to use.”

We can use Facade design pattern for :-

• It will increase the readability.
• Easy to maintain.
• Makes a library easier to use, understand and test because the facade will provide convenient methods for common tasks.
• It reduces the dependencies of the external code, so it provides flexibility.
• We can use this pattern to collate all the complex method calls and related code blocks and channelizes it through one single Facade class. In this way with respect to client there is only one single call. Even if we make changes to the subsystem classes and then there is no impact to the client call which means this increases loose coupling.

Example :- Service oriented architectures make use of the facade pattern. For example, in web services, one web service might provide access to a number of smaller services that have been hidden from the caller by the facade. Like while purchasing clothes online how it is interacting through payment gateway that complexities if unknown by the user.

Facade design pattern used in java api are : -

javax.servlet.http.HttpSession

javax.servlet.http.HttpServletRequest

javax.servlet.http.HttpServletResponse

javax.faces.context.ExternalContext

javax.faces.context.FacesContext, it internally uses many others the abstract/interface types like LifeCycle, ViewHandler, NavigationHandler and many more without showing that to enduser.

6. Flyweight – It is a kind of design pattern which is used to reduce the creation of multiple objects which are identical in nature. This design pattern is used when there is requirement to create large number of objects which are similar in nature. It helps to minimizes the memory use by sharing as much data as possible in case of similar objects. As we know creation of multiple objects consumes huge memory so this design pattern is providing a solution to minimizes the amount of memory by sharing those objects or we can say that this pattern allow us to reuse memory spaces within the application when we have huge number of objects which are almost same in nature. Sharing is the key feature of this design pattern.

As per GOF : "Facilitates the reuse of many fine grained objects, making the utilization of large numbers of objects more efficient."

For example : Suppose we are making a game for Android OS like car race app, then the shape of car we can share by providing different colours to those cars and making them different cars for the game players.

When we think about this pattern then we need to think about the concept of Intrinsic and Extrinsic state, The data which comes in Intrinsic state are constant, so they can be stored in memory. But the data which comes under Extrinsic state are not constant, they are required to be calculated on the fly or dynamically, so the reason they can't be stored in memory. So as per the above example, we can consider as the shape of each car will be under Intrinsic state and the color of each car will be in Extrinsic state.

In Java API : String Pool implementation is the best example of Flyweight Design Pattern.

Other example are : java.lang.Integer#valueOf(int) (also on Boolean, Byte, Character, Short and Long)

7) Proxy : The word Proxy means an agent or substitute which is authorized to act for another one. In the design pattern Proxy will represent another object.

As per GOF :- "Provide a surrogate or placeholder for another object to control access over it."

This pattern is also known as surrogate or placeholder. This pattern allows us to create a wrapper class over the actual object. Here wrapper class which acts as proxy helps to control access to real object so in turn we can add extra functionalities to real object without changing real object's.

For example: In most of the IT companies, they are allowing the internet use but blocking the sites like Gmail, Yahoo, Facebbok by using a Proxy server which acts as a wrapper of original server.

Example as per java API : java.lang.reflect.Proxy, java.rmi.*.

If we are working with Spring, then also we can find AOP proxies object.

We can use proxy design pattern in below conditions:

[1] During the need of a remote proxy which provides a local representative for an object in a different address space by providing interface for remote resources such as web service or REST resources.

[2] During the need of a virtual proxy which creates expensive object on demand.

[3] During the need of a protection proxy which controls access to the original object. Protection proxies are useful when objects should have different access rights.

[4] During the need of a smart reference which is a replacement for a bare pointer that performs additional actions when an object is accessed.

[5] Suppose there is a requirement to add a thread-safe feature to an existing class without changing the existing class's code.

Java-Collections                                           Spring-Core                                                     JSON

Next part - Behavioral Design Pattern is under progress