Singleton Design Pattern

By -

Creational Design Pattern

Summary
Singleton Design pattern is used to provide a mechanism so that a Class can have only one instance. So when Client try's to use an instance of Singleton Class it gets the same instance. 
Singleton.

Details
Singleton Design pattern make sure that Class which implement this pattern can have only one instance. In case of Java, only one instance in a single JVM.
For instance if we want only one instance of Cache Class which would store temporary values in memory.

Singleton pattern is also used in Logger Classes. Logger provide single instance for logging which is used by application code.

Singleton design pattern is implemented by following mechanism
1) Making the constructor private. So that Client cannot create different instances
2) Provide a static method, which the client will interact to get the instance of the class
3) Do not offer any setter method for the object
4) If any getter for individual property returns any object reference, it should return a copy of it
5) Taking care of reflection api, to do this we can throw exception in the constructor if it the instance is not initialized.

Advantages
Provide an option to make sure the instance is single, and if we want to create multiple copies of the object still they will be same.

Useful when we want only one instance of a Class like Service, shared resource etc.

Disadvantages
Depending on the need, DI/IOC can be better suitable.

Possible ways to break

Following points need to be thought about possible ways to break the Singleton Class to get more than one instance.

In java one can use the Reflection API to alter the constructor (private) of the Singleton Class to create different instances. This can be taken care by throwing exception from the private constructor.

In Java one can use the clone. It can be achieved by overriding clone() method and throwing Exception.

Multiple thread can break the Singleton Class. It needs to be taken care as well.

In Java Serialization can cause breaking this contract. It can be handled by returning the instance from readResolve() method.
Example
Let's take example of a House Key. We want only one key for the whole house. We do not want any way to temper the key. We want only one identical key to be available. If any one needs a key, essentially they will get the same single key instance. We can utilize the Singleton pattern to make sure that the key once generated is not modifiable.

Here the Class HouseKey implements Singleton pattern, and that Class make sure only one instance of the key exists.

Class Diagram

Sample Code


public class HouseKey implements Serializable {
  private static final long serialVersionUID = 1L;
  private String keyPattern;
  private Long keyDate;

  private static HouseKey instance;

  // private constructor
  private HouseKey() {

  }

  // public get instance method
  public static HouseKey getInstance() {
    if (instance == null) {
      synchronized (HouseKey.class) {
        instance = new HouseKey();
        instance.keyPattern = "key 12345";
        instance.keyDate = new Date().getTime();
      }
    }
    return instance;
  }


  // safeguard against Clone
  protected Object clone() throws CloneNotSupportedException {
    throw new CloneNotSupportedException();
  }


  // safeguard against Serialization
  public Object readResolve() {
    return HouseKey.getInstance();
  }

  @Override
  public String toString() {
    return "HouseKey " + this.keyPattern + "  " + this.keyDate;
  }
}











Github Code 










References












































Comments











Post a Comment



















Popular posts from this blog









Difference between volatile and synchronized







By







-















volatile   is a field modifier, while synchronized  modifies code blocks and methods. So we can specify three variations of a simple accessor using those two keywords:          int i1;              int geti1() {return i1;} volatile int i2;              int geti2() {return i2;}         int i3; synchronized int geti3() {return i3;}  geti1()  accesses the value currently stored in i1  in the current thread . Threads can have local copies of variables, and the data does not have to be the same as the data held in other threads. In particular, another thread may have updated i1  in it's thread, but the value in the current thread could be different from that updated value. In fact Java has the idea of a "main" memory, and this is the memory that holds the current "correct" value for variables. Threads can have their own copy of data for variables, and the thread copy can be different from the "main" memory. So in fact, it is possible for the "main"








Read more










Converting Java Map to String







By







-















 Java Collections framework, String manipulation etc is something that we often encounter in Development process.  For processing collections (like checking null/empty, Intersection, Disjunction) We do have some of the very use full libraries.   Some of the Collection related libraries are Apche Commons Collections and Google  Collections(Guava).   Problem Use Case    This article explains how to convert a Java Map  to String(and vice versa) using different libraries and technique.   One way is to use StringBuilder(Or String) and loop though the Map and build the String by applying some sort of separator ( for key:value and entry). Here we have to take care of the null value etc.   Without Any Library  If we want to convert the map to a String with key value separator and also individual entry seperator in the resulting String, we have to write code for that. For a simple Map, we have to iterate though the map, take care of the null values etc. Following is a sample to get String built








Read more










Masking Credit Card number in Java







By







-















 Sometimes we need to mask crucial information like Credit Card Numbers, CVV numbers etc before storing  or logging the information. This example mask Credit Card Number (Except last 4 Digit) from a Text which contains information along with Credit Card Number.   The following example demonstrates how we can easily mask the credit card with Matcher and Pattern Classes. This Sample Code uses Matcher and Pattern.  Pattern Used in this sample is not optimized for Credit Card Numbers, this pattern will get any numerical numbers in the String Content.  Based on the Credit Card Type a more efficient and Strict RegEx can be used to mask the Credit Card.     /**Mask the Credit card number but last four digit value **/                    Pattern PATTERN = Pattern.compile( "[0-9]+" );           String message = content;         Matcher matcher = PATTERN.matcher(message);         String maskingChar = "*";         StringBuilder finalMask = new StringBuilder(maskingChar);       








Read more