Back to: Java Design Patterns
Repository Design Pattern in Java
In this article, I am going to discuss the Repository Design Pattern in Java with Examples. Please read our previous article where we discussed the Dependency Injection Design Pattern in Java. In this article, we will explore the Repository Design Pattern in Java, its advantages, disadvantages, and practical applications in software development.
What is Repository Design Pattern?
In software development, efficient and maintainable data access is crucial for building robust applications. The Repository design pattern provides a structured approach to encapsulate data access logic and simplify interactions with persistent storage.
The Repository design pattern is a behavioral pattern that provides a layer of abstraction between the application and the data persistence layer. It separates the data access logic from the business logic, allowing for a clear separation of concerns and improved maintainability.
What is Repository?
A repository is nothing but a class defined for an entity, with all the possible database operations. For example, a repository for a Student entity will have the basic CRUD operations and any other possible operations related to the Student entity.
Why do we need the Repository Design Pattern in Java?
As we already discussed, nowadays, most data-driven applications need to access the data residing in one or more other data sources. Most of the time data sources will be a database. Again, these data-driven applications need to have a good and secure strategy for data access to perform the CRUD operations against the underlying database. One of the most important aspects of this strategy is the separation between the actual database, queries, and other data access logic from the rest of the application. The Repository Design Pattern is one of the most popular design patterns to achieve such separation between the actual database, queries, and other data access logic from the rest of the application.
Components of Repository Design Pattern
The Repository Design Pattern consists of the following key components:
- Repository: The Repository acts as a central access point to the data persistence layer. It provides a set of methods for performing common data operations, such as create, read, update, and delete (CRUD) operations. The Repository shields the application from the underlying data access details and provides a consistent interface for data manipulation.
- Entity: An Entity represents a domain object or data entity that is persisted in the underlying data storage. It encapsulates the data and behavior related to a specific concept in the application domain.
- Data Persistence Layer: The Data Persistence Layer represents the storage mechanism used to persist data, such as a relational database, document store, or file system. The Repository interacts with the Data Persistence Layer to perform data operations.
Example to Understand Repository Design Pattern in Java
In a student management system, the Repository Design Pattern can be employed to handle the storage and retrieval of student data. Let’s consider a scenario where we have a StudentRepository responsible for managing the persistence and retrieval of student records from a database.
The StudentRepository acts as an abstraction layer between the application and the database. It provides methods to create, read, update, and delete student records. The repository encapsulates the data access logic, shielding the application from the intricacies of the database implementation.
In this example, the StudentRepository handles tasks such as creating new student records, retrieving student information based on various criteria (e.g., by ID), updating student details, and deleting student records.
By utilizing the Repository design pattern, the student management system achieves separation of concerns and improves maintainability. The business logic of the application remains decoupled from the specific database implementation, allowing for easier maintenance and potential future changes. Additionally, the Repository pattern promotes code reusability, as the same StudentRepository can be utilized across different components of the system, and it enhances testability by facilitating the use of mock repositories during unit testing. The UML Diagram of this example is given below using Repository Design Pattern.
Implementing Repository Design Pattern in Java
Step 1: Create a new directory to store all the class files of this project.
Step 2: Open VS Code and create a new project, called repository.
Step 3: In the project, create a new file called Student.java. Add the following code to the file:
public class Student
{
private int id;
private String name, email;
public Student(int id, String name, String email) {
this.id = id;
this.name = name;
this.email = email;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", email=" + email + "]";
}
}
This is the POJO class that will be treated as the entity class for this project. Note that the constructors, setters, getters, and the toString() method can be automatically generated using the “Source Action…” option in the right-click menu of VS Code.
Step 4: In the project, create a new file called StudentRepository.java. Add the following code to the file:
public interface StudentRepository
{
public Student getStudentById (int id);
public void addStudent(Student s);
public void updateStudent(Student s);
public void deleteStudent(int id);
public boolean exists(int id);
}
This interface defines the methods that need to be implemented by the concrete repository class.
Step 5: In the project, create a new file called StudentRepositoryImpl.java. Add the following code to the file:
import java.util.HashMap;
public class StudentRepositoryImpl implements StudentRepository
{
private HashMap<Integer, Student> students;
public StudentRepositoryImpl()
{students = new HashMap<>();}
@Override
public Student getStudentById(int id)
{return students.get(id);}
@Override
public void addStudent(Student s)
{students.put(s.getId(), s);}
@Override
public void updateStudent(Student s)
{
(students.get(s.getId())).setName(s.getName());
(students.get(s.getId())).setEmail(s.getEmail());
}
@Override
public void deleteStudent(int id)
{students.remove(id);}
@Override
public boolean exists(int id)
{return students.containsKey(id);}
}
This class implements the method defined in the StudentRepository interface.
Step 6: In the project, create a new file called RepositoryPatternDemo.java. This class contains the main() function. Add the following code to RepositoryPatternDemo.java. Implement the addStudent(), retreiveStudent(), updateStudent() and deleteStudent() methods:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class RepositoryPatternDemo
{
private static StudentRepositoryImpl repo;
private static BufferedReader br;
public static void main(String[] args) throws NumberFormatException, IOException
{
br = new BufferedReader(new InputStreamReader(System.in));
int choice = 0;
repo = new StudentRepositoryImpl();
while (choice != 9)
{
System.out.println();
System.out.println();
System.out.println("Choose operation: ");
System.out.println();
System.out.println("1. Add New Student");
System.out.println("2. Retreive Student");
System.out.println("3. Update Student");
System.out.println("4. Delete Student");
System.out.println("9. Exit");
System.out.println();
System.out.print("Enter choice here: ");
choice = Integer.parseInt(br.readLine());
switch (choice)
{
case 1: addStudent(); break;
case 2: retreiveStudent(); break;
case 3: updateStudent(); break;
case 4: deleteStudent(); break;
case 9: System.out.println("Bye!"); break;
default: System.out.println("Invalid!");
}
}
}
private static void addStudent() throws NumberFormatException, IOException
{
int id;
String name, email;
System.out.println("Entering student: ");
System.out.print("Enter id: ");
id = Integer.parseInt(br.readLine());
if (repo.exists(id))
{
System.out.println("ID Exists! Cannot add student!");
return;
}
else
{
System.out.print("Enter name: ");
name = br.readLine();
System.out.print("Enter email: ");
email = br.readLine();
repo.addStudent(new Student(id, name, email));
}
}
private static void retreiveStudent() throws NumberFormatException, IOException
{
int id;
System.out.println("Retreiving student: ");
System.out.print("Enter id: ");
id = Integer.parseInt(br.readLine());
if (repo.exists(id))
System.out.println(repo.getStudentById(id).toString());
else
System.out.println("Student not found!");
}
private static void updateStudent() throws NumberFormatException, IOException
{
int id;
String name, email;
System.out.println("Entering student: ");
System.out.print("Enter id: ");
id = Integer.parseInt(br.readLine());
if (repo.exists(id))
{
System.out.print("Enter name: ");
name = br.readLine();
System.out.print("Enter email: ");
email = br.readLine();
repo.updateStudent(new Student(id, name, email));
}
else
System.out.println("ID does not exist! Cannot update student!");
}
private static void deleteStudent() throws NumberFormatException, IOException
{
int id;
System.out.println("Retreiving student: ");
System.out.print("Enter id: ");
id = Integer.parseInt(br.readLine());
if (repo.exists(id))
repo.deleteStudent(id);
else
System.out.println("Student not found!");
}
}
Step 7: Compile and execute the application. Ensure compilation is successful. Verify that the program works as expected.
Congratulations! You now know how to implement Repository Design Pattern in Java!
UML Diagram of Repository Design Pattern:
Now, let us see the Repository Design Pattern UML Diagram Components with our Example so that you can easily understand the UML Diagram.
The classes can be described as follows:
- Object: This represents the entity that needs to be stored in the repository.
- ObjectRepository & ObjectRepositoryImpl: This represents the repository interface and its implementation.
- DriverClass: This class contains the main() function and is responsible for the simulation of the program.
Advantages of Repository Design Pattern in Java:
The followings are the advantages of using the Repository Design Pattern in Java:
- Separation of Concerns: One of the primary advantages of the Repository pattern is the clear separation of concerns it provides. By encapsulating the data access logic within the Repository, the business logic of the application remains decoupled from the specifics of the underlying data storage. This separation promotes code maintainability, modularity, and testability.
- Abstraction over Data Access Details: The Repository pattern abstracts the data access details and provides a consistent interface for data manipulation. This abstraction shields the application from the complexities of the underlying data storage, such as the query language or database-specific operations. It allows developers to work with domain-specific methods and concepts rather than low-level data access mechanisms.
- Code Reusability: The Repository pattern promotes code reusability. By encapsulating the data access logic within the Repository, multiple components of the application can utilize the same Repository to interact with the data persistence layer. This reduces code duplication and enhances maintainability.
- Testability: The Repository pattern greatly facilitates unit testing. Since the Repository acts as a wrapper around the data access logic, it is easier to replace the actual implementation with mock objects or test doubles during testing. This allows for isolated testing of the application’s business logic without the need to access the actual data storage.
- Flexibility and Portability: The Repository pattern provides flexibility and portability. The underlying data storage can be changed or replaced without affecting the application’s business logic. By modifying the implementation of the Repository to work with a different data storage mechanism, the application can seamlessly transition to new technology or adapt to changing requirements.
Disadvantages of Repository Design Pattern in Java:
The followings are the disadvantages of using the Repository Design Pattern in Java:
- Increased Complexity: Implementing the Repository pattern introduces additional complexity to the application architecture. It requires creating and maintaining the Repository interfaces, implementations, and mappings between entities and data storage. This added complexity may result in a steeper learning curve for developers.
- Performance Overhead: The Repository pattern may introduce performance overhead due to the abstraction layer between the application and the data storage. Additional processing and mapping may be required to translate the application’s data operations to the specific data storage format. However, modern frameworks and techniques can mitigate this overhead to a large extent.
- Learning Curve: Adopting the Repository pattern may require developers to understand and follow certain conventions and patterns for organizing the application’s data access logic. This learning curve may be challenging, especially for developers new to the pattern or working on legacy codebases.
- Size and Complexity of the Repository: As the application grows and the number of entities and data operations increases, the Repository itself can become large and complex. Managing a complex Repository implementation may require careful organization and attention to maintain its clarity and effectiveness.
Real-Time use Cases of the Repository Design Pattern in Java
The Repository Design Pattern finds practical applications in various software development scenarios:
- Data Access Layer: The Repository pattern is commonly used in the implementation of the Data Access Layer (DAL) in an application. It provides a clean and structured way to encapsulate data access logic, making it easier to manage and maintain.
- Persistence Ignorance: The Repository pattern enables the application to be persistence-agnostic. The business logic of the application can remain unaware of the specific details of the underlying data storage, allowing for more flexibility and adaptability.
- Codebase Modularity: By separating the data access logic into a Repository, the application’s codebase can be organized into distinct layers, promoting modularity and separation of concerns. This improves the overall architecture and maintainability of the codebase.
- Unit Testing: The Repository pattern greatly facilitates unit testing by allowing the use of mock objects or test doubles in place of the actual data storage. This makes it easier to isolate the business logic and perform comprehensive testing.
In the next article, I am going to discuss the Generic Repository Design Pattern in Java with Examples. Here, in this article, I try to explain Repository Design Pattern in Java with Examples. I hope you understood the need for and use of the Repository Design Pattern in Java.
About the Author: Pranaya Rout
Pranaya Rout has published more than 3,000 articles in his 11-year career. Pranaya Rout has very good experience with Microsoft Technologies, Including C#, VB, ASP.NET MVC, ASP.NET Web API, EF, EF Core, ADO.NET, LINQ, SQL Server, MYSQL, Oracle, ASP.NET Core, Cloud Computing, Microservices, Design Patterns and still learning new technologies.