Generic Repository in Spring for Different Entities

Building a Generic Repository in Spring for Saving Different Entities

In modern application development, especially when working with Spring Boot, we often encounter the need to manage various entities in a consistent and efficient manner. One effective way to achieve this is by implementing a Generic Repository pattern. This blog post will guide you through the concept of a Generic Repository, its benefits, and how to implement it in a Spring Boot application. 

Building a Generic Repository in Spring for Saving Different Entities

What is a Generic Repository?

A Generic Repository is a design pattern that allows you to create a single repository interface that can handle multiple entity types. This approach promotes code reusability, reduces redundancy, and simplifies data access logic.

Benefits of Using a Generic Repository

• Code Reusability: You can reuse the same repository methods for different entities.
• Consistency: It provides a consistent way to interact with the database.
• Maintainability: Changes to the repository logic can be made in one place.
• Type Safety: Generics provide compile-time type checking.

Diagram: Generic Repository Structure

+---------------------+
|   GenericRepository |
+---------------------+
| + save(T entity)    |
| + findById(ID id)   |
| + findAll()         |
| + delete(T entity)  |
+---------------------+
          ^
          |
          |
+---------------------+       +----------------------+
|   UserRepository    |       |   ProductRepository  |
+---------------------+       +----------------------+
| + findByUsername()  |       | + findByCategory()   |
+---------------------+       +----------------------+

Implementing a Generic Repository in Spring Boot

Step 1: Define the Generic Repository Interface

First, we will create a generic interface that defines the basic CRUD operations.

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface GenericRepository<T, ID> extends JpaRepository<T, ID> {
    // Additional custom methods can be defined here if needed
}

Step 2: Create Entity Classes

Next, let’s create a couple of entity classes, User and Product.

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;

    // Getters and Setters
}

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String category;

    // Getters and Setters
}

Step 3: Create Specific Repositories

Now, we will create specific repositories for our entities by extending the GenericRepository.

import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends GenericRepository<User , Long> {
    User findByUsername(String username);
}

@Repository
public interface ProductRepository extends GenericRepository<Product, Long> {
    List<Product> findByCategory(String category);
}

Step 4: Service Layer

Next, we will create a service layer to handle business logic.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User saveUser  (User  user) {
        return userRepository.save(user);
    }

    public List<User > getAllUsers() {
        return userRepository.findAll();
    }
}

@Service
public class ProductService {
    @Autowired
    private ProductRepository productRepository;

    public Product saveProduct(Product product) {
        return productRepository.save(product);
    }

    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }
}

Step 5: Controller Layer

Finally, we will create a controller layer to expose REST endpoints.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @PostMapping
    public User createUser  (@RequestBody User user) {
        return userService.saveUser  (user);
    }

    @GetMapping
    public List<User > getAllUsers() {
        return userService.getAllUsers();
    }
}

@RestController
@RequestMapping("/products")
public class ProductController {
    @Autowired
    private ProductService productService;

    @PostMapping
    public Product createProduct(@RequestBody Product product) {
        return productService.saveProduct(product);
    }

    @GetMapping
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }
}

Conclusion

In this blog post, we explored the concept of a Generic Repository in Spring Boot, highlighting its advantages and providing a step-by-step implementation guide. By utilizing a Generic Repository, developers can streamline their data access layer, ensuring that their code remains clean, maintainable, and efficient. This pattern not only enhances code reusability but also promotes a consistent approach to handling various entities within an application. As you continue to build your Spring Boot applications, consider implementing a Generic Repository to simplify your data management tasks and improve overall application architecture.