The factory design pattern is one of the creational patterns. This pattern will allow the creation of objects with out exposing the instantiation logic to the client.
Motivation: During one of the project implementation, we were trying to read the data from multiple sources like database, CSV and XML. In this case, we created readers like DatabaseReader, CSVReader, and XMLReader, etc. But, in the client code, we were using the concrete implementations to instantiate the class(For example, XMLReader reader = new XMLReader()) and leading to a lot of duplication of object creational logic across the client code. To overcome this issue, we created an interface called Reader and all the readers implemented the Reader interface. Defined a factory method which will take necessary parameters from the client and creates the required object.
Design Elements: The below design elements are required to use the factory design pattern.
- Product<interface> – defines the interface of objects the factory method creates.
- ConcreteProduct – implements the product interface
- Creator – declares the factory method, which returns an object of type Product. The creator may also define a default implementation of the factory method that returns a default ConcreteProduct object.
Implementation:
Example:
In this example, we will create Reader objects to read Database, CSV and XML data by using “Factory Design Pattern”. As a first step, we will create a Reader interface.
package org.smarttechie;
public interface Reader {
public String read();
}
Now, we will provide the implementation for Reader interface to read the database.
package org.smarttechie;
public class DataBaseReader implements Reader {
@Override
public String read() {
return "Reading database";
}
}
The implementation to read CSV and XML data.
package org.smarttechie;
public class XMLReader implements Reader {
@Override
public String read() {
return "XML file reader";
}
}
package org.smarttechie;
public class CSVReader implements Reader {
@Override
public String read() {
return "CSV file reading";
}
}
Now, we will create a factory method to create reader objects.
package org.smarttechie;
public class ReaderFactory {
public static Reader getReader(String readerType) {
Reader reader = null;
if (readerType.equalsIgnoreCase("XML")) {
reader = new XMLReader();
} else if (readerType.equalsIgnoreCase("CSV")) {
reader = new CSVReader();
} else if (readerType.equalsIgnoreCase("DB")) {
reader = new DataBaseReader();
}
return reader;
}
}
With a test class, we will test the factory design pattern.
package org.smarttechie;
public class FactoryPatternTest {
/**
* @param args
*/
public static void main(String[] args) {
System.out.println(ReaderFactory.getReader("XML").read());
}
}
In the above code, we need to ask the ReaderFactory to get the specific reader. So, client code no need to know the implementation of the concrete reader classes. The code used in this article is available here.
Siva Janapati is an Architect with experience in building Cloud Native Microservices architectures, Reactive Systems, Large scale distributed systems, and Serverless Systems. Siva has hands-on in architecture, design, and implementation of scalable systems using Cloud, Java, Go lang, Apache Kafka, Apache Solr, Spring, Spring Boot, Lightbend reactive tech stack, APIGEE edge & on-premise and other open-source, proprietary technologies. Expertise working with and building RESTful, GraphQL APIs. He has successfully delivered multiple applications in retail, telco, and financial services domains. He manages the GitHub(https://github.com/2013techsmarts) where he put the source code of his work related to his blog posts.
Smart Techie 
Good Simple example