Advanced

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
 
@RestController  // => @Controller + @ResponseBody combined
@RequestMapping("/api/donations")
// => Maps HTTP requests to this controller
public class DonationRestController {  // => Defines DonationRestController class
    @GetMapping("/{id}")
    // => Handles HTTP GET requests
    public ResponseEntity<String> getById(@PathVariable Long id) {  // => Method: getById(...)
        // => ResponseEntity controls HTTP status and headers
 
        if (id <= 0) {  // => Conditional check
            return ResponseEntity.badRequest().body("Invalid ID");  // => Returns result
            // => Returns HTTP 400 Bad Request
        }
 
        String donation = "Donation #" + id;  // => donation = "Donation #" + id
        return ResponseEntity.ok(donation);  // => Returns result
        // => Returns HTTP 200 OK with body
    }
 
    @PostMapping
    // => Handles HTTP POST requests
    public ResponseEntity<String> create(@RequestBody String donor) {  // => Method: create(...)
        String result = "Created for " + donor;  // => result = "Created for " + donor
 
        return ResponseEntity  // => Returns ResponseEntity
            .status(HttpStatus.CREATED)  // => HTTP 201 Created
            .header("Location", "/api/donations/123")  // => Custom header
            .body(result);  // => Sets response body and completes ResponseEntity
        // => Full control over response
    }
}

import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.*
 
@RestController  // => @Controller + @ResponseBody combined
@RequestMapping("/api/donations")
# => Maps HTTP requests to this controller
class DonationRestController {  # => Defines DonationRestController class
    @GetMapping("/{id}")
    # => Handles HTTP GET requests
    fun getById(@PathVariable id: Long): ResponseEntity<String> {
    # => Function getById executes
        // => ResponseEntity controls HTTP status and headers
 
        return if (id <= 0) {  # => Returns if (id <= 0) {
            ResponseEntity.badRequest().body("Invalid ID")  # => Calls badRequest(...)
            // => Returns HTTP 400 Bad Request
        } else {
            val donation = "Donation #$id"  # => donation = "Donation #$id"
            ResponseEntity.ok(donation)  # => Calls ok(...)
            // => Returns HTTP 200 OK with body
 
    @PostMapping
    # => Handles HTTP POST requests
    fun create(@RequestBody donor: String): ResponseEntity<String> {
    # => Function create executes
        val result = "Created for $donor"  # => result = "Created for $donor"
 
        return ResponseEntity  # => Returns ResponseEntity
            .status(HttpStatus.CREATED)  // => HTTP 201 Created
            .header("Location", "/api/donations/123")  // => Custom header
            .body(result)  # => Sets response body and completes ResponseEntity
        // => Full control over response
    }  # => End of create
}

import org.springframework.web.bind.annotation.*;
 
class Donation {  // => Defines Donation class
    private String donor;  // => donor: String field
    private double amount;  // => amount: double field
 
    public Donation(String donor, double amount) {  // => Code executes here
    // => Constructor for Donation with injected dependencies
        this.donor = donor;  // => Code executes here
        this.amount = amount;
    }  // => End of Donation
 
    public String getDonor() { return donor; }  // => Method: getDonor(...)
    public double getAmount() { return amount; }  // => Method: getAmount(...)
}
 
@RestController
@RequestMapping("/api/donations")
// => Maps HTTP requests to this controller
public class ContentNegotiationController {  // => Defines ContentNegotiationController class
    @GetMapping(produces = "application/json")
    // => Handles HTTP GET requests
    // => Produces JSON when Accept: application/json
    public Donation getAsJson() {  // => Method: getAsJson(...)
        return new Donation("Ali", 500.0);  // => Returns result
        // => Serialized to: {"donor":"Ali","amount":500.0}
    }
 
    @GetMapping(produces = "application/xml")
    // => Handles HTTP GET requests
    // => Produces XML when Accept: application/xml
    public Donation getAsXml() {  // => Method: getAsXml(...)
        return new Donation("Fatima", 300.0);  // => Returns result
        // => Serialized to: <Donation><donor>Fatima</donor>...</Donation>
        // => Requires JAXB annotations on Donation class
    }
}

import org.springframework.web.bind.annotation.*
 
data class Donation(val donor: String, val amount: Double)
 
@RestController
@RequestMapping("/api/donations")
# => Maps HTTP requests to this controller
class ContentNegotiationController {  # => Defines ContentNegotiationController class
    @GetMapping(produces = ["application/json"])
    # => Handles HTTP GET requests
    // => Produces JSON when Accept: application/json
    fun getAsJson(): Donation {
    # => Function getAsJson executes
        return Donation("Ali", 500.0)  # => Returns Donation("Ali", 500.0)
        // => Serialized to: {"donor":"Ali","amount":500.0}
    }
 
    @GetMapping(produces = ["application/xml"])
    # => Handles HTTP GET requests
    // => Produces XML when Accept: application/xml
    fun getAsXml(): Donation {
    # => Function getAsXml executes
        return Donation("Fatima", 300.0)  # => Returns result
        // => Serialized to: <Donation><donor>Fatima</donor>...</Donation>
        // => Requires JAXB annotations on Donation class
    }
}

import org.springframework.web.bind.annotation.*;
 
@RestController  // => Code executes here
@RequestMapping("/api")  // => Code executes here
// => Maps HTTP requests to this controller
@CrossOrigin(  // => Code executes here
// => Enables CORS for this endpoint
    origins = "http://localhost:3000",  // => Allowed origin
    methods = {RequestMethod.GET, RequestMethod.POST},  // => Allowed methods
    allowedHeaders = "*",  // => All headers allowed
    maxAge = 3600  // => Preflight cache duration (seconds)
)
public class CorsController {  // => Defines CorsController class
    @GetMapping("/data")
    // => Handles HTTP GET requests
    public String getData() {  // => Method: getData(...)
        return "CORS enabled data";  // => Returns "CORS enabled data"
        // => Accessible from http://localhost:3000
    }
}

import org.springframework.web.bind.annotation.*
 
@RestController  # => Code executes here
@RequestMapping("/api")  # => Code executes here
# => Maps HTTP requests to this controller
@CrossOrigin(
# => Enables CORS for this endpoint
    origins = ["http://localhost:3000"],  // => Allowed origin
    methods = [RequestMethod.GET, RequestMethod.POST],  // => Allowed methods
    allowedHeaders = ["*"],  // => All headers allowed
    maxAge = 3600  // => Preflight cache duration (seconds)
)
class CorsController {  # => Defines CorsController class
    @GetMapping("/data")
    # => Handles HTTP GET requests
    fun getData(): String {
    # => Function getData executes
        return "CORS enabled data"  # => Returns "CORS enabled data"
        // => Accessible from http://localhost:3000
    }  # => End of getData
}

import org.springframework.web.bind.annotation.*;
 
@RestController  // => Code executes here
@RequestMapping("/api/v1/donations")  // => Code executes here
// => Maps HTTP requests to this controller
// => URI versioning: version in path
public class DonationsV1Controller {  // => Defines DonationsV1Controller class
    @GetMapping  // => Code executes here
    // => Handles HTTP GET requests
    public String listV1() {  // => Method: listV1(...)
        return "Donations API v1";  // => Returns "Donations API v1"
        // => Simple string response
    }
}
 
@RestController
@RequestMapping("/api/v2/donations")
// => Maps HTTP requests to this controller
// => Version 2 with improved response
public class DonationsV2Controller {  // => Defines DonationsV2Controller class
    @GetMapping
    // => Handles HTTP GET requests
    public DonationResponse listV2() {  // => Method: listV2(...)
        return new DonationResponse("Enhanced v2 response");  // => Returns result
        // => Structured response object
    }
}
 
class DonationResponse {  // => Defines DonationResponse class
    private String message;  // => message: String field
    public DonationResponse(String message) { this.message = message; }
    // => Constructor for DonationResponse with injected dependencies
    public String getMessage() { return message; }  // => Method: getMessage(...)
}

import org.springframework.web.bind.annotation.*
 
@RestController
@RequestMapping("/api/v1/donations")
# => Maps HTTP requests to this controller
// => URI versioning: version in path
class DonationsV1Controller {  # => Defines DonationsV1Controller class
    @GetMapping
    # => Handles HTTP GET requests
    fun listV1(): String {
    # => Function listV1 executes
        return "Donations API v1"  # => Returns "Donations API v1"
        // => Simple string response
    }  # => End of listV1
}
 
@RestController
@RequestMapping("/api/v2/donations")
# => Maps HTTP requests to this controller
// => Version 2 with improved response
class DonationsV2Controller {  # => Defines DonationsV2Controller class
    @GetMapping
    # => Handles HTTP GET requests
    fun listV2(): DonationResponse {
    # => Function listV2 executes
        return DonationResponse("Enhanced v2 response")  # => Returns result
        // => Structured response object
    }  # => End of listV2
}
 
data class DonationResponse(val message: String)
# => Defines DonationResponse

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
 
class ErrorResponse {  // => Defines ErrorResponse class
    private String message;  // => message: String field
    private int status;  // => status: int field
 
    public ErrorResponse(String message, int status) {  // => Code executes here
    // => Constructor for ErrorResponse with injected dependencies
        this.message = message;  // => Code executes here
        this.status = status;  // => Code executes here
    }  // => End of ErrorResponse
 
    public String getMessage() { return message; }  // => Method: getMessage(...)
    public int getStatus() { return status; }  // => Method: getStatus(...)
}
 
@RestControllerAdvice  // => Global exception handler for all controllers
public class GlobalExceptionHandler {  // => Defines GlobalExceptionHandler class
    @ExceptionHandler(IllegalArgumentException.class)
    // => Handles specific exception type in this controller
    // => Handles IllegalArgumentException from any controller
    public ResponseEntity<ErrorResponse> handleIllegalArgument(  // => Method: handleIllegalArgument(...)
        IllegalArgumentException ex
    ) {
        ErrorResponse error = new ErrorResponse(ex.getMessage(), 400);
        // => error = new ErrorResponse(ex.getMessage(), 400)
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(error);  // => Returns result
        // => Returns 400 with error details
 
    @ExceptionHandler(Exception.class)
    // => Handles specific exception type in this controller
    // => Catch-all for unhandled exceptions
    public ResponseEntity<ErrorResponse> handleGeneral(Exception ex) {  // => Method: handleGeneral(...)
        ErrorResponse error = new ErrorResponse("Internal error", 500);
        // => Assigns error
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);  // => Returns result
        // => Returns 500 for unexpected errors
    }
}

import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.*
 
data class ErrorResponse(val message: String, val status: Int)
 
@RestControllerAdvice  // => Global exception handler for all controllers
class GlobalExceptionHandler {  # => Defines GlobalExceptionHandler class
    @ExceptionHandler(IllegalArgumentException::class)
    # => Handles specific exception type in this controller
    // => Handles IllegalArgumentException from any controller
    fun handleIllegalArgument(ex: IllegalArgumentException): ResponseEntity<ErrorResponse> {
    # => Function handleIllegalArgument executes
        val error = ErrorResponse(ex.message ?: "Bad request", 400)  # => assigns error
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(error)  # => Returns result
        // => Returns 400 with error details
    }
 
    @ExceptionHandler(Exception::class)
    # => Handles specific exception type in this controller
    // => Catch-all for unhandled exceptions
    fun handleGeneral(ex: Exception): ResponseEntity<ErrorResponse> {
    # => Function handleGeneral executes
        val error = ErrorResponse("Internal error", 500)  # => assigns error
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error)  # => Returns result
        // => Returns 500 for unexpected errors
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;
 
@Configuration  // => Code executes here
// => Marks class as Spring bean factory
public class SecurityConfig {  // => Defines SecurityConfig class
    @Bean
    // => Registers return value as Spring-managed bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {  // => Method: filterChain(...)
        http
            .authorizeHttpRequests(auth -> auth  // => Configures HTTP request authorization rules
                .requestMatchers("/public/**").permitAll()  // => Allows unrestricted access to /public/**
                // => Public endpoints (no auth required)
 
                .requestMatchers("/api/**").authenticated()  // => Requires authentication for /api/**
                // => API endpoints require authentication
 
                .anyRequest().denyAll()  // => Denies all unmatched requests by default
                // => Deny all other requests
            )
            .httpBasic();  // => HTTP Basic authentication
 
        return http.build();  // => Builds security filter chain
    }
}

import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.security.config.annotation.web.builders.HttpSecurity
import org.springframework.security.web.SecurityFilterChain
 
@Configuration  # => Code executes here
# => Marks class as Spring bean factory
class SecurityConfig {  # => Defines SecurityConfig class
    @Bean  # => Code executes here
    # => Registers return value as Spring-managed bean
    fun filterChain(http: HttpSecurity): SecurityFilterChain {
    # => Function filterChain executes
        http
            .authorizeHttpRequests { auth ->
                auth
                    .requestMatchers("/public/**").permitAll()  # => Allows unrestricted access to /public/**
                    // => Public endpoints (no auth required)
 
                    .requestMatchers("/api/**").authenticated()  # => Requires authentication for /api/**
                    // => API endpoints require authentication
 
                    .anyRequest().denyAll()  # => Denies all unmatched requests by default
                    // => Deny all other requests
            }  # => End of filterChain
            .httpBasic { }  // => HTTP Basic authentication
 
        return http.build()  // => Builds security filter chain
    }
}

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Service;
 
@Service
// => Specialized @Component for business logic layer
public class SecureService {  // => Defines SecureService class
    @PreAuthorize("hasRole('ADMIN')")
    // => Checks authorization before method execution
    // => Only users with ADMIN role can access
    // => Throws AccessDeniedException if unauthorized
    public void adminOperation() {  // => Method: adminOperation(...)
        System.out.println("Admin operation executed");  // => Outputs to console
    }
 
    @PreAuthorize("hasAnyRole('USER', 'ADMIN')")
    // => Checks authorization before method execution
    // => Users with USER OR ADMIN role allowed
    public void userOperation() {  // => Method: userOperation(...)
        System.out.println("User operation executed");  // => Outputs to console
    }
 
    @PreAuthorize("#username == authentication.name")
    // => SpEL expression: user can only access own data
    // => #username param must match authenticated user
    public void accessOwnData(String username) {  // => Method: accessOwnData(...)
        System.out.println("Accessing data for: " + username);  // => Outputs to console
    }
}

import org.springframework.security.access.prepost.PreAuthorize
import org.springframework.stereotype.Service
 
@Service
# => Specialized @Component for business logic layer
class SecureService {  # => Defines SecureService class
    @PreAuthorize("hasRole('ADMIN')")
    # => Checks authorization before method execution
    // => Only users with ADMIN role can access
    // => Throws AccessDeniedException if unauthorized
    fun adminOperation() {
    # => Function adminOperation executes
        println("Admin operation executed")  # => Outputs to console
    }
 
    @PreAuthorize("hasAnyRole('USER', 'ADMIN')")
    # => Checks authorization before method execution
    // => Users with USER OR ADMIN role allowed
    fun userOperation() {
    # => Function userOperation executes
        println("User operation executed")  # => Outputs to console
    }
 
    @PreAuthorize("#username == authentication.name")
    // => SpEL expression: user can only access own data
    // => #username param must match authenticated user
    fun accessOwnData(username: String) {
    # => Function accessOwnData executes
        println("Accessing data for: $username")  # => Outputs to console
    }
}

import org.springframework.security.core.userdetails.*;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Service;
import java.util.List;
 
@Service  // => Code executes here
// => Specialized @Component for business logic layer
public class CustomUserDetailsService implements UserDetailsService {  // => Defines CustomUserDetailsService class
    @Override
    // => Verifies this method overrides a superclass method
    public UserDetails loadUserByUsername(String username)  // => Method: loadUserByUsername(...)
        throws UsernameNotFoundException {
        // => Called during authentication
        // => Load user from database
 
        if ("admin".equals(username)) {  // => Conditional check
            return User.builder()  // => Returns User.builder()
                .username("admin")
                .password("{noop}password")  // => {noop} = no password encoding
                .authorities(List.of(
                    new SimpleGrantedAuthority("ROLE_ADMIN")  // => Creates new SimpleGrantedAuthority instance
                    // => Grants ADMIN role
                ))
                .build();  // => Constructs the object
            // => Returns UserDetails for Spring Security
 
        throw new UsernameNotFoundException("User not found: " + username);  // => Throws exception
        // => Authentication fails
    }
}

import org.springframework.security.core.userdetails.*
import org.springframework.security.core.authority.SimpleGrantedAuthority
import org.springframework.stereotype.Service
 
@Service  # => Code executes here
# => Specialized @Component for business logic layer
class CustomUserDetailsService : UserDetailsService {  # => Defines CustomUserDetailsService class
    override fun loadUserByUsername(username: String): UserDetails {
        // => Called during authentication
        // => Load user from database
 
        return if (username == "admin") {  # => Returns result
            User.builder()  # => Calls builder(...)
                .username("admin")
                .password("{noop}password")  // => {noop} = no password encoding
                .authorities(listOf(
                    SimpleGrantedAuthority("ROLE_ADMIN")  # => Calls SimpleGrantedAuthority(...)
                    // => Grants ADMIN role
                ))
                .build()  # => Constructs the object
            // => Returns UserDetails for Spring Security
        } else {
            throw UsernameNotFoundException("User not found: $username")  # => Throws exception
            // => Authentication fails
    }  # => End of loadUserByUsername
}

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.stereotype.Service;
import java.util.Date;
 
@Service  // => Code executes here
// => Specialized @Component for business logic layer
public class JwtService {  // => Defines JwtService class
    private static final String SECRET = "mySecretKey";  // => Field: final
    // => Secret key for signing tokens
    // => In production: use strong secret, store securely
 
    public String generateToken(String username) {  // => Method: generateToken(...)
        return Jwts.builder()  // => Returns Jwts.builder()
            .setSubject(username)  // => Token subject (username)
            .setIssuedAt(new Date())  // => Issue time
            .setExpiration(new Date(System.currentTimeMillis() + 86400000))  // => setExpiration(...) called
            // => Expiration: 24 hours from now
            .signWith(SignatureAlgorithm.HS256, SECRET)
            // => Sign with HMAC SHA-256
            .compact();
        // => Returns JWT string
    }
 
    public String extractUsername(String token) {  // => Method: extractUsername(...)
        return Jwts.parser()  // => Returns Jwts.parser()
            .setSigningKey(SECRET)  // => Verify signature
            .parseClaimsJws(token)  // => Parse and validate
            .getBody()
            .getSubject();  // => Extract username from subject claim
    }
}

import io.jsonwebtoken.Jwts
import io.jsonwebtoken.SignatureAlgorithm
import org.springframework.stereotype.Service
import java.util.Date
 
@Service  # => Code executes here
# => Specialized @Component for business logic layer
class JwtService {  # => Defines JwtService class
    companion object {  # => Code executes here
        private const val SECRET = "mySecretKey"
        // => Secret key for signing tokens
        // => In production: use strong secret, store securely
 
    fun generateToken(username: String): String {
    # => Function generateToken executes
        return Jwts.builder()  # => Returns Jwts.builder()
            .setSubject(username)  // => Token subject (username)
            .setIssuedAt(Date())  // => Issue time
            .setExpiration(Date(System.currentTimeMillis() + 86400000))
            // => Expiration: 24 hours from now
            .signWith(SignatureAlgorithm.HS256, SECRET)
            // => Sign with HMAC SHA-256
            .compact()
        // => Returns JWT string
    }  # => End of generateToken
 
    fun extractUsername(token: String): String {
    # => Function extractUsername executes
        return Jwts.parser()  # => Returns Jwts.parser()
            .setSigningKey(SECRET)  // => Verify signature
            .parseClaimsJws(token)  // => Parse and validate
            .body
            .subject  // => Extract username from subject claim
    }  # => End of extractUsername
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
 
@Configuration  // => Code executes here
// => Marks class as Spring bean factory
public class PasswordConfig {  // => Defines PasswordConfig class
    @Bean
    // => Registers return value as Spring-managed bean
    public PasswordEncoder passwordEncoder() {  // => Method: passwordEncoder(...)
        return new BCryptPasswordEncoder();  // => Returns result
        // => BCrypt hashing algorithm
        // => Slow by design (protects against brute force)
    }
}
 
@Service
// => Specialized @Component for business logic layer
class PasswordService {  // => Defines PasswordService class
    private final PasswordEncoder encoder;  // => encoder: PasswordEncoder field
 
    public PasswordService(PasswordEncoder encoder) {
        this.encoder = encoder;
    }  // => End of PasswordService
 
    public String encodePassword(String raw) {  // => Method: encodePassword(...)
        String encoded = encoder.encode(raw);  // => encoded = encoder.encode(raw)
        // => Hashes password with random salt
        // => Same input produces different hash each time
 
        System.out.println("Raw: " + raw);  // => Outputs to console
        System.out.println("Encoded: " + encoded);  // => Outputs to console
        return encoded;  // => Returns encoded
    }
 
    public boolean matches(String raw, String encoded) {  // => Method: matches(...)
        return encoder.matches(raw, encoded);  // => Returns result
        // => Verifies password against hash
        // => Returns true if match
    }
}

import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder
import org.springframework.security.crypto.password.PasswordEncoder
import org.springframework.stereotype.Service
 
@Configuration
# => Marks class as Spring bean factory
class PasswordConfig {  # => Defines PasswordConfig class
    @Bean
    # => Registers return value as Spring-managed bean
    fun passwordEncoder(): PasswordEncoder {
        return BCryptPasswordEncoder()  # => Returns BCryptPasswordEncoder()
        // => BCrypt hashing algorithm
        // => Slow by design (protects against brute force)
    }  # => End of passwordEncoder
}
 
@Service
# => Specialized @Component for business logic layer
class PasswordService(private val encoder: PasswordEncoder) {  # => Defines PasswordService class
    fun encodePassword(raw: String): String {
        val encoded = encoder.encode(raw)  # => encoded = encoder.encode(raw)
        // => Hashes password with random salt
        // => Same input produces different hash each time
 
        println("Raw: $raw")  # => Outputs to console
        println("Encoded: $encoded")  # => Outputs to console
        return encoded  # => Returns encoded
    }  # => End of encodePassword
 
    fun matches(raw: String, encoded: String): Boolean {
        return encoder.matches(raw, encoded)  # => Returns result
        // => Verifies password against hash
        // => Returns true if match
    }
}

import org.springframework.cache.annotation.*;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Service;
 
@Configuration
// => Marks class as Spring bean factory
@EnableCaching  // => Enables Spring caching support
public class CacheConfig {  // => Defines CacheConfig class
}
 
@Service
// => Specialized @Component for business logic layer
@CacheConfig(cacheNames = "donations")
// => Default cache name for this class
class DonationCacheService {  // => Defines DonationCacheService class
    @Cacheable  // => Result cached after first call
                // => Subsequent calls return cached value
    public String getDonation(Long id) {  // => Method: getDonation(...)
        System.out.println("Loading from database: " + id);  // => Outputs to console
        // => Only printed on cache miss
        return "Donation #" + id;  // => Returns "Donation #" + id
    }
 
    @CachePut(key = "#id")
    // => Always executes method, updates cache
    // => Updates cache with new value
    // => Method always executed
    public String updateDonation(Long id, String data) {  // => Method: updateDonation(...)
        System.out.println("Updating: " + id);  // => Outputs to console
        return data;  // => Cached
    }
 
    @CacheEvict(key = "#id")
    // => Removes from cache
    // => Next getDonation() will reload
    public void deleteDonation(Long id) {  // => Method: deleteDonation(...)
        System.out.println("Deleting: " + id);  // => Outputs to console
    }
}

import org.springframework.cache.annotation.*
import org.springframework.context.annotation.Configuration
import org.springframework.stereotype.Service
 
@Configuration
# => Marks class as Spring bean factory
@EnableCaching  // => Enables Spring caching support
class CacheConfig  # => Defines CacheConfig class
 
@Service
# => Specialized @Component for business logic layer
@CacheConfig(cacheNames = ["donations"])
// => Default cache name for this class
class DonationCacheService {  # => Defines DonationCacheService class
    @Cacheable  // => Result cached after first call
                // => Subsequent calls return cached value
    fun getDonation(id: Long): String {
    # => Function getDonation executes
        println("Loading from database: $id")  # => Outputs to console
        // => Only printed on cache miss
        return "Donation #$id"  # => Returns "Donation #$id"
    }
 
    @CachePut(key = "#id")
    // => Updates cache with new value
    // => Method always executed
    fun updateDonation(id: Long, data: String): String {
    # => Function updateDonation executes
        println("Updating: $id")  # => Outputs to console
        return data  // => Cached
    }
 
    @CacheEvict(key = "#id")
    // => Removes from cache
    // => Next getDonation() will reload
    fun deleteDonation(id: Long) {
    # => Function deleteDonation executes
        println("Deleting: $id")  # => Outputs to console
    }
}

import org.springframework.scheduling.annotation.*;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;
 
@Configuration
// => Marks class as Spring bean factory
@EnableAsync  // => Enables @Async support
public class AsyncConfig {  // => Defines AsyncConfig class
}
 
@Service
// => Specialized @Component for business logic layer
class NotificationService {  // => Defines NotificationService class
    @Async  // => Method runs in separate thread
            // => Caller doesn't wait for completion
    public void sendEmail(String to, String message) {  // => Method: sendEmail(...)
        System.out.println("Sending email to: " + to);  // => Outputs to console
        // => Runs asynchronously
        try {
        // => Exception-safe block - failures handled by catch clause
            Thread.sleep(2000);  // => Simulates slow operation
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();  // => Calls currentThread(...)
        System.out.println("Email sent to: " + to);  // => Outputs to console
 
    @Async
    // => Method executes asynchronously in thread pool
    public CompletableFuture<String> processAsync(String data) {  // => Method: processAsync(...)
        // => Returns CompletableFuture for async result
        try {
        // => Exception-safe block - failures handled by catch clause
            Thread.sleep(1000);  // => Calls sleep(...)
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();  // => Calls currentThread(...)
 
        return CompletableFuture.completedFuture("Processed: " + data);  // => Returns result
        // => Caller can wait for result if needed
}

import org.springframework.scheduling.annotation.*
import org.springframework.context.annotation.Configuration
import org.springframework.stereotype.Service
import java.util.concurrent.CompletableFuture
 
@Configuration
# => Marks class as Spring bean factory
@EnableAsync  // => Enables @Async support
class AsyncConfig  # => Defines AsyncConfig class
 
@Service
# => Specialized @Component for business logic layer
class NotificationService {  # => Defines NotificationService class
    @Async  // => Method runs in separate thread
            // => Caller doesn't wait for completion
    fun sendEmail(to: String, message: String) {
    # => Function sendEmail executes
        println("Sending email to: $to")  # => Outputs to console
        // => Runs asynchronously
        Thread.sleep(2000)  // => Simulates slow operation
        println("Email sent to: $to")  # => Outputs to console
    }
 
    @Async
    fun processAsync(data: String): CompletableFuture<String> {
    # => Function processAsync executes
        // => Returns CompletableFuture for async result
        Thread.sleep(1000)  # => Calls sleep(...)
 
        return CompletableFuture.completedFuture("Processed: $data")  # => Returns result
        // => Caller can wait for result if needed
    }
}

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
 
class DonationEvent extends ApplicationEvent {  // => Defines DonationEvent class
    // => Custom event class
    private final String donor;  // => donor: String field
    private final double amount;  // => amount: double field
 
    public DonationEvent(Object source, String donor, double amount) {  // => Code executes here
    // => Constructor for DonationEvent with injected dependencies
        super(source);  // => Event source
        this.donor = donor;  // => Code executes here
        this.amount = amount;  // => Code executes here
    }  // => End of DonationEvent
 
    public String getDonor() { return donor; }  // => Method: getDonor(...)
    public double getAmount() { return amount; }  // => Method: getAmount(...)
}
 
@Service  // => Code executes here
// => Specialized @Component for business logic layer
class DonationService {  // => Defines DonationService class
    private final ApplicationEventPublisher publisher;  // => publisher: ApplicationEventPublisher field
 
    public DonationService(ApplicationEventPublisher publisher) {
    // => Constructor for DonationService with injected dependencies
        this.publisher = publisher;  // => Injected event publisher
    }  // => End of DonationService
 
    public void createDonation(String donor, double amount) {  // => Method: createDonation(...)
        System.out.println("Creating donation");  // => Outputs to console
 
        publisher.publishEvent(new DonationEvent(this, donor, amount));  // => Calls publishEvent(...)
        // => Publishes event to all listeners
        // => Synchronous by default
    }
}
 
@Component
// => Component scanning will discover and register this class
class DonationEventListener {  // => Defines DonationEventListener class
    @EventListener  // => Listens for DonationEvent
    public void handleDonation(DonationEvent event) {  // => Method: handleDonation(...)
        // => Called when event published
        System.out.println("Event received: " + event.getDonor() +  // => Outputs to console
                           " donated $" + event.getAmount());
    }
}

import org.springframework.context.ApplicationEvent
import org.springframework.context.ApplicationEventPublisher
import org.springframework.context.event.EventListener
import org.springframework.stereotype.Component
import org.springframework.stereotype.Service
 
class DonationEvent(  # => Defines DonationEvent class
    source: Any,  # => Code executes here
    val donor: String,  # => Code executes here
    val amount: Double
) : ApplicationEvent(source)  // => Custom event class
 
@Service
# => Specialized @Component for business logic layer
class DonationService(  # => Defines DonationService class
    private val publisher: ApplicationEventPublisher
    // => Injected event publisher
) {
    fun createDonation(donor: String, amount: Double) {
    # => Function createDonation executes
        println("Creating donation")  # => Outputs to console
 
        publisher.publishEvent(DonationEvent(this, donor, amount))  # => Calls publishEvent(...)
        // => Publishes event to all listeners
        // => Synchronous by default
    }  # => End of createDonation
 
@Component
# => Component scanning will discover and register this class
class DonationEventListener {  # => Defines DonationEventListener class
    @EventListener  // => Listens for DonationEvent
    fun handleDonation(event: DonationEvent) {
    # => Function handleDonation executes
        // => Called when event published
        println("Event received: ${event.donor} donated $${event.amount}")  # => Outputs to console
    }  # => End of handleDonation
}

import org.springframework.scheduling.annotation.*;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
 
@Configuration
// => Marks class as Spring bean factory
@EnableScheduling  // => Enables @Scheduled support
public class SchedulingConfig {  // => Defines SchedulingConfig class
}
 
@Component
// => Component scanning will discover and register this class
class ScheduledTasks {  // => Defines ScheduledTasks class
    @Scheduled(fixedRate = 5000)
    // => Method executes on schedule (cron/fixed rate)
    // => Runs every 5 seconds
    // => Fixed delay between start of executions
    public void reportStatus() {  // => Method: reportStatus(...)
        System.out.println("Status check at: " + System.currentTimeMillis());  // => Outputs to console
    }
 
    @Scheduled(cron = "0 0 * * * *")
    // => Method executes on schedule (cron/fixed rate)
    // => Cron expression: every hour at minute 0
    // => Format: second minute hour day month weekday
    public void hourlyTask() {  // => Method: hourlyTask(...)
        System.out.println("Hourly task executed");  // => Outputs to console
    }
 
    @Scheduled(fixedDelay = 3000, initialDelay = 10000)
    // => Waits 10 seconds before first execution
    // => Then runs every 3 seconds after previous completion
    public void delayedTask() {  // => Method: delayedTask(...)
        System.out.println("Delayed task running");  // => Outputs to console
    }
}

import org.springframework.scheduling.annotation.*
import org.springframework.context.annotation.Configuration
import org.springframework.stereotype.Component
 
@Configuration
# => Marks class as Spring bean factory
@EnableScheduling  // => Enables @Scheduled support
class SchedulingConfig  # => Defines SchedulingConfig class
 
@Component
# => Component scanning will discover and register this class
class ScheduledTasks {  # => Defines ScheduledTasks class
    @Scheduled(fixedRate = 5000)
    # => Method executes on schedule (cron/fixed rate)
    // => Runs every 5 seconds
    // => Fixed delay between start of executions
    fun reportStatus() {
    # => Function reportStatus executes
        println("Status check at: ${System.currentTimeMillis()}")  # => Outputs to console
    }
 
    @Scheduled(cron = "0 0 * * * *")
    // => Cron expression: every hour at minute 0
    // => Format: second minute hour day month weekday
    fun hourlyTask() {
    # => Function hourlyTask executes
        println("Hourly task executed")  # => Outputs to console
    }
 
    @Scheduled(fixedDelay = 3000, initialDelay = 10000)
    // => Waits 10 seconds before first execution
    // => Then runs every 3 seconds after previous completion
    fun delayedTask() {
    # => Function delayedTask executes
        println("Delayed task running")  # => Outputs to console
    }
}

import org.springframework.boot.autoconfigure.condition.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration  // => Code executes here
// => Marks class as Spring bean factory
class ConditionalConfig {  // => Defines ConditionalConfig class
    @Bean  // => Code executes here
    // => Registers return value as Spring-managed bean
    @ConditionalOnProperty(  // => Code executes here
    // => Bean registered based on property value
        name = "feature.cache.enabled",  // => name = "feature.cache.enabled"
        // => name = "feature.cache.enabled"
        havingValue = "true"
    )
    // => Bean created only if property = true
    public CacheService cacheService() {  // => Method: cacheService(...)
        return new CacheService();  // => Returns new CacheService()
        // => Registered when cache enabled
    }
 
    @Bean
    // => Registers return value as Spring-managed bean
    @ConditionalOnMissingBean(CacheService.class)
    // => Bean registered when no other bean of that type exists
    // => Created only if CacheService bean doesn't exist
    public NoCacheService noCacheService() {  // => Method: noCacheService(...)
        return new NoCacheService();  // => Returns new NoCacheService()
        // => Fallback when cache disabled
    }
 
    @Bean
    // => Registers return value as Spring-managed bean
    @ConditionalOnClass(name = "com.mysql.jdbc.Driver")
    // => Bean registered when class is on classpath
    // => Created only if MySQL driver on classpath
    public DatabaseService mysqlService() {  // => Method: mysqlService(...)
        return new DatabaseService("MySQL");  // => Returns result
    }
}
 
class CacheService {  // => Defines CacheService class
    public CacheService() {
    // => No-arg constructor for CacheService
        System.out.println("CacheService created");  // => Outputs to console
    }  // => End of CacheService
}
 
class NoCacheService {  // => Defines NoCacheService class
    public NoCacheService() {
    // => No-arg constructor for NoCacheService
        System.out.println("NoCacheService created");  // => Outputs to console
    }  // => End of NoCacheService
}
 
class DatabaseService {  // => Defines DatabaseService class
    public DatabaseService(String type) {
    // => Constructor for DatabaseService with injected dependencies
        System.out.println("DatabaseService: " + type);  // => Outputs to console
    }  // => End of DatabaseService
}

import org.springframework.boot.autoconfigure.condition.*
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
 
@Configuration  # => Code executes here
# => Marks class as Spring bean factory
class ConditionalConfig {  # => Defines ConditionalConfig class
    @Bean  # => Code executes here
    # => Registers return value as Spring-managed bean
    @ConditionalOnProperty(  # => Code executes here
    # => Bean registered based on property value
        name = ["feature.cache.enabled"],  # => name = ["feature.cache.enabled"]
        # => name = ["feature.cache.enabled"]
        havingValue = "true"
    )
    // => Bean created only if property = true
    fun cacheService(): CacheService {
    # => Function cacheService executes
        return CacheService()  # => Returns CacheService()
        // => Registered when cache enabled
    }  # => End of cacheService
 
    @Bean
    # => Registers return value as Spring-managed bean
    @ConditionalOnMissingBean(CacheService::class)
    # => Bean registered when no other bean of that type exists
    // => Created only if CacheService bean doesn't exist
    fun noCacheService(): NoCacheService {
    # => Function noCacheService executes
        return NoCacheService()  # => Returns NoCacheService()
        // => Fallback when cache disabled
    }  # => End of noCacheService
 
    @Bean
    # => Registers return value as Spring-managed bean
    @ConditionalOnClass(name = ["com.mysql.jdbc.Driver"])
    # => Bean registered when class is on classpath
    // => Created only if MySQL driver on classpath
    fun mysqlService(): DatabaseService {
    # => Function mysqlService executes
        return DatabaseService("MySQL")  # => Returns DatabaseService("MySQL")
    }  # => End of mysqlService
}
 
class CacheService {  # => Defines CacheService class
    init {
        println("CacheService created")  # => Outputs to console
}
 
class NoCacheService {  # => Defines NoCacheService class
    init {
        println("NoCacheService created")  # => Outputs to console
}
 
class DatabaseService(type: String) {  # => Defines DatabaseService class
    init {
        println("DatabaseService: $type")  # => Outputs to console
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.stereotype.Service;
import static org.junit.jupiter.api.Assertions.*;
 
@Service  // => Code executes here
// => Specialized @Component for business logic layer
class CalculatorService {  // => Defines CalculatorService class
    public int add(int a, int b) {  // => Method: add(...)
        return a + b;  // => Returns a + b
    }
}
 
@SpringBootTest  // => Loads full Spring application context
                 // => All beans available for testing
class CalculatorServiceTest {  // => Defines CalculatorServiceTest class
    @Autowired  // => Injects actual bean from context
    private CalculatorService calculator;  // => calculator: CalculatorService field
 
    @Test
    // => JUnit test method - executed by test runner
    void testAddition() {
        // => Test with real Spring-managed bean
        int result = calculator.add(5, 3);  // => result = calculator.add(5, 3)
 
        assertEquals(8, result);  // => Calls assertEquals(...)
        // => Assertion: expected 8
}

import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.stereotype.Service
import kotlin.test.assertEquals
 
@Service
# => Specialized @Component for business logic layer
class CalculatorService {  # => Defines CalculatorService class
    fun add(a: Int, b: Int): Int = a + b
    # => Function add executes
}
 
@SpringBootTest  // => Loads full Spring application context
                 // => All beans available for testing
class CalculatorServiceTest {  # => Defines CalculatorServiceTest class
    @Autowired  // => Injects actual bean from context
    private lateinit var calculator: CalculatorService
 
    @Test
    # => JUnit test method - executed by test runner
    fun testAddition() {
    # => Function testAddition executes
        // => Test with real Spring-managed bean
        val result = calculator.add(5, 3)  # => result = calculator.add(5, 3)
 
        assertEquals(8, result)  # => Calls assertEquals(...)
        // => Assertion: expected 8
    }  # => End of testAddition
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.web.bind.annotation.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
 
@RestController
class GreetingController {  // => Defines GreetingController class
    @GetMapping("/greet")
    // => Handles HTTP GET requests
    public String greet(@RequestParam String name) {  // => Method: greet(...)
        return "Hello, " + name;  // => Returns "Hello, " + name
    }
}
 
@WebMvcTest(GreetingController.class)
// => Loads only web layer beans for MVC testing
// => Loads only web layer (controllers)
// => Faster than @SpringBootTest
class GreetingControllerTest {  // => Defines GreetingControllerTest class
    @Autowired
    // => Spring injects the required dependency automatically
    private MockMvc mockMvc;  // => Mock HTTP client
 
    @Test
    // => JUnit test method - executed by test runner
    void testGreeting() throws Exception {
        mockMvc.perform(get("/greet").param("name", "Ali"))  // => Calls perform(...)
            // => Performs GET /greet?name=Ali
            .andExpect(status().isOk())  // => Asserts expected response condition
            // => Expects HTTP 200
            .andExpect(content().string("Hello, Ali"));  // => Asserts expected response condition
            // => Expects response body
}

import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
import org.springframework.test.web.servlet.MockMvc
import org.springframework.web.bind.annotation.*
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.*
 
@RestController
class GreetingController {  # => Defines GreetingController class
    @GetMapping("/greet")
    # => Handles HTTP GET requests
    fun greet(@RequestParam name: String): String {
    # => Function greet executes
        return "Hello, $name"  # => Returns "Hello, $name"
    }  # => End of greet
}
 
@WebMvcTest(GreetingController::class)
# => Loads only web layer beans for MVC testing
// => Loads only web layer (controllers)
// => Faster than @SpringBootTest
class GreetingControllerTest {  # => Defines GreetingControllerTest class
    @Autowired
    # => Spring injects the required dependency automatically
    private lateinit var mockMvc: MockMvc  // => Mock HTTP client
 
    @Test
    # => JUnit test method - executed by test runner
    fun testGreeting() {
    # => Function testGreeting executes
        mockMvc.perform(get("/greet").param("name", "Ali"))  # => Calls perform(...)
            // => Performs GET /greet?name=Ali
            .andExpect(status().isOk)  # => Asserts expected response condition
            // => Expects HTTP 200
            .andExpect(content().string("Hello, Ali"))
            // => Expects response body
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;
import static org.junit.jupiter.api.Assertions.*;
 
@SpringBootTest  // => Code executes here
// => Loads full application context for integration testing
@Transactional  // => Each test runs in transaction
                // => Automatically rolled back after test
class DatabaseTest {  // => Defines DatabaseTest class
    @Autowired  // => Code executes here
    // => Spring injects the required dependency automatically
    private JdbcTemplate jdbc;  // => jdbc: JdbcTemplate field
 
    @Test
    // => JUnit test method - executed by test runner
    void testInsert() {
        jdbc.update("INSERT INTO donations (donor, amount) VALUES (?, ?)",  // => Calls update(...)
                    "TestUser", 100.0);
        // => Inserts data
 
        Integer count = jdbc.queryForObject(  // => count assigned from jdbc.queryForObject(...)
            "SELECT COUNT(*) FROM donations WHERE donor = ?",
            Integer.class,
            "TestUser"
        );
 
        assertEquals(1, count);  // => Calls assertEquals(...)
        // => Assertion passes
 
        // => Transaction rolled back after test
        // => Database unchanged
}

import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.transaction.annotation.Transactional
import kotlin.test.assertEquals
 
@SpringBootTest  # => Code executes here
# => Loads full application context for integration testing
@Transactional  // => Each test runs in transaction
                // => Automatically rolled back after test
class DatabaseTest {  # => Defines DatabaseTest class
    @Autowired  # => Code executes here
    # => Spring injects the required dependency automatically
    private lateinit var jdbc: JdbcTemplate
 
    @Test
    # => JUnit test method - executed by test runner
    fun testInsert() {
    # => Function testInsert executes
        jdbc.update("INSERT INTO donations (donor, amount) VALUES (?, ?)",  # => Calls update(...)
                    "TestUser", 100.0)
        // => Inserts data
 
        val count = jdbc.queryForObject(  # => count = jdbc.queryForObject(
            "SELECT COUNT(*) FROM donations WHERE donor = ?",
            Int::class.java,
            "TestUser"
        )
 
        assertEquals(1, count)  # => Calls assertEquals(...)
        // => Assertion passes
 
        // => Transaction rolled back after test
        // => Database unchanged
    }  # => End of testInsert
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import static org.junit.jupiter.api.Assertions.*;
 
// application-test.properties:
// test.value=test-data
 
@SpringBootTest
@ActiveProfiles("test")  // => Activates "test" profile
                         // => Loads application-test.properties
class ProfileTest {  // => Defines ProfileTest class
    @Value("${test.value}")
    // => Injects value from property source or SpEL expression
    private String testValue;  // => Reads from test profile
 
    @Test
    // => JUnit test method - executed by test runner
    void testProfileValue() {
        assertEquals("test-data", testValue);  // => Calls assertEquals(...)
        // => Uses test-specific configuration
    }
}

import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Value
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.test.context.ActiveProfiles
import kotlin.test.assertEquals
 
// application-test.properties:
// test.value=test-data
 
@SpringBootTest
@ActiveProfiles("test")  // => Activates "test" profile
                         // => Loads application-test.properties
class ProfileTest {  # => Defines ProfileTest class
    @Value("\${test.value}")
    # => Injects value from property source or SpEL expression
    private lateinit var testValue: String  // => Reads from test profile
 
    @Test
    # => JUnit test method - executed by test runner
    fun testProfileValue() {
        assertEquals("test-data", testValue)  # => Calls assertEquals(...)
        // => Uses test-specific configuration
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.stereotype.Service;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;
 
@Service  // => Code executes here
// => Specialized @Component for business logic layer
class DataService {  // => Defines DataService class
    public String fetchData() {  // => Method: fetchData(...)
        return "real data";  // => Returns "real data"
    }
}
 
@Service  // => Code executes here
// => Specialized @Component for business logic layer
class BusinessService {  // => Defines BusinessService class
    private final DataService dataService;  // => dataService: DataService field
 
    public BusinessService(DataService dataService) {  // => Code executes here
    // => Constructor for BusinessService with injected dependencies
        this.dataService = dataService;  // => Code executes here
    }  // => End of BusinessService
 
    public String process() {  // => Method: process(...)
        return "Processed: " + dataService.fetchData();  // => Returns result
    }
}
 
@SpringBootTest  // => Code executes here
// => Loads full application context for integration testing
class MockBeanTest {  // => Defines MockBeanTest class
    @MockBean  // => Replaces real bean with mock
    private DataService dataService;  // => dataService: DataService field
 
    @Autowired  // => Injects BusinessService with mocked dependency
    private BusinessService businessService;  // => businessService: BusinessService field
 
    @Test
    // => JUnit test method - executed by test runner
    void testWithMock() {
        when(dataService.fetchData()).thenReturn("mock data");  // => Calls when(...)
        // => Configures mock behavior
 
        String result = businessService.process();  // => result = businessService.process()
 
        assertEquals("Processed: mock data", result);  // => Calls assertEquals(...)
        // => Uses mock instead of real service
}

import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.mock.mockito.MockBean
import org.springframework.stereotype.Service
import org.mockito.Mockito.*
import kotlin.test.assertEquals
 
@Service  # => Code executes here
# => Specialized @Component for business logic layer
class DataService {  # => Defines DataService class
    fun fetchData(): String = "real data"  # => Code executes here
    # => Function fetchData executes
}
 
@Service  # => Code executes here
# => Specialized @Component for business logic layer
class BusinessService(private val dataService: DataService) {  # => Defines BusinessService class
    fun process(): String = "Processed: ${dataService.fetchData()}"
    # => Function process executes
}
 
@SpringBootTest
# => Loads full application context for integration testing
class MockBeanTest {  # => Defines MockBeanTest class
    @MockBean  // => Replaces real bean with mock
    private lateinit var dataService: DataService
 
    @Autowired  // => Injects BusinessService with mocked dependency
    private lateinit var businessService: BusinessService
 
    @Test
    # => JUnit test method - executed by test runner
    fun testWithMock() {
    # => Function testWithMock executes
        `when`(dataService.fetchData()).thenReturn("mock data")  # => Specifies mock return value
        // => Configures mock behavior
 
        val result = businessService.process()  # => result = businessService.process()
 
        assertEquals("Processed: mock data", result)  # => Calls assertEquals(...)
        // => Uses mock instead of real service
    }  # => End of testWithMock
}

import org.springframework.boot.actuate.health.*;
import org.springframework.stereotype.Component;
 
@Component  // => Code executes here
// => Component scanning will discover and register this class
class CustomHealthIndicator implements HealthIndicator {  // => Defines CustomHealthIndicator class
    @Override  // => Code executes here
    // => Verifies this method overrides a superclass method
    public Health health() {  // => Method: health(...)
        // => Called by /actuator/health endpoint
        // => Returns application health status
 
        boolean healthy = checkSystemHealth();  // => healthy = checkSystemHealth()
 
        if (healthy) {  // => Conditional check
            return Health.up()  // => Returns Health.up()
                .withDetail("message", "System healthy")  // => withDetail(...) called
                .withDetail("uptime", getUptime())  // => withDetail(...) called
                .build();  // => Constructs the object
            // => Status: UP
        } else {
            return Health.down()  // => Returns Health.down()
                .withDetail("error", "System degraded")
                .build();  // => Constructs the object
            // => Status: DOWN
    }
 
    private boolean checkSystemHealth() {  // => Method: checkSystemHealth(...)
        return true;  // => Actual health check logic
    }
 
    private long getUptime() {  // => Method: getUptime(...)
        return System.currentTimeMillis();  // => Returns result
    }
}

import org.springframework.boot.actuate.health.*
import org.springframework.stereotype.Component
 
@Component  # => Code executes here
# => Component scanning will discover and register this class
class CustomHealthIndicator : HealthIndicator {  # => Defines CustomHealthIndicator class
    override fun health(): Health {
        // => Called by /actuator/health endpoint
        // => Returns application health status
 
        val healthy = checkSystemHealth()  # => healthy = checkSystemHealth()
 
        return if (healthy) {  # => Returns if (healthy) {
            Health.up()  # => Calls up(...)
                .withDetail("message", "System healthy")
                .withDetail("uptime", getUptime())
                .build()  # => Constructs the object
            // => Status: UP
        } else {
            Health.down()  # => Calls down(...)
                .withDetail("error", "System degraded")
                .build()  # => Constructs the object
            // => Status: DOWN
 
    private fun checkSystemHealth(): Boolean = true  // => Actual health check logic
 
    private fun getUptime(): Long = System.currentTimeMillis()  # => Method: getUptime(...)
}  # => End of health

import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.stereotype.Service;
 
@Service
// => Specialized @Component for business logic layer
class DonationMetricsService {  // => Defines DonationMetricsService class
    private final Counter donationCounter;  // => donationCounter: Counter field
 
    public DonationMetricsService(MeterRegistry registry) {
        // => MeterRegistry auto-configured by Spring Boot
 
        this.donationCounter = Counter.builder("donations.total")
            // => Metric name
            .tag("type", "charity")
            // => Tag for filtering/grouping
            .description("Total donations received")
            // => Metric description
            .register(registry);
        // => Registers metric
    }  // => End of DonationMetricsService
 
    public void recordDonation(double amount) {  // => Method: recordDonation(...)
        donationCounter.increment();  // => Calls increment(...)
        // => Increments counter
        // => Exposed at /actuator/metrics/donations.total
 
        System.out.println("Donation recorded: $" + amount);  // => Outputs to console
    }
}

import io.micrometer.core.instrument.Counter
import io.micrometer.core.instrument.MeterRegistry
import org.springframework.stereotype.Service
 
@Service
# => Specialized @Component for business logic layer
class DonationMetricsService(registry: MeterRegistry) {  # => Defines DonationMetricsService class
    // => MeterRegistry auto-configured by Spring Boot
 
    private val donationCounter: Counter = Counter.builder("donations.total")
        // => Metric name
        .tag("type", "charity")
        // => Tag for filtering/grouping
        .description("Total donations received")
        // => Metric description
        .register(registry)
    // => Registers metric
 
    fun recordDonation(amount: Double) {
        donationCounter.increment()  # => Calls increment(...)
        // => Increments counter
        // => Exposed at /actuator/metrics/donations.total
 
        println("Donation recorded: $$amount")  # => Outputs to console
    }
}

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.config.annotation.*;
import org.springframework.context.annotation.Configuration;
import javax.servlet.http.*;
 
@Component  // => Code executes here
// => Component scanning will discover and register this class
class LoggingInterceptor implements HandlerInterceptor {  // => Defines LoggingInterceptor class
    @Override  // => Code executes here
    // => Verifies this method overrides a superclass method
    public boolean preHandle(  // => Method: preHandle(...)
        HttpServletRequest request,  // => Code executes here
        HttpServletResponse response,  // => Code executes here
        Object handler  // => Code executes here
    ) {  // => Code executes here
        // => Called BEFORE controller method
        System.out.println("Request: " + request.getMethod() + " " +  // => Outputs to console
                          request.getRequestURI());  // => Calls getRequestURI(...)
        return true;  // => Continue to controller (false = abort)
 
    @Override  // => Code executes here
    // => Verifies this method overrides a superclass method
    public void afterCompletion(  // => Method: afterCompletion(...)
        HttpServletRequest request,  // => Code executes here
        HttpServletResponse response,  // => Code executes here
        Object handler,  // => Code executes here
        Exception ex  // => Code executes here
    ) {
        // => Called AFTER response sent
        System.out.println("Response status: " + response.getStatus());  // => Outputs to console
}
 
@Configuration
// => Marks class as Spring bean factory
class WebConfig implements WebMvcConfigurer {  // => Defines WebConfig class
    private final LoggingInterceptor loggingInterceptor;  // => loggingInterceptor: LoggingInterceptor field
 
    public WebConfig(LoggingInterceptor loggingInterceptor) {
    // => Constructor for WebConfig with injected dependencies
        this.loggingInterceptor = loggingInterceptor;
    }  // => End of WebConfig
 
    @Override
    // => Verifies this method overrides a superclass method
    public void addInterceptors(InterceptorRegistry registry) {  // => Method: addInterceptors(...)
        registry.addInterceptor(loggingInterceptor)  // => Calls addInterceptor(...)
            .addPathPatterns("/api/**");
        // => Apply to /api/** paths only
    }
}

import org.springframework.stereotype.Component
import org.springframework.web.servlet.HandlerInterceptor
import org.springframework.web.servlet.config.annotation.*
import org.springframework.context.annotation.Configuration
import javax.servlet.http.*
 
@Component  # => Code executes here
# => Component scanning will discover and register this class
class LoggingInterceptor : HandlerInterceptor {  # => Defines LoggingInterceptor class
    override fun preHandle(  # => Code executes here
        request: HttpServletRequest,  # => Code executes here
        response: HttpServletResponse,  # => Code executes here
        handler: Any  # => Code executes here
    ): Boolean {  # => Code executes here
        // => Called BEFORE controller method
        println("Request: ${request.method} ${request.requestURI}")  # => Outputs to console
        return true  // => Continue to controller (false = abort)
 
    override fun afterCompletion(  # => Code executes here
        request: HttpServletRequest,  # => Code executes here
        response: HttpServletResponse,  # => Code executes here
        handler: Any,  # => Code executes here
        ex: Exception?  # => Code executes here
    ) {  # => Code executes here
        // => Called AFTER response sent
        println("Response status: ${response.status}")  # => Outputs to console
}
 
@Configuration  # => Code executes here
# => Marks class as Spring bean factory
class WebConfig(  # => Defines WebConfig class
    private val loggingInterceptor: LoggingInterceptor
) : WebMvcConfigurer {
    override fun addInterceptors(registry: InterceptorRegistry) {
        registry.addInterceptor(loggingInterceptor)  # => Calls addInterceptor(...)
            .addPathPatterns("/api/**")
        // => Apply to /api/** paths only
    }  # => End of addInterceptors

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
 
@Configuration
class DataSourceConfig {  // => Defines DataSourceConfig class
    @Bean
    public DataSource dataSource() {  // => Method: dataSource(...)
        HikariConfig config = new HikariConfig();
 
        config.setJdbcUrl("jdbc:h2:mem:testdb");  // => Calls setJdbcUrl(...)
        // => Database URL
 
        config.setUsername("sa");  // => Calls setUsername(...)
        config.setPassword("");  // => Calls setPassword(...)
 
        config.setMaximumPoolSize(10);  // => Calls setMaximumPoolSize(...)
        // => Maximum 10 connections in pool
 
        config.setMinimumIdle(2);  // => Calls setMinimumIdle(...)
        // => Keep at least 2 idle connections
 
        config.setConnectionTimeout(30000);  // => Calls setConnectionTimeout(...)
        // => Wait max 30 seconds for connection
 
        config.setIdleTimeout(600000);  // => Calls setIdleTimeout(...)
        // => Close idle connections after 10 minutes
 
        config.setMaxLifetime(1800000);  // => Calls setMaxLifetime(...)
        // => Recycle connections after 30 minutes
 
        return new HikariDataSource(config);  // => Returns result
        // => Returns pooled DataSource
        // => Spring uses this for all database operations
    }
}

import com.zaxxer.hikari.HikariConfig
import com.zaxxer.hikari.HikariDataSource
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import javax.sql.DataSource
 
@Configuration  # => Code executes here
# => Marks class as Spring bean factory
class DataSourceConfig {  # => Defines DataSourceConfig class
    @Bean
    # => Registers return value as Spring-managed bean
    fun dataSource(): DataSource {
    # => Function dataSource executes
        val config = HikariConfig().apply {  # => config = HikariConfig().apply {
            jdbcUrl = "jdbc:h2:mem:testdb"
            // => Database URL
 
            username = "sa"
            password = ""
 
            maximumPoolSize = 10
            // => Maximum 10 connections in pool
 
            minimumIdle = 2
            // => Keep at least 2 idle connections
 
            connectionTimeout = 30000
            // => Wait max 30 seconds for connection
 
            idleTimeout = 600000
            // => Close idle connections after 10 minutes
 
            maxLifetime = 1800000
            // => Recycle connections after 30 minutes
 
        return HikariDataSource(config)  # => Returns HikariDataSource(config)
        // => Returns pooled DataSource
        // => Spring uses this for all database operations
    }  # => End of dataSource
}

import javax.validation.*;
import javax.validation.constraints.*;
import java.lang.annotation.*;
 
@Target({ElementType.FIELD, ElementType.PARAMETER})  // => Code executes here
@Retention(RetentionPolicy.RUNTIME)  // => Code executes here
@Constraint(validatedBy = ZakatAmountValidator.class)  // => Code executes here
// => Links annotation to validator implementation
@interface ValidZakatAmount {  // => Code executes here
    String message() default "Invalid zakat amount";  // => Code executes here
    Class<?>[] groups() default {};  // => Code executes here
    Class<? extends Payload>[] payload() default {};
 
class ZakatAmountValidator implements ConstraintValidator<ValidZakatAmount, Double> {
// => Defines ZakatAmountValidator
    // => Defines ZakatAmountValidator class
    @Override
    // => Verifies this method overrides a superclass method
    public boolean isValid(Double value, ConstraintValidatorContext context) {  // => Method: isValid(...)
        // => Validation logic
        if (value == null) {  // => Conditional check
            return true;  // => Let @NotNull handle null check
        }  // => End of ZakatAmountValidator
 
        return value >= 0 && value <= 100000;  // => Returns result
        // => Amount must be 0-100000
    }
}
 
class DonationForm {  // => Defines DonationForm class
    @ValidZakatAmount(message = "Zakat amount must be 0-100000")
    // => Uses custom validator
    private Double amount;  // => amount: Double field
 
    public Double getAmount() { return amount; }  // => Method: getAmount(...)
    public void setAmount(Double amount) { this.amount = amount; }  // => Method: setAmount(...)
}

import javax.validation.*
import javax.validation.constraints.*
 
@Target(AnnotationTarget.FIELD, AnnotationTarget.VALUE_PARAMETER)  # => Code executes here
@Retention(AnnotationRetention.RUNTIME)  # => Code executes here
@Constraint(validatedBy = [ZakatAmountValidator::class])  # => Code executes here
// => Links annotation to validator implementation
annotation class ValidZakatAmount(  # => Code executes here
    val message: String = "Invalid zakat amount",  # => message = "Invalid zakat amount",
    val groups: Array<KClass<*>> = [],  # => groups = [],
    val payload: Array<KClass<out Payload>> = []  # => Code executes here
)  # => Code executes here
 
class ZakatAmountValidator : ConstraintValidator<ValidZakatAmount, Double> {  # => Defines ZakatAmountValidator class
    override fun isValid(value: Double?, context: ConstraintValidatorContext): Boolean {  # => Code executes here
        // => Validation logic
        if (value == null) {  # => Conditional check
            return true  // => Let @NotNull handle null check
        }  # => End of isValid
 
        return value in 0.0..100000.0  # => Returns value in 0.0..100000.0
        // => Amount must be 0-100000
    }
}
 
data class DonationForm(  # => Code executes here
# => Defines DonationForm
    @field:ValidZakatAmount(message = "Zakat amount must be 0-100000")
    // => Uses custom validator
    val amount: Double?
)