1. Repository<T, ID> - Base Marker Interface
Special Effect: Pure marker - no methods
public interface UserRepository extends Repository<User, Long> {// Only custom methods allowed - no built-in CRUDList<User> findByUsername(String username);
}
Use Case: When you want only custom query methods without any built-in CRUD operations.
2. CrudRepository<T, ID> - Basic CRUD Operations
Special Effect: Complete CRUD functionality
public interface ProductRepository extends CrudRepository<Product, Long> {// Automatically gets these methods:// save(), findById(), findAll(), delete(), count(), exists()
}// Usage
productRepository.save(product); // INSERT/UPDATE
productRepository.findById(1L); // SELECT by ID
productRepository.findAll(); // SELECT all
productRepository.deleteById(1L); // DELETE
productRepository.count(); // COUNT records
Use Case: Basic database operations without pagination needs.
3. PagingAndSortingRepository<T, ID> - Pagination & Sorting
Special Effect: Adds pagination and sorting capabilities
public interface OrderRepository extends PagingAndSortingRepository<Order, Long> {// Gets CRUD methods + pagination/sorting
}// Usage
Pageable pageable = PageRequest.of(0, 10, Sort.by("createdDate").descending());
Page<Order> orders = orderRepository.findAll(pageable);// Sorting only
Iterable<Order> sortedOrders = orderRepository.findAll(Sort.by("amount").ascending());
Use Case: When you need large dataset handling with pagination and sorting.
4. JpaRepository<T, ID> - JPA-Specific Enhancements
Special Effect: JPA optimizations and batch operations
public interface UserRepository extends JpaRepository<User, Long> {// Gets all previous methods + JPA-specific optimizations
}// Special JPA methods
userRepository.flush(); // Force synchronization with DB
userRepository.saveAndFlush(user); // Save + immediate flush
userRepository.deleteInBatch(users); // Batch delete (single SQL)
userRepository.deleteAllInBatch(); // Delete all in one SQL statement
Use Case: JPA/Hibernate applications needing performance optimizations.
5. ReactiveCrudRepository<T, ID> - Reactive Programming
Special Effect: Non-blocking, reactive operations
public interface UserRepository extends ReactiveCrudRepository<User, Long> {// Returns Mono/Flux instead of regular objects
}// Usage
Mono<User> user = userRepository.findById(1L); // Single result
Flux<User> users = userRepository.findAll(); // Multiple results
Mono<User> saved = userRepository.save(user); // Non-blocking save
Use Case: High-concurrency applications with reactive streams.
6. RxJava2CrudRepository<T, ID> - RxJava Integration
Special Effect: RxJava reactive types
public interface ProductRepository extends RxJava2CrudRepository<Product, Long> {// Returns Observable/Single/Maybe
}// Usage
Single<Product> product = productRepository.findById(1L);
Observable<Product> products = productRepository.findAll();
Use Case: Applications using RxJava reactive programming.
Comparison Summary:
Interface Methods Return Types Special Feature
Repository 0 Custom Pure marker
CrudRepository ~12 Objects/Iterables Basic CRUD
PagingAndSortingRepository +2 Page/Slice Pagination
JpaRepository +8 Lists JPA optimizations
ReactiveCrudRepository ~12 Mono/Flux Non-blocking
RxJava2CrudRepository ~12 Single/Observable RxJava types
Choosing the Right Interface:
- Repository → Custom methods only
- CrudRepository → Basic CRUD needs
- PagingAndSortingRepository → Large datasets
- JpaRepository → JPA/Hibernate projects (most common)
- ReactiveCrudRepository → WebFlux/reactive applications
- RxJava2CrudRepository → RxJava-based projects
Each interface builds upon the previous one, adding specific capabilities for different use cases.