Intermediate

// pom.xml
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

// Domain model
@Entity
public class BankAccount {
  @Id @GeneratedValue
  private Long id;
  private String owner;
  private BigDecimal balance;
  // constructors, getters, setters
}

@Entity
public class TransferLog {
  @Id @GeneratedValue
  private Long id;
  private Long fromAccount;
  private Long toAccount;
  private BigDecimal amount;
  private LocalDateTime timestamp;
  // constructors, getters, setters
}

// Repository
public interface AccountRepository extends JpaRepository<BankAccount, Long> {}
public interface TransferLogRepository extends JpaRepository<TransferLog, Long> {}

// Service with transactions
@Service
public class TransferService {
  @Autowired private AccountRepository accountRepo;
  // => Injected repository for BankAccount CRUD operations
  @Autowired private TransferLogRepository logRepo;
  // => Injected repository for TransferLog audit trail

  @Transactional // Default: REQUIRED propagation, rollback on RuntimeException
  public void transfer(Long fromId, Long toId, BigDecimal amount) {
    BankAccount from = accountRepo.findById(fromId)
      // => Retrieves source account, throws IllegalArgumentException if not found
      .orElseThrow(() -> new IllegalArgumentException("Source not found"));
    BankAccount to = accountRepo.findById(toId)
      // => Retrieves destination account for credit operation
      .orElseThrow(() -> new IllegalArgumentException("Destination not found"));

    if (from.getBalance().compareTo(amount) < 0) {
      throw new IllegalStateException("Insufficient funds"); // => Rollback entire transaction
    }

    from.setBalance(from.getBalance().subtract(amount));
    // => Debits source account (new balance = old balance - amount)
    to.setBalance(to.getBalance().add(amount));
    // => Credits destination account (new balance = old balance + amount)
    accountRepo.save(from);
    // => Persists updated source account to database
    accountRepo.save(to);
    // => Persists updated destination account to database

    // Log the transfer
    TransferLog log = new TransferLog();
    log.setFromAccount(fromId);
    log.setToAccount(toId);
    log.setAmount(amount);
    log.setTimestamp(LocalDateTime.now());
    // => Records exact time of transfer for audit trail
    logRepo.save(log);
    // => Persists transfer log entry (all-or-nothing with account updates)

    // If exception occurs here, ALL changes (both accounts + log) rollback
  }
}

// Controller
@RestController
@RequestMapping("/api/transfers")
public class TransferController {
  @Autowired private TransferService transferService;

  @PostMapping
  public ResponseEntity<String> transfer(
    @RequestParam Long fromId,
    @RequestParam Long toId,
    @RequestParam BigDecimal amount
  ) {
    try {
      transferService.transfer(fromId, toId, amount);
      return ResponseEntity.ok("Transfer successful");
    } catch (Exception e) {
      return ResponseEntity.badRequest().body(e.getMessage());
    }
  }
}

@Service
public class InventoryService {
  @Autowired private ProductRepository productRepo;

  // READ_COMMITTED: Prevents dirty reads
  @Transactional(isolation = Isolation.READ_COMMITTED)
  public int getStock(Long productId) {
    Product p = productRepo.findById(productId).orElseThrow();
    // => Fetches product from database within transaction boundary
    return p.getStock(); // => Sees only committed data from other transactions
  }

  // REPEATABLE_READ: Prevents non-repeatable reads
  @Transactional(isolation = Isolation.REPEATABLE_READ)
  public void processOrder(Long productId, int quantity) {
    Product p = productRepo.findById(productId).orElseThrow();
    // => Fetches product from database within transaction boundary
    int initialStock = p.getStock(); // => 100
    // => Captures initial stock value (locks this value for entire transaction)

    // Simulate delay
    Thread.sleep(1000);

    // Even if another transaction updates stock, this transaction still sees 100
    int currentStock = productRepo.findById(productId).get().getStock(); // => Still 100

    if (currentStock >= quantity) {
      p.setStock(currentStock - quantity);
      productRepo.save(p);
    }
  }

  // SERIALIZABLE: Strictest isolation (rarely needed)
  @Transactional(isolation = Isolation.SERIALIZABLE)
  public void criticalOperation(Long productId) {
    // Locks prevent concurrent access—transactions execute serially
  }
}

@Entity
public class Product {
  @Id @GeneratedValue
  private Long id;
  private String name;
  private int stock;

  @Version // Optimistic locking version field
  private Long version;

  // constructors, getters, setters
}

@Service
public class StockService {
  @Autowired private ProductRepository productRepo;

  @Transactional
  public void decreaseStock(Long productId, int quantity) {
    Product product = productRepo.findById(productId).orElseThrow();
    // version = 1

    product.setStock(product.getStock() - quantity);
    productRepo.save(product);
    // SQL: UPDATE product SET stock=?, version=2 WHERE id=? AND version=1

    // If another transaction updated product (version=2), this fails with OptimisticLockException
  }

  // Retry logic for conflicts
  @Transactional
  public void decreaseStockWithRetry(Long productId, int quantity) {
    int maxRetries = 3;
    for (int i = 0; i < maxRetries; i++) {
      try {
        Product product = productRepo.findById(productId).orElseThrow();
        product.setStock(product.getStock() - quantity);
        productRepo.save(product);
        return; // Success
      } catch (OptimisticLockException e) {
        if (i == maxRetries - 1) throw e; // Retries exhausted
        // Retry with fresh data
      }
    }
  }
}

// application.properties
spring.jpa.properties.hibernate.jdbc.batch_size=50
spring.jpa.properties.hibernate.order_inserts=true
spring.jpa.properties.hibernate.order_updates=true

@Service
public class BulkImportService {
  @Autowired private ProductRepository productRepo;
  @Autowired private EntityManager entityManager;

  // Inefficient: N+1 queries
  @Transactional
  public void importProductsSlow(List<Product> products) {
    for (Product p : products) {
      productRepo.save(p); // => 1000 products = 1000 INSERT statements
    }
  }

  // Better: Batch inserts
  @Transactional
  public void importProductsFast(List<Product> products) {
    productRepo.saveAll(products); // => Batches 1000 products into 20 INSERTs (50 per batch)
  }

  // Best: Manual batch flushing for large datasets
  @Transactional
  public void importProductsOptimal(List<Product> products) {
    int batchSize = 50;
    for (int i = 0; i < products.size(); i++) {
      entityManager.persist(products.get(i));
      if (i % batchSize == 0 && i > 0) {
        entityManager.flush(); // Force batch execution
        entityManager.clear(); // Free memory
      }
    }
  }

  // Bulk update with JPQL
  @Transactional
  public void discountAllProducts(BigDecimal discountPercent) {
    int updated = entityManager.createQuery(
      "UPDATE Product p SET p.price = p.price * :factor"
    ).setParameter("factor", BigDecimal.ONE.subtract(discountPercent))
     .executeUpdate(); // => Single UPDATE statement for all rows

    System.out.println("Updated " + updated + " products");
  }
}

// pom.xml
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-security</artifactId>
</dependency>

// With just the dependency, Spring Boot:
// 1. Generates random password on startup (console log)
// 2. Secures all endpoints with HTTP Basic Auth
// 3. Default username: "user"
// 4. CSRF protection enabled
// 5. Session management configured

@RestController
public class SecuredController {
  @GetMapping("/public")
  public String publicEndpoint() {
    return "Accessible without auth"; // => Still requires login by default!
  }

  @GetMapping("/api/data")
  public String securedEndpoint() {
    return "Protected data"; // => Requires authentication
  }
}

// Run the app and see console:
// Using generated security password: a1b2c3d4-e5f6-7890-abcd-ef1234567890
// curl http://localhost:8080/api/data => 401 Unauthorized
// curl -u user:a1b2c3d4-e5f6-7890-abcd-ef1234567890 http://localhost:8080/api/data => "Protected data"

@Configuration
@EnableWebSecurity
public class SecurityConfig {

  @Bean
  public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http // => Configure HTTP security chain
      .authorizeHttpRequests(auth -> auth // => Define authorization rules
        .requestMatchers("/public/**").permitAll() // => Public endpoints (no auth required)
        .requestMatchers("/admin/**").hasRole("ADMIN") // => Admin endpoints (requires ADMIN role)
        .anyRequest().authenticated() // => All other endpoints require authentication
      )
      .formLogin(form -> form // => Configure form-based login
        .loginPage("/login") // => Custom login page URL
        .permitAll()
      )
      .logout(logout -> logout.permitAll()); // => Enable logout endpoint

    return http.build(); // => Build SecurityFilterChain bean
  }

  @Bean
  public UserDetailsService userDetailsService() {
    // => In-memory users (for demo—use database/LDAP in production)
    UserDetails user = User.builder() // => Create user with builder pattern
      .username("user") // => Username for authentication
      .password(passwordEncoder().encode("password123")) // => BCrypt-hashed password
      .roles("USER") // => Granted authority: ROLE_USER
      .build(); // => Immutable UserDetails object

    UserDetails admin = User.builder() // => Create admin user
      .username("admin") // => Admin username
      .password(passwordEncoder().encode("admin123")) // => BCrypt-hashed admin password
      .roles("ADMIN", "USER") // => Multiple roles: ROLE_ADMIN + ROLE_USER
      .build(); // => Admin has both USER and ADMIN privileges

    return new InMemoryUserDetailsManager(user, admin); // => Store users in memory (non-persistent)
  }

  @Bean
  public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder(); // => BCrypt with automatic salt generation (industry standard)
  }
}

// Controller
@RestController
public class ApiController {
  @GetMapping("/public/hello")
  public String publicHello() {
    return "Public endpoint"; // => Accessible without login
  }

  @GetMapping("/api/user-data")
  public String userData() {
    return "User data"; // => Requires USER or ADMIN role
  }

  @GetMapping("/admin/dashboard")
  public String adminDashboard() {
    return "Admin dashboard"; // => Requires ADMIN role only
  }
}

@Configuration
@EnableMethodSecurity // Enable method security annotations
public class MethodSecurityConfig {}

@Service
public class OrderService {
  @Autowired private OrderRepository orderRepo;

  @PreAuthorize("hasRole('USER')") // => Check role BEFORE method execution
  public List<Order> getMyOrders(String username) { // => username parameter from authenticated user
    return orderRepo.findByUsername(username); // => Query orders filtered by username
  }

  @PreAuthorize("hasRole('ADMIN')") // => ADMIN role required (throws AccessDeniedException if missing)
  public List<Order> getAllOrders() { // => Admin-only endpoint
    return orderRepo.findAll(); // => Returns ALL orders (no filtering)
  }

  @PreAuthorize("#username == authentication.name") // => SpEL expression: method param matches authenticated username
  public Order getOrder(String username, Long orderId) {
    return orderRepo.findByIdAndUsername(orderId, username) // => Query with composite key
      .orElseThrow(() -> new AccessDeniedException("Not authorized")); // => Explicit access denial
  }

  @PreAuthorize("hasRole('ADMIN') or #order.username == authentication.name") // => Admin OR resource owner can update
  public Order updateOrder(Order order) {
    return orderRepo.save(order); // => Persist updated order (authorization already checked)
  }

  @PostAuthorize("returnObject.username == authentication.name") // => Check AFTER execution (compare returned order's owner)
  public Order loadOrder(Long orderId) {
    return orderRepo.findById(orderId).orElseThrow(); // => Fetch order first
    // => THEN Spring verifies returnObject.username matches authentication.name
  }
}

// Controller
@RestController
@RequestMapping("/api/orders")
public class OrderController {
  @Autowired private OrderService orderService;

  @GetMapping("/my-orders") // => Endpoint: GET /api/orders/my-orders
  public List<Order> getMyOrders(@AuthenticationPrincipal UserDetails user) { // => Inject authenticated user
    return orderService.getMyOrders(user.getUsername()); // => Pass authenticated username to service layer
  }

  @GetMapping("/all")
  public List<Order> getAllOrders() {
    return orderService.getAllOrders(); // => Service method checks @PreAuthorize("hasRole('ADMIN')")
  }
}

// pom.xml
<dependency>
  <groupId>io.jsonwebtoken</groupId>
  <artifactId>jjwt-api</artifactId>
  <version>0.12.3</version>
</dependency>
<dependency>
  <groupId>io.jsonwebtoken</groupId>
  <artifactId>jjwt-impl</artifactId>
  <version>0.12.3</version>
</dependency>

// JWT utility class
@Component
public class JwtUtil {
  private String secret = "mySecretKey1234567890123456789012"; // 256-bit key
  private long expiration = 86400000; // 24 hours

  public String generateToken(String username) { // => Create JWT token for authenticated user
    return Jwts.builder() // => Start JWT builder
      .subject(username) // => Set "sub" claim (token owner)
      .issuedAt(new Date()) // => Set "iat" claim (issued at timestamp)
      .expiration(new Date(System.currentTimeMillis() + expiration)) // => Set "exp" claim (24h from now)
      .signWith(Keys.hmacShaKeyFor(secret.getBytes())) // => Sign with HS256 algorithm
      .compact(); // => Serialize to Base64-encoded string
    // => Result format: header.payload.signature (JWT standard)
  }

  public String extractUsername(String token) { // => Parse JWT and extract username
    return Jwts.parser() // => Create JWT parser
      .verifyWith(Keys.hmacShaKeyFor(secret.getBytes())) // => Verify signature with same secret key
      .build() // => Build parser instance
      .parseSignedClaims(token) // => Parse and validate JWT (throws if invalid/expired)
      .getPayload() // => Extract claims (payload section)
      .getSubject(); // => Get "sub" claim (username)
  }

  public boolean isTokenValid(String token, String username) { // => Comprehensive token validation
    try {
      String extractedUser = extractUsername(token); // => Parse token (throws if tampered/invalid)
      return extractedUser.equals(username) && !isTokenExpired(token); // => Check username match + expiration
    } catch (Exception e) { // => Catch signature verification failures, malformed tokens
      return false; // => Invalid token
    }
  }

  private boolean isTokenExpired(String token) { // => Check if token has expired
    Date expiration = Jwts.parser() // => Create parser
      .verifyWith(Keys.hmacShaKeyFor(secret.getBytes())) // => Verify signature
      .build() // => Build parser
      .parseSignedClaims(token) // => Parse JWT
      .getPayload() // => Extract claims
      .getExpiration(); // => Get "exp" claim (expiration timestamp)
    return expiration.before(new Date()); // => Compare exp with current time
  }
}

// JWT authentication filter
@Component
public class JwtAuthFilter extends OncePerRequestFilter {
  @Autowired private JwtUtil jwtUtil; // => Inject JWT utility for token operations
  @Autowired private UserDetailsService userDetailsService; // => Inject user details service

  @Override
  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
    throws ServletException, IOException {

    String header = request.getHeader("Authorization"); // => Extract Authorization header
    if (header != null && header.startsWith("Bearer ")) { // => Check for Bearer token format
      String token = header.substring(7); // => Remove "Bearer " prefix (7 chars)
      String username = jwtUtil.extractUsername(token); // => Parse JWT to extract username

      if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) { // => Valid username + not already authenticated
        UserDetails user = userDetailsService.loadUserByUsername(username); // => Load user from database/cache
        if (jwtUtil.isTokenValid(token, username)) { // => Verify signature + expiration + username match
          UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken( // => Create Spring Security auth token
            user, null, user.getAuthorities() // => principal, credentials (null for JWT), authorities
          );
          SecurityContextHolder.getContext().setAuthentication(auth); // => Set authentication in security context
        }
      }
    }
    chain.doFilter(request, response); // => Continue filter chain (with or without authentication)
  }
}

// Security config
@Configuration
@EnableWebSecurity
public class JwtSecurityConfig {
  @Autowired private JwtAuthFilter jwtAuthFilter;

  @Bean
  public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http
      .csrf(csrf -> csrf.disable()) // => Disable CSRF (not needed for stateless JWT APIs)
      .authorizeHttpRequests(auth -> auth // => Configure authorization
        .requestMatchers("/auth/**").permitAll() // => Public auth endpoints (login, register)
        .anyRequest().authenticated() // => All other endpoints require JWT
      )
      .sessionManagement(session -> session // => Configure session management
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS) // => No HTTP sessions (JWT is stateless)
      )
      .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class); // => Insert JWT filter before default auth filter

    return http.build(); // => Build SecurityFilterChain bean
  }
}

// Auth controller
@RestController
@RequestMapping("/auth")
public class AuthController {
  @Autowired private AuthenticationManager authManager; // => Spring Security authentication manager
  @Autowired private JwtUtil jwtUtil; // => Inject JWT utility

  @PostMapping("/login") // => Endpoint: POST /auth/login
  public ResponseEntity<String> login(@RequestBody LoginRequest request) { // => Accept JSON login request
    authManager.authenticate( // => Validate username + password (throws if invalid)
      new UsernamePasswordAuthenticationToken(request.getUsername(), request.getPassword()) // => Create auth token
    ); // => If authentication fails, throws BadCredentialsException
    String token = jwtUtil.generateToken(request.getUsername()); // => Generate JWT for authenticated user
    return ResponseEntity.ok(token); // => Return JWT to client
  }
}

// Usage:
// POST /auth/login {"username":"user1","password":"pass123"}
// Response: "eyJhbGciOiJIUzI1NiJ9..."
// GET /api/data with Header: Authorization: Bearer eyJhbGciOiJIUzI1NiJ9...

// pom.xml
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>

// application.yml
spring:
  security:
    oauth2:
      client:
        registration:
          google:
            client-id: YOUR_GOOGLE_CLIENT_ID
            client-secret: YOUR_GOOGLE_CLIENT_SECRET
            scope:
              - email
              - profile
          github:
            client-id: YOUR_GITHUB_CLIENT_ID
            client-secret: YOUR_GITHUB_CLIENT_SECRET
            scope:
              - user:email
              - read:user

// Security config
@Configuration
@EnableWebSecurity
public class OAuth2Config {
  @Bean
  public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http
      .authorizeHttpRequests(auth -> auth // => Configure URL authorization
        .requestMatchers("/", "/login", "/error").permitAll() // => Public pages
        .anyRequest().authenticated() // => All others require OAuth2 login
      )
      .oauth2Login(oauth2 -> oauth2 // => Configure OAuth2 login
        .loginPage("/login") // => Custom login page (links to Google/GitHub)
        .defaultSuccessUrl("/dashboard") // => Redirect after successful OAuth2 authentication
      );

    return http.build(); // => Build SecurityFilterChain bean
  }
}

// Controller
@RestController
public class ProfileController {
  @GetMapping("/dashboard") // => Protected endpoint
  public String dashboard(@AuthenticationPrincipal OAuth2User principal) { // => Inject OAuth2 authenticated user
    String name = principal.getAttribute("name"); // => Extract "name" claim from provider
    String email = principal.getAttribute("email"); // => Extract "email" claim
    return "Welcome, " + name + " (" + email + ")";
    // => Extracts user info from OAuth2 provider
  }

  @GetMapping("/user-info")
  public Map<String, Object> userInfo(@AuthenticationPrincipal OAuth2User principal) {
    return principal.getAttributes(); // => Complete OAuth2 profile (name, email, picture, etc.)
  }
}

// Flow:
// 1. User clicks "Login with Google"
// 2. Redirects to Google's login page
// 3. User authenticates with Google
// 4. Google redirects back with authorization code
// 5. Spring exchanges code for access token
// 6. Spring fetches user info from Google
// 7. User logged in, redirected to /dashboard

// Test class
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class ProductControllerIntegrationTest {
  @Autowired private TestRestTemplate restTemplate; // HTTP client for testing
  @Autowired private ProductRepository productRepo;

  @BeforeEach
  void setup() {
    productRepo.deleteAll(); // Clean database before each test
  }

  @Test
  void testCreateAndRetrieveProduct() {
    // Create product
    Product product = new Product("Laptop", 999.99);
    ResponseEntity<Product> createResponse = restTemplate.postForEntity(
      "/api/products", product, Product.class
    );
    assertEquals(HttpStatus.CREATED, createResponse.getStatusCode());
    Long productId = createResponse.getBody().getId();

    // Retrieve product
    ResponseEntity<Product> getResponse = restTemplate.getForEntity(
      "/api/products/" + productId, Product.class
    );
    assertEquals(HttpStatus.OK, getResponse.getStatusCode());
    assertEquals("Laptop", getResponse.getBody().getName());
    // => Full end-to-end test: controller → service → repository → database
  }

  @Test
  void testDeleteProduct() {
    Product product = productRepo.save(new Product("Mouse", 25.00));

    restTemplate.delete("/api/products/" + product.getId());

    assertFalse(productRepo.existsById(product.getId()));
    // => Verifies deletion through full stack
  }
}

// Mocking external dependencies
@SpringBootTest
public class OrderServiceTest {
  @Autowired private OrderService orderService;

  @MockBean // Replace real bean with mock
  private PaymentGateway paymentGateway;

  @Test
  void testProcessOrder() {
    // Stub mock behavior
    when(paymentGateway.charge(any(), any())).thenReturn(true);

    Order order = new Order("user1", 100.00);
    orderService.processOrder(order);

    verify(paymentGateway, times(1)).charge(eq("user1"), eq(100.00));
    // => Tests order processing without calling real payment gateway
  }
}

@WebMvcTest(ProductController.class) // Only load ProductController
public class ProductControllerUnitTest {
  @Autowired private MockMvc mockMvc; // Simulates HTTP requests

  @MockBean // Mock the service layer
  private ProductService productService;

  @Test
  void testGetProduct() throws Exception {
    // Arrange
    Product product = new Product(1L, "Laptop", 999.99);
    when(productService.findById(1L)).thenReturn(Optional.of(product));

    // Act & Assert
    mockMvc.perform(get("/api/products/1"))
      .andExpect(status().isOk())
      .andExpect(jsonPath("$.name").value("Laptop"))
      .andExpect(jsonPath("$.price").value(999.99));
    // => Tests controller logic without starting full app
  }

  @Test
  void testCreateProduct() throws Exception {
    Product product = new Product("Mouse", 25.00);
    when(productService.save(any(Product.class))).thenReturn(product);

    mockMvc.perform(post("/api/products")
        .contentType(MediaType.APPLICATION_JSON)
        .content("{\"name\":\"Mouse\",\"price\":25.00}"))
      .andExpect(status().isCreated())
      .andExpect(jsonPath("$.name").value("Mouse"));
  }

  @Test
  void testGetProductNotFound() throws Exception {
    when(productService.findById(999L)).thenReturn(Optional.empty());

    mockMvc.perform(get("/api/products/999"))
      .andExpect(status().isNotFound());
    // => Tests error handling
  }
}

// pom.xml
<dependency>
  <groupId>org.testcontainers</groupId>
  <artifactId>postgresql</artifactId>
  <version>1.19.3</version>
  <scope>test</scope>
</dependency>

// Test class
@SpringBootTest
@Testcontainers // Enable TestContainers support
public class ProductRepositoryTestContainersTest {
  @Container // Start PostgreSQL container
  static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16")
    .withDatabaseName("testdb")
    .withUsername("test")
    .withPassword("test");

  @DynamicPropertySource // Configure Spring to use container
  static void properties(DynamicPropertyRegistry registry) {
    registry.add("spring.datasource.url", postgres::getJdbcUrl);
    registry.add("spring.datasource.username", postgres::getUsername);
    registry.add("spring.datasource.password", postgres::getPassword);
  }

  @Autowired private ProductRepository productRepo;

  @Test
  void testSaveAndFind() {
    Product product = new Product("Keyboard", 75.00);
    productRepo.save(product);

    Optional<Product> found = productRepo.findById(product.getId());
    assertTrue(found.isPresent());
    assertEquals("Keyboard", found.get().getName());
    // => Tests against real PostgreSQL database in Docker
  }

  @Test
  void testCustomQuery() {
    productRepo.save(new Product("Mouse", 20.00));
    productRepo.save(new Product("Keyboard", 75.00));
    productRepo.save(new Product("Monitor", 300.00));

    List<Product> expensive = productRepo.findByPriceGreaterThan(50.00);
    assertEquals(2, expensive.size());
    // => Verifies custom queries against real database
  }
}

@ExtendWith(MockitoExtension.class) // Enable Mockito
public class OrderServiceUnitTest {
  @Mock // Create mock
  private OrderRepository orderRepo;

  @Mock
  private PaymentService paymentService;

  @InjectMocks // Inject mocks into service
  private OrderService orderService;

  @Test
  void testProcessOrder() {
    // Arrange
    Order order = new Order("user1", 100.00);
    when(orderRepo.save(any(Order.class))).thenReturn(order);
    when(paymentService.charge(anyString(), anyDouble())).thenReturn(true);

    // Act
    Order result = orderService.processOrder(order);

    // Assert
    assertNotNull(result);
    verify(orderRepo, times(1)).save(order); // Verify method called once
    verify(paymentService, times(1)).charge("user1", 100.00);
  }

  @Test
  void testProcessOrderPaymentFailure() {
    Order order = new Order("user1", 100.00);
    when(paymentService.charge(anyString(), anyDouble())).thenReturn(false);

    assertThrows(PaymentException.class, () -> {
      orderService.processOrder(order);
    });

    verify(orderRepo, never()).save(any()); // Verify save never called
    // => Tests failure scenarios
  }

  @Test
  void testArgumentCaptor() {
    Order order = new Order("user1", 100.00);
    when(paymentService.charge(anyString(), anyDouble())).thenReturn(true);

    orderService.processOrder(order);

    ArgumentCaptor<Order> captor = ArgumentCaptor.forClass(Order.class);
    verify(orderRepo).save(captor.capture());

    Order captured = captor.getValue();
    assertEquals("PROCESSED", captured.getStatus());
    // => Captures arguments passed to mocked methods
  }
}

// pom.xml
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

// Enable caching
@SpringBootApplication
@EnableCaching // Enable cache annotations
public class Application {
  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

// Service with caching
@Service
public class ProductService {
  @Autowired private ProductRepository productRepo;

  @Cacheable("products") // Cache results by method arguments
  public Product findById(Long id) {
    System.out.println("Fetching from database: " + id);
    return productRepo.findById(id).orElseThrow();
    // First call: prints "Fetching..." and queries database
    // Subsequent calls: returns cached value, no database query
  }

  @Cacheable(value = "products", key = "#name") // Custom cache key
  public List<Product> findByName(String name) {
    System.out.println("Querying database for: " + name);
    return productRepo.findByNameContaining(name);
  }

  @CachePut(value = "products", key = "#result.id") // Update cache after method
  public Product save(Product product) {
    return productRepo.save(product);
    // => Saves to database AND updates cache with new value
  }

  @CacheEvict(value = "products", key = "#id") // Remove from cache
  public void deleteById(Long id) {
    productRepo.deleteById(id);
    // => Deletes from database AND evicts from cache
  }

  @CacheEvict(value = "products", allEntries = true) // Clear entire cache
  public void clearCache() {
    System.out.println("Cache cleared");
  }

  @Caching(evict = {
    @CacheEvict(value = "products", key = "#product.id"),
    @CacheEvict(value = "categories", key = "#product.categoryId")
  })
  public Product update(Product product) {
    return productRepo.save(product);
    // => Evicts multiple cache entries
  }
}

// Usage
Product p1 = productService.findById(1L); // => Database query
Product p2 = productService.findById(1L); // => Cached (no query)
productService.deleteById(1L); // => Evicts cache
Product p3 = productService.findById(1L); // => Database query again