Intermediate

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
 
@Repository  // => Code executes here
// => Specialized @Component for data access layer
class DonationRepository {  // => Defines DonationRepository class
    public void save(String donation) {  // => Method: save(...)
        System.out.println("Saved: " + donation);  // => Outputs to console
    }
}
 
@Component  // => Code executes here
// => Component scanning will discover and register this class
class EmailNotifier {  // => Defines EmailNotifier class
    public void send(String message) {  // => Method: send(...)
        System.out.println("Email: " + message);  // => Outputs to console
    }
}
 
@Component  // => Code executes here
// => Component scanning will discover and register this class
class AuditLogger {  // => Defines AuditLogger class
    public void log(String action) {  // => Method: log(...)
        System.out.println("Audit: " + action);  // => Outputs to console
    }
}
 
@Service  // => Code executes here
// => Specialized @Component for business logic layer
class DonationService {  // => Defines DonationService class
    private final DonationRepository repository;  // => repository: DonationRepository field
    private final EmailNotifier notifier;  // => notifier: EmailNotifier field
    private final AuditLogger logger;  // => logger: AuditLogger field
 
    // => Constructor with three dependencies
    // => Spring injects all three automatically
    public DonationService(  // => Code executes here
        DonationRepository repository,  // => Injected first
        EmailNotifier notifier,          // => Injected second
        AuditLogger logger               // => Injected third
    ) {
        this.repository = repository;
        this.notifier = notifier;
        this.logger = logger;
        // => All dependencies immutable (final)
 
    public void processDonation(String donor, double amount) {  // => Method: processDonation(...)
        String donation = donor + ": $" + amount;  // => donation = donor + ": $" + amount
        repository.save(donation);         // => Uses repository
        notifier.send("Thank you");        // => Uses notifier
        logger.log("Donation processed"); // => Uses logger
    }
}
 
@Configuration
// => Marks class as Spring bean factory
@ComponentScan
// => Scans packages for @Component and stereotype annotations
class AppConfig {  // => Defines AppConfig class
}
 
public class Example26 {  // => Defines Example26 class
    public static void main(String[] args) {
        // => Application entry point - Spring context created here
    // => Method main receives args
        AnnotationConfigApplicationContext context =
            // => Spring IoC container initialized
            new AnnotationConfigApplicationContext(AppConfig.class);  // => Processes @Configuration, discovers beans
                // => Creates Spring IoC container, processes @Configuration
 
        DonationService service = context.getBean(DonationService.class);  // => Retrieves DonationService bean from container
        // => service = context.getBean(DonationService.class)
            // => Retrieves DonationService bean from container
        service.processDonation("Yusuf", 1000.0);  // => Calls processDonation(...)
        // => Output: Saved: Yusuf: $1000.0
        // => Output: Email: Thank you
        // => Output: Audit: Donation processed
 
        context.close();  // => Shuts down Spring container, releases resources
    }  // => End of static
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
import org.springframework.stereotype.Component
import org.springframework.stereotype.Repository
import org.springframework.stereotype.Service
 
@Repository
# => Specialized @Component for data access layer
class DonationRepository {  # => Defines DonationRepository class
    fun save(donation: String) {
    # => Function save executes
        println("Saved: $donation")  # => Outputs to console
    }  # => End of save
}
 
@Component
# => Component scanning will discover and register this class
class EmailNotifier {  # => Defines EmailNotifier class
    fun send(message: String) {
    # => Function send executes
        println("Email: $message")  # => Outputs to console
    }  # => End of send
}
 
@Component
# => Component scanning will discover and register this class
class AuditLogger {  # => Defines AuditLogger class
    fun log(action: String) {
    # => Function log executes
        println("Audit: $action")  # => Outputs to console
    }  # => End of log
}
 
@Service
# => Specialized @Component for business logic layer
// => Kotlin primary constructor with three dependencies
// => Spring injects all three automatically
class DonationService(  # => Defines DonationService class
    private val repository: DonationRepository,  // => Injected, immutable
    private val notifier: EmailNotifier,          // => Injected, immutable
    private val logger: AuditLogger               // => Injected, immutable
) {
    fun processDonation(donor: String, amount: Double) {
    # => Function processDonation executes
        val donation = "$donor: $$amount"  # => donation = "$donor: $$amount"
        repository.save(donation)         // => Uses repository
        notifier.send("Thank you")        // => Uses notifier
        logger.log("Donation processed") // => Uses logger
    }  # => End of processDonation
 
@Configuration
# => Marks class as Spring bean factory
@ComponentScan
# => Scans packages for @Component and stereotype annotations
class AppConfig  # => Defines AppConfig class
 
fun main() {
# => Function main executes
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
 
    val service = context.getBean(DonationService::class.java)  # => assigns service
    service.processDonation("Yusuf", 1000.0)  # => Calls processDonation(...)
    // => Output: Saved: Yusuf: $1000.0
    // => Output: Email: Thank you
    // => Output: Audit: Donation processed
 
    context.close()  # => Shuts down Spring container, releases resources
}  # => End of main

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
 
@Component
// => Component scanning will discover and register this class
class PushNotifier {  // => Defines PushNotifier class
    public void send(String message) {  // => Method: send(...)
        System.out.println("Push: " + message);  // => Outputs to console
    }
}
 
@Component
// => Component scanning will discover and register this class
class NotificationService {  // => Defines NotificationService class
    private PushNotifier pushNotifier;  // => Optional dependency
 
    @Autowired(required = false)
    // => Spring won't fail if PushNotifier bean missing
    // => Setter NOT called if bean absent
    public void setPushNotifier(PushNotifier pushNotifier) {  // => Method: setPushNotifier(...)
        this.pushNotifier = pushNotifier;  // => May remain null
        System.out.println("PushNotifier injected");  // => Outputs to console
    }
 
    public void sendNotification(String message) {  // => Method: sendNotification(...)
        if (pushNotifier != null) {  // => Conditional check
            // => Check before using optional dependency
            pushNotifier.send(message);  // => Calls send(...)
        } else {
            System.out.println("No push notifier available");  // => Outputs to console
    }
}
 
@Configuration
// => Marks class as Spring bean factory
@ComponentScan
// => Scans packages for @Component and stereotype annotations
class AppConfig {  // => Defines AppConfig class
}
 
public class Example27 {  // => Defines Example27 class
    public static void main(String[] args) {
        // => Application entry point - Spring context created here
    // => Method main receives args
        AnnotationConfigApplicationContext context =
            // => Spring IoC container initialized
            new AnnotationConfigApplicationContext(AppConfig.class);  // => Processes @Configuration, discovers beans
                // => Creates Spring IoC container, processes @Configuration
 
        NotificationService service = context.getBean(NotificationService.class);  // => Retrieves NotificationService bean from container
        // => Assigns service
            // => Retrieves NotificationService bean from container
        service.sendNotification("Test message");  // => Calls sendNotification(...)
        // => Output: PushNotifier injected
        // => Output: Push: Test message
        // => PushNotifier WAS available (bean exists)
 
        context.close();  // => Shuts down Spring container, releases resources
    }  // => End of static
}

import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
import org.springframework.stereotype.Component
 
@Component
# => Component scanning will discover and register this class
class PushNotifier {  # => Defines PushNotifier class
    fun send(message: String) {
    # => Function send executes
        println("Push: $message")  # => Outputs to console
    }  # => End of send
}
 
@Component
# => Component scanning will discover and register this class
class NotificationService {  # => Defines NotificationService class
    private var pushNotifier: PushNotifier? = null  // => Optional dependency (nullable)
 
    @Autowired(required = false)
    // => Spring won't fail if PushNotifier bean missing
    // => Setter NOT called if bean absent
    fun setPushNotifier(pushNotifier: PushNotifier) {
    # => Function setPushNotifier executes
        this.pushNotifier = pushNotifier  // => May remain null
        println("PushNotifier injected")  # => Outputs to console
    }
 
    fun sendNotification(message: String) {
    # => Function sendNotification executes
        pushNotifier?.let {
            // => Safe call - only executes if not null
            it.send(message)  # => Calls send(...)
        } ?: println("No push notifier available")  # => Outputs to console
        // => Elvis operator for null case
    }
}
 
@Configuration
# => Marks class as Spring bean factory
@ComponentScan
# => Scans packages for @Component and stereotype annotations
class AppConfig  # => Defines AppConfig class
 
fun main() {
# => Function main executes
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
 
    val service = context.getBean(NotificationService::class.java)  # => assigns service
    service.sendNotification("Test message")  # => Calls sendNotification(...)
    // => Output: PushNotifier injected
    // => Output: Push: Test message
    // => PushNotifier WAS available (bean exists)
 
    context.close()  # => Shuts down Spring container, releases resources
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
 
class ZakatCalculator {  // => Defines ZakatCalculator class
    private final String type;  // => type: String field
 
    public ZakatCalculator(String type) {
    // => Constructor for ZakatCalculator with injected dependencies
        this.type = type;
    }  // => End of ZakatCalculator
 
    public String getType() {  // => Method: getType(...)
        return type;  // => Returns type
    }
 
    public double calculate(double amount) {  // => Method: calculate(...)
        return amount * 0.025;  // => Returns amount * 0.025
    }
}
 
@Component
// => Component scanning will discover and register this class
class DynamicCalculatorService {  // => Defines DynamicCalculatorService class
    @Autowired
    // => Spring injects the required dependency automatically
    private ApplicationContext context;  // => context: ApplicationContext field
    // => Spring injects its own ApplicationContext
    // => Allows dynamic bean lookup
 
    public void calculateForType(String type, double amount) {  // => Method: calculateForType(...)
        ZakatCalculator calculator = context.getBean(type + "Calculator", ZakatCalculator.class);  // => Retrieves type bean from container
        // => Assigns calculator
            // => Retrieves bean from container
        // => Dynamic bean lookup by name
        // => Name constructed at runtime
 
        double zakat = calculator.calculate(amount);  // => zakat = calculator.calculate(amount)
        System.out.println(type + " Zakat: $" + zakat);  // => Outputs to console
    }
}
 
@Configuration
// => Marks class as Spring bean factory
class AppConfig {  // => Defines AppConfig class
    @Bean("goldCalculator")  // => Named bean
    public ZakatCalculator goldCalculator() {  // => Method: goldCalculator(...)
        return new ZakatCalculator("Gold");  // => Returns result
    }
 
    @Bean("silverCalculator")  // => Named bean
    public ZakatCalculator silverCalculator() {  // => Method: silverCalculator(...)
        return new ZakatCalculator("Silver");  // => Returns result
    }
}
 
public class Example28 {  // => Defines Example28 class
    public static void main(String[] args) {
        // => Application entry point - Spring context created here
    // => Method main receives args
        AnnotationConfigApplicationContext context =
            // => Spring IoC container initialized
            new AnnotationConfigApplicationContext(AppConfig.class, DynamicCalculatorService.class);  // => Processes @Configuration, discovers beans
                // => Creates Spring IoC container, processes @Configuration
 
        DynamicCalculatorService service = context.getBean(DynamicCalculatorService.class);  // => Retrieves DynamicCalculatorService bean from container
        // => Assigns service
            // => Retrieves DynamicCalculatorService bean from container
        service.calculateForType("gold", 10000);    // => Output: gold Zakat: $250.0
        service.calculateForType("silver", 5000);   // => Output: silver Zakat: $125.0
 
        context.close();  // => Shuts down Spring container, releases resources
    }  // => End of static
}

import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.ApplicationContext
import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.stereotype.Component
 
class ZakatCalculator(private val type: String) {  # => Defines ZakatCalculator class
    fun getType(): String = type
    # => Function getType executes
 
    fun calculate(amount: Double): Double = amount * 0.025
    # => Function calculate executes
}
 
@Component
# => Component scanning will discover and register this class
class DynamicCalculatorService {  # => Defines DynamicCalculatorService class
    @Autowired
    # => Spring injects the required dependency automatically
    private lateinit var context: ApplicationContext
    // => Spring injects its own ApplicationContext
    // => Allows dynamic bean lookup
 
    fun calculateForType(type: String, amount: Double) {
    # => Function calculateForType executes
        val calculator = context.getBean("${type}Calculator", ZakatCalculator::class.java)  # => assigns calculator
        // => Dynamic bean lookup by name
        // => Name constructed at runtime
 
        val zakat = calculator.calculate(amount)  # => zakat = calculator.calculate(amount)
        println("$type Zakat: $$zakat")  # => Outputs to console
    }  # => End of calculateForType
}
 
@Configuration
# => Marks class as Spring bean factory
class AppConfig {  # => Defines AppConfig class
    @Bean("goldCalculator")  // => Named bean
    fun goldCalculator(): ZakatCalculator = ZakatCalculator("Gold")
    # => Function goldCalculator executes
 
    @Bean("silverCalculator")  // => Named bean
    fun silverCalculator(): ZakatCalculator = ZakatCalculator("Silver")
    # => Function silverCalculator executes
}
 
fun main() {
# => Function main executes
    val context = AnnotationConfigApplicationContext(AppConfig::class.java, DynamicCalculatorService::class.java)  # => assigns context
 
    val service = context.getBean(DynamicCalculatorService::class.java)  # => assigns service
    service.calculateForType("gold", 10000.0)    // => Output: gold Zakat: $250.0
    service.calculateForType("silver", 5000.0)   // => Output: silver Zakat: $125.0
 
    context.close()  # => Shuts down Spring container, releases resources
}  # => End of main

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
 
@Component  // => Code executes here
// => Component scanning will discover and register this class
class ServiceA {  // => Defines ServiceA class
    private ServiceB serviceB;  // => Circular dependency
 
    // => Constructor creates instance first
    public ServiceA() {
        System.out.println("ServiceA constructor");  // => Outputs to console
    }  // => End of ServiceA
 
    @Autowired  // => Setter injection AFTER construction
                // => Breaks circular dependency cycle
    public void setServiceB(ServiceB serviceB) {  // => Method: setServiceB(...)
        this.serviceB = serviceB;  // => Injected after both beans constructed
        System.out.println("ServiceA: ServiceB injected");  // => Outputs to console
    }
 
    public void doWork() {  // => Method: doWork(...)
        System.out.println("ServiceA working");  // => Outputs to console
        serviceB.help();  // => Uses ServiceB
    }
}
 
@Component
// => Component scanning will discover and register this class
class ServiceB {  // => Defines ServiceB class
    private ServiceA serviceA;  // => Circular dependency
 
    public ServiceB() {
        System.out.println("ServiceB constructor");  // => Outputs to console
    }  // => End of ServiceB
 
    @Autowired  // => Setter injection breaks cycle
    public void setServiceA(ServiceA serviceA) {  // => Method: setServiceA(...)
        this.serviceA = serviceA;
        System.out.println("ServiceB: ServiceA injected");  // => Outputs to console
    }
 
    public void help() {  // => Method: help(...)
        System.out.println("ServiceB helping");  // => Outputs to console
    }
}
 
@Configuration
// => Marks class as Spring bean factory
@ComponentScan
// => Scans packages for @Component and stereotype annotations
class AppConfig {  // => Defines AppConfig class
}
 
public class Example29 {  // => Defines Example29 class
    public static void main(String[] args) {
        // => Application entry point - Spring context created here
        AnnotationConfigApplicationContext context =
            // => Spring IoC container initialized
            new AnnotationConfigApplicationContext(AppConfig.class);  // => Processes @Configuration, discovers beans
                // => Creates Spring IoC container, processes @Configuration
        // => Spring creates both beans, then injects via setters
        // => Output: ServiceA constructor
        // => Output: ServiceB constructor
        // => Output: ServiceA: ServiceB injected
        // => Output: ServiceB: ServiceA injected
 
        ServiceA serviceA = context.getBean(ServiceA.class);  // => Retrieves ServiceA bean from container
        serviceA.doWork();  // => Calls doWork(...)
        // => Output: ServiceA working
        // => Output: ServiceB helping
 
        context.close();  // => Shuts down Spring container, releases resources
    }  // => End of static
}

import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
import org.springframework.stereotype.Component
 
@Component
# => Component scanning will discover and register this class
class ServiceA {  # => Defines ServiceA class
    private lateinit var serviceB: ServiceB  // => Circular dependency (lateinit)
 
    init {
        println("ServiceA constructor")  # => Outputs to console
 
    @Autowired  // => Setter injection AFTER construction
                // => Breaks circular dependency cycle
    fun setServiceB(serviceB: ServiceB) {
    # => Function setServiceB executes
        this.serviceB = serviceB  // => Injected after both beans constructed
        println("ServiceA: ServiceB injected")  # => Outputs to console
    }  # => End of setServiceB
 
    fun doWork() {
    # => Function doWork executes
        println("ServiceA working")  # => Outputs to console
        serviceB.help()  // => Uses ServiceB
    }  # => End of doWork
}
 
@Component
# => Component scanning will discover and register this class
class ServiceB {  # => Defines ServiceB class
    private lateinit var serviceA: ServiceA  // => Circular dependency (lateinit)
 
    init {
        println("ServiceB constructor")  # => Outputs to console
 
    @Autowired  // => Setter injection breaks cycle
    fun setServiceA(serviceA: ServiceA) {
    # => Function setServiceA executes
        this.serviceA = serviceA
        println("ServiceB: ServiceA injected")  # => Outputs to console
    }  # => End of setServiceA
 
    fun help() {
    # => Function help executes
        println("ServiceB helping")  # => Outputs to console
    }  # => End of help
}
 
@Configuration
# => Marks class as Spring bean factory
@ComponentScan
# => Scans packages for @Component and stereotype annotations
class AppConfig  # => Defines AppConfig class
 
fun main() {
# => Function main executes
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
    // => Spring creates both beans, then injects via setters
    // => Output: ServiceA constructor
    // => Output: ServiceB constructor
    // => Output: ServiceA: ServiceB injected
    // => Output: ServiceB: ServiceA injected
 
    val serviceA = context.getBean(ServiceA::class.java)  # => assigns serviceA
    serviceA.doWork()  # => Calls doWork(...)
    // => Output: ServiceA working
    // => Output: ServiceB helping
 
    context.close()  # => Shuts down Spring container, releases resources
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.List;
 
interface Repository<T> {  // => Defines Repository class
    void save(T entity);  // => Code executes here
}
 
class StringRepository implements Repository<String> {  // => Defines StringRepository class
    public void save(String entity) {  // => Method: save(...)
        System.out.println("Saved String: " + entity);  // => Outputs to console
    }
}
 
class IntegerRepository implements Repository<Integer> {  // => Defines IntegerRepository class
    public void save(Integer entity) {  // => Method: save(...)
        System.out.println("Saved Integer: " + entity);  // => Outputs to console
    }
}
 
@Configuration  // => Code executes here
// => Marks class as Spring bean factory
class AppConfig {  // => Defines AppConfig class
    @Bean  // => Code executes here
    // => Registers return value as Spring-managed bean
    public Repository<String> stringRepository() {  // => Method: stringRepository(...)
        return new StringRepository();  // => Generic type: Repository<String>
    }
 
    @Bean  // => Code executes here
    // => Registers return value as Spring-managed bean
    public Repository<Integer> integerRepository() {  // => Method: integerRepository(...)
        return new IntegerRepository();  // => Generic type: Repository<Integer>
    }
 
    @Bean  // => Code executes here
    // => Registers return value as Spring-managed bean
    public GenericService genericService(Repository<String> stringRepo) {  // => Method: genericService(...)
        // => Spring matches by FULL generic type: Repository<String>
        // => Injects stringRepository, NOT integerRepository
        return new GenericService(stringRepo);  // => Returns result
    }
}
 
class GenericService {  // => Defines GenericService class
    private final Repository<String> repository;  // => repository: Repository<String> field
 
    public GenericService(Repository<String> repository) {  // => Code executes here
        this.repository = repository;  // => Type-safe injection
    }  // => End of GenericService
 
    public void process() {  // => Method: process(...)
        repository.save("Test Entity");  // => Calls save(...)
    }
}
 
public class Example30 {  // => Defines Example30 class
    public static void main(String[] args) {
        // => Application entry point - Spring context created here
    // => Method main receives args
        AnnotationConfigApplicationContext context =
            // => Spring IoC container initialized
            new AnnotationConfigApplicationContext(AppConfig.class);  // => Processes @Configuration, discovers beans
                // => Creates Spring IoC container, processes @Configuration
 
        GenericService service = context.getBean(GenericService.class);  // => Retrieves GenericService bean from container
        // => service = context.getBean(GenericService.class)
            // => Retrieves GenericService bean from container
        service.process();  // => Calls process(...)
        // => Output: Saved String: Test Entity
        // => Correct repository injected based on generic type
 
        context.close();  // => Shuts down Spring container, releases resources
    }  // => End of static
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
 
interface Repository<T> {  # => Defines Repository class
    fun save(entity: T)  # => Code executes here
    # => Function save executes
}
 
class StringRepository : Repository<String> {  # => Defines StringRepository class
    override fun save(entity: String) {  # => Code executes here
        println("Saved String: $entity")  # => Outputs to console
    }  # => End of save
}
 
class IntegerRepository : Repository<Int> {  # => Defines IntegerRepository class
    override fun save(entity: Int) {
        println("Saved Integer: $entity")  # => Outputs to console
    }  # => End of save
}
 
@Configuration
# => Marks class as Spring bean factory
class AppConfig {  # => Defines AppConfig class
    @Bean
    # => Registers return value as Spring-managed bean
    fun stringRepository(): Repository<String> {
    # => Function stringRepository executes
        return StringRepository()  // => Generic type: Repository<String>
    }  # => End of stringRepository
 
    @Bean
    # => Registers return value as Spring-managed bean
    fun integerRepository(): Repository<Int> {
    # => Function integerRepository executes
        return IntegerRepository()  // => Generic type: Repository<Int>
    }  # => End of integerRepository
 
    @Bean
    # => Registers return value as Spring-managed bean
    fun genericService(stringRepo: Repository<String>): GenericService {
    # => Function genericService executes
        // => Spring matches by FULL generic type: Repository<String>
        // => Injects stringRepository, NOT integerRepository
        return GenericService(stringRepo)  # => Returns result
    }  # => End of genericService
}
 
class GenericService(private val repository: Repository<String>) {  # => Defines GenericService class
    // => Type-safe injection
 
    fun process() {
    # => Function process executes
        repository.save("Test Entity")  # => Calls save(...)
    }  # => End of process
}
 
fun main() {
# => Function main executes
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
 
    val service = context.getBean(GenericService::class.java)  # => assigns service
    service.process()  # => Calls process(...)
    // => Output: Saved String: Test Entity
    // => Correct repository injected based on generic type
 
    context.close()  # => Shuts down Spring container, releases resources
}  # => End of main

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;
 
@Aspect  // => Marks this as AOP aspect
@Component  // => Makes it a Spring-managed bean
class LoggingAspect {  // => Defines LoggingAspect class
    @Before("execution(* DonationService.donate(..))")
    // => Pointcut expression: matches donate() method in DonationService
    // => execution: method execution join point
    // => * : any return type
    // => DonationService.donate: class and method name
    // => (..) : any number/type of parameters
    public void logBefore(JoinPoint joinPoint) {  // => Method: logBefore(...)
        // => Runs BEFORE donate() method executes
        String methodName = joinPoint.getSignature().getName();  // => assigns methodName
        // => Gets method name being called
        System.out.println("BEFORE: " + methodName + " called");  // => Outputs to console
    }
}
 
@Component
// => Component scanning will discover and register this class
class DonationService {  // => Defines DonationService class
    public void donate(String donor, double amount) {  // => Method: donate(...)
        System.out.println("Donation: " + donor + " - $" + amount);  // => Outputs to console
    }
}
 
@Configuration
// => Marks class as Spring bean factory
@ComponentScan
@EnableAspectJAutoProxy  // => Enables Spring AOP proxy creation
                          // => Required for @Aspect to work
class AppConfig {  // => Defines AppConfig class
}
 
public class Example31 {  // => Defines Example31 class
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(AppConfig.class);
                // => Creates Spring IoC container, processes @Configuration
 
        DonationService service = context.getBean(DonationService.class);
            // => Retrieves DonationService bean from container
        service.donate("Ibrahim", 500.0);  // => Calls donate(...)
        // => Output: BEFORE: donate called
        // => Output: Donation: Ibrahim - $500.0
        // => Aspect executed before actual method
 
        context.close();  // => Shuts down Spring container, releases resources
    }
}

import org.aspectj.lang.JoinPoint
import org.aspectj.lang.annotation.Aspect
import org.aspectj.lang.annotation.Before
import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.EnableAspectJAutoProxy
import org.springframework.stereotype.Component
 
@Aspect  // => Marks this as AOP aspect
@Component  // => Makes it a Spring-managed bean
class LoggingAspect {  # => Defines LoggingAspect class
    @Before("execution(* DonationService.donate(..))")
    // => Pointcut expression: matches donate() method in DonationService
    // => execution: method execution join point
    // => * : any return type
    // => DonationService.donate: class and method name
    // => (..) : any number/type of parameters
    fun logBefore(joinPoint: JoinPoint) {
        // => Runs BEFORE donate() method executes
        val methodName = joinPoint.signature.name  # => methodName = joinPoint.signature.name
        // => Gets method name being called
        println("BEFORE: $methodName called")  # => Outputs to console
    }
}
 
@Component
# => Component scanning will discover and register this class
class DonationService {  # => Defines DonationService class
    fun donate(donor: String, amount: Double) {
        println("Donation: $donor - $$amount")  # => Outputs to console
    }
}
 
@Configuration
@ComponentScan
@EnableAspectJAutoProxy  // => Enables Spring AOP proxy creation
                          // => Required for @Aspect to work
class AppConfig  # => Defines AppConfig class
 
fun main() {
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
 
    val service = context.getBean(DonationService::class.java)  # => assigns service
    service.donate("Ibrahim", 500.0)  # => Calls donate(...)
    // => Output: BEFORE: donate called
    // => Output: Donation: Ibrahim - $500.0
    // => Aspect executed before actual method
 
    context.close()  # => Shuts down Spring container, releases resources
}

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;
 
@Aspect
// => Marks class as containing AOP advice definitions
@Component
// => Component scanning will discover and register this class
class AuditAspect {  // => Defines AuditAspect class
    @AfterReturning(
    // => Advice executes after successful method return
        pointcut = "execution(* ZakatService.calculateZakat(..))",
        // => Assigns pointcut
        returning = "result"
        // => Captures return value in "result" parameter
    )
    public void auditResult(JoinPoint joinPoint, Object result) {  // => Method: auditResult(...)
        // => Runs AFTER successful method completion
        // => Only if method returns normally (no exception)
        System.out.println("AFTER_RETURNING: Result = " + result);  // => Outputs to console
    }
 
    @After("execution(* ZakatService.calculateZakat(..))")
    // => Advice executes after the matched method (always)
    // => Runs AFTER method completes (success OR exception)
    // => Like finally block
    public void logAfter(JoinPoint joinPoint) {  // => Method: logAfter(...)
        System.out.println("AFTER: Method completed");  // => Outputs to console
    }
}
 
@Component
// => Component scanning will discover and register this class
class ZakatService {  // => Defines ZakatService class
    public double calculateZakat(double wealth) {  // => Method: calculateZakat(...)
        System.out.println("Calculating zakat for wealth: " + wealth);  // => Outputs to console
        return wealth * 0.025;  // => Returns result
    }
}
 
@Configuration
// => Marks class as Spring bean factory
@ComponentScan
// => Scans packages for @Component and stereotype annotations
@EnableAspectJAutoProxy
// => Enables @Aspect annotation processing
class AppConfig {  // => Defines AppConfig class
}
 
public class Example32 {  // => Defines Example32 class
    public static void main(String[] args) {
        // => Application entry point - Spring context created here
    // => Method main receives args
        AnnotationConfigApplicationContext context =
            // => Spring IoC container initialized
            new AnnotationConfigApplicationContext(AppConfig.class);  // => Processes @Configuration, discovers beans
                // => Creates Spring IoC container, processes @Configuration
 
        ZakatService service = context.getBean(ZakatService.class);  // => Retrieves ZakatService bean from container
        double zakat = service.calculateZakat(10000);  // => zakat = service.calculateZakat(10000)
        // => Output: Calculating zakat for wealth: 10000.0
        // => Output: AFTER_RETURNING: Result = 250.0
        // => Output: AFTER: Method completed
 
        System.out.println("Final zakat: " + zakat);  // => Outputs to console
 
        context.close();  // => Shuts down Spring container, releases resources
    }
}

import org.aspectj.lang.JoinPoint
import org.aspectj.lang.annotation.*
import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.EnableAspectJAutoProxy
import org.springframework.stereotype.Component
 
@Aspect
# => Marks class as containing AOP advice definitions
@Component
# => Component scanning will discover and register this class
class AuditAspect {  # => Defines AuditAspect class
    @AfterReturning(
    # => Advice executes after successful method return
        pointcut = "execution(* ZakatService.calculateZakat(..))",
        # => Assigns pointcut
        returning = "result"
        // => Captures return value in "result" parameter
    )
    fun auditResult(joinPoint: JoinPoint, result: Any) {
    # => Function auditResult executes
        // => Runs AFTER successful method completion
        // => Only if method returns normally (no exception)
        println("AFTER_RETURNING: Result = $result")  # => Outputs to console
    }
 
    @After("execution(* ZakatService.calculateZakat(..))")
    # => Advice executes after the matched method (always)
    // => Runs AFTER method completes (success OR exception)
    // => Like finally block
    fun logAfter(joinPoint: JoinPoint) {
    # => Function logAfter executes
        println("AFTER: Method completed")  # => Outputs to console
    }
}
 
@Component
# => Component scanning will discover and register this class
class ZakatService {  # => Defines ZakatService class
    fun calculateZakat(wealth: Double): Double {
    # => Function calculateZakat executes
        println("Calculating zakat for wealth: $wealth")  # => Outputs to console
        return wealth * 0.025  // => Returns result
    }
}
 
@Configuration
# => Marks class as Spring bean factory
@ComponentScan
# => Scans packages for @Component and stereotype annotations
@EnableAspectJAutoProxy
# => Enables @Aspect annotation processing
class AppConfig  # => Defines AppConfig class
 
fun main() {
# => Function main executes
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
 
    val service = context.getBean(ZakatService::class.java)  # => assigns service
    val zakat = service.calculateZakat(10000.0)  # => assigns zakat
    // => Output: Calculating zakat for wealth: 10000.0
    // => Output: AFTER_RETURNING: Result = 250.0
    // => Output: AFTER: Method completed
 
    println("Final zakat: $zakat")  # => Outputs to console
 
    context.close()  # => Shuts down Spring container, releases resources
}

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
 
@Aspect
// => Marks class as containing AOP advice definitions
@Component
// => Component scanning will discover and register this class
class PerformanceAspect {  // => Defines PerformanceAspect class
    @Around("execution(* PaymentService.*(..))")
    // => Wraps entire method execution
    public Object measureTime(ProceedingJoinPoint pjp) throws Throwable {  // => Method: measureTime(...)
        long start = System.currentTimeMillis();  // => start = System.currentTimeMillis()
        // => Before method execution
 
        Object result = pjp.proceed();  // => Executes target method
        // => Returns method result
 
        long duration = System.currentTimeMillis() - start;  // => assigns duration
        System.out.println("Time: " + duration + "ms");  // => Outputs to console
        return result;  // => Returns to caller
    }
}

import org.aspectj.lang.ProceedingJoinPoint
import org.aspectj.lang.annotation.Around
import org.aspectj.lang.annotation.Aspect
import org.springframework.stereotype.Component
 
@Aspect
# => Marks class as containing AOP advice definitions
@Component
# => Component scanning will discover and register this class
class PerformanceAspect {  # => Defines PerformanceAspect class
    @Around("execution(* PaymentService.*(..))")
    # => Advice wraps the matched method execution
    // => Wraps entire method execution
    @Throws(Throwable::class)
    fun measureTime(pjp: ProceedingJoinPoint): Any? {
    # => Function measureTime executes
        val start = System.currentTimeMillis()  # => start = System.currentTimeMillis()
        // => Before method execution
 
        val result = pjp.proceed()  // => Executes target method
        // => Returns method result
 
        val duration = System.currentTimeMillis() - start  # => assigns duration
        println("Time: ${duration}ms")  # => Outputs to console
        return result  // => Returns to caller
    }
}

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
 
@Aspect
// => Marks class as containing AOP advice definitions
@Component
// => Component scanning will discover and register this class
class SecurityAspect {  // => Defines SecurityAspect class
    @Pointcut("execution(* *Service.*(..))")
    // => Defines reusable pointcut expression
    // => Matches all methods in *Service classes
    public void serviceMethods() {}  // => Reusable pointcut
 
    @Pointcut("args(amount,..)")
    // => Defines reusable pointcut expression
    // => Matches methods with first param named amount
    public void hasAmount() {}  // => Method: hasAmount(...)
 
    @Before("serviceMethods() && hasAmount()")
    // => Combines both pointcuts with AND
    public void checkSecurity() {  // => Method: checkSecurity(...)
        System.out.println("Security check");  // => Outputs to console
    }
}

import org.aspectj.lang.annotation.Aspect
import org.aspectj.lang.annotation.Before
import org.aspectj.lang.annotation.Pointcut
import org.springframework.stereotype.Component
 
@Aspect
# => Marks class as containing AOP advice definitions
@Component
# => Component scanning will discover and register this class
class SecurityAspect {  # => Defines SecurityAspect class
    @Pointcut("execution(* *Service.*(..))")
    # => Defines reusable pointcut expression
    // => Matches all methods in *Service classes
    fun serviceMethods() {}  // => Reusable pointcut
 
    @Pointcut("args(amount,..)")
    # => Defines reusable pointcut expression
    // => Matches methods with first param named amount
    fun hasAmount() {}
    # => Function hasAmount executes
 
    @Before("serviceMethods() && hasAmount()")
    // => Combines both pointcuts with AND
    fun checkSecurity() {
    # => Function checkSecurity executes
        println("Security check")  # => Outputs to console
    }
}

import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
 
@Aspect
// => Marks class as containing AOP advice definitions
@Component
// => Component scanning will discover and register this class
class ErrorAspect {  // => Defines ErrorAspect class
    @AfterThrowing(
    // => Advice executes when method throws an exception
        pointcut = "execution(* TransferService.*(..))",
        // => pointcut = "execution(* TransferService.*(..))"
        throwing = "ex"
        // => Captures thrown exception
    )
    public void handleError(Exception ex) {  // => Method: handleError(...)
        // => Called only on exception
        // => Does NOT catch (exception still propagates)
        System.out.println("Error logged: " + ex.getMessage());  // => Outputs to console
        // => Could send alerts, log to monitoring
    }
}

import org.aspectj.lang.annotation.AfterThrowing
import org.aspectj.lang.annotation.Aspect
import org.springframework.stereotype.Component
 
@Aspect
# => Marks class as containing AOP advice definitions
@Component
# => Component scanning will discover and register this class
class ErrorAspect {  # => Defines ErrorAspect class
    @AfterThrowing(
    # => Advice executes when method throws an exception
        pointcut = "execution(* TransferService.*(..))",
        # => pointcut = "execution(* TransferService.*(..))"
        throwing = "ex"
        // => Captures thrown exception
    )
    fun handleError(ex: Exception) {
    # => Function handleError executes
        // => Called only on exception
        // => Does NOT catch (exception still propagates)
        println("Error logged: ${ex.message}")  # => Outputs to console
        // => Could send alerts, log to monitoring
    }
}

import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Service;
 
@Service
// => Specialized @Component for business logic layer
class AccountService {  // => Defines AccountService class
    @Transactional  // => Method runs in transaction
                    // => Commits on success, rolls back on exception
    public void transfer(String from, String to, double amount) {  // => Method: transfer(...)
        debit(from, amount);   // => Operation 1
        credit(to, amount);    // => Operation 2
        // => Both succeed or both rollback
    }
 
    private void debit(String account, double amount) {  // => Method: debit(...)
        System.out.println("Debit: $" + amount);  // => Outputs to console
        // => Would execute: UPDATE accounts SET balance = balance - ?
    }
 
    private void credit(String account, double amount) {  // => Method: credit(...)
        System.out.println("Credit: $" + amount);  // => Outputs to console
        // => Would execute: UPDATE accounts SET balance = balance + ?
    }
}

import org.springframework.transaction.annotation.Transactional
import org.springframework.stereotype.Service
 
@Service
# => Specialized @Component for business logic layer
class AccountService {  # => Defines AccountService class
    @Transactional  // => Method runs in transaction
                    // => Commits on success, rolls back on exception
    fun transfer(from: String, to: String, amount: Double) {
        debit(from, amount)   // => Operation 1
        credit(to, amount)    // => Operation 2
        // => Both succeed or both rollback
    }  # => End of transfer
 
    private fun debit(account: String, amount: Double) {  # => Method: debit(...)
        println("Debit: $$amount")  # => Outputs to console
        // => Would execute: UPDATE accounts SET balance = balance - ?
    }
 
    private fun credit(account: String, amount: Double) {  # => Method: credit(...)
        println("Credit: $$amount")  # => Outputs to console
        // => Would execute: UPDATE accounts SET balance = balance + ?
    }
}

import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Service;
 
@Service
// => Specialized @Component for business logic layer
class OrderService {  // => Defines OrderService class
    @Transactional(propagation = Propagation.REQUIRED)
    // => Joins existing transaction or creates new one
    // => Default behavior
    public void createOrder() {  // => Method: createOrder(...)
        System.out.println("Order created");  // => Outputs to console
    }
 
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    // => Always creates NEW transaction
    // => Suspends current transaction if exists
    public void logAudit() {  // => Method: logAudit(...)
        System.out.println("Audit logged");  // => Outputs to console
        // => Commits independently of outer transaction
    }
 
    @Transactional(propagation = Propagation.MANDATORY)
    // => Must run within existing transaction
    // => Throws exception if no transaction active
    public void updateInventory() {  // => Method: updateInventory(...)
        System.out.println("Inventory updated");  // => Outputs to console
    }
}

import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.stereotype.Service
 
@Service
# => Specialized @Component for business logic layer
class OrderService {  # => Defines OrderService class
    @Transactional(propagation = Propagation.REQUIRED)
    # => Wraps test in transaction; rolls back after
    // => Joins existing transaction or creates new one
    // => Default behavior
    fun createOrder() {
        println("Order created")  # => Outputs to console
    }
 
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    # => Wraps test in transaction; rolls back after
    // => Always creates NEW transaction
    // => Suspends current transaction if exists
    fun logAudit() {
        println("Audit logged")  # => Outputs to console
        // => Commits independently of outer transaction
    }
 
    @Transactional(propagation = Propagation.MANDATORY)
    # => Wraps test in transaction; rolls back after
    // => Must run within existing transaction
    // => Throws exception if no transaction active
    fun updateInventory() {
        println("Inventory updated")  # => Outputs to console
    }
}

import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Service;
 
@Service
class InventoryService {  // => Defines InventoryService class
    @Transactional(isolation = Isolation.READ_COMMITTED)
    // => Prevents dirty reads
    // => Can see committed changes from other transactions
    public int checkStock(String product) {  // => Method: checkStock(...)
        // => Reads only committed data
        return 100;  // => Simulated stock level
    }
 
    @Transactional(isolation = Isolation.REPEATABLE_READ)
    // => Prevents dirty and non-repeatable reads
    // => Same query returns same results within transaction
    public void processOrder() {  // => Method: processOrder(...)
        int stock1 = checkStockInternal();  // => Returns 100
        // => Other transaction updates stock
        int stock2 = checkStockInternal();  // => Still returns 100
        // => Repeatable read guaranteed
    }
 
    private int checkStockInternal() {  // => Method: checkStockInternal(...)
        return 100;  // => Returns 100
    }
}

import org.springframework.transaction.annotation.Isolation
import org.springframework.transaction.annotation.Transactional
import org.springframework.stereotype.Service
 
@Service
# => Specialized @Component for business logic layer
class InventoryService {  # => Defines InventoryService class
    @Transactional(isolation = Isolation.READ_COMMITTED)
    // => Prevents dirty reads
    // => Can see committed changes from other transactions
    fun checkStock(product: String): Int {
        // => Reads only committed data
        return 100  // => Simulated stock level
    }
 
    @Transactional(isolation = Isolation.REPEATABLE_READ)
    // => Prevents dirty and non-repeatable reads
    // => Same query returns same results within transaction
    fun processOrder() {
        val stock1 = checkStockInternal()  // => Returns 100
        // => Other transaction updates stock
        val stock2 = checkStockInternal()  // => Still returns 100
        // => Repeatable read guaranteed
    }
 
    private fun checkStockInternal(): Int = 100  # => Method: checkStockInternal(...)
}

import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Service;
 
@Service
// => Specialized @Component for business logic layer
class PaymentService {  // => Defines PaymentService class
    @Transactional(rollbackFor = Exception.class)
    // => Rolls back on ANY exception (checked or unchecked)
    // => Default: rollback only on unchecked exceptions
    public void processPayment() throws Exception {  // => Method: processPayment(...)
        // => Checked exceptions now trigger rollback
        if (Math.random() > 0.5) {  // => Conditional check
            throw new Exception("Payment failed");  // => Throws exception
            // => Transaction rolled back
        }
    }
 
    @Transactional(noRollbackFor = IllegalArgumentException.class)
    // => Does NOT rollback for IllegalArgumentException
    // => Commits despite this exception
    public void validatePayment() {  // => Method: validatePayment(...)
        if (Math.random() > 0.5) {  // => Conditional check
            throw new IllegalArgumentException("Invalid amount");  // => Throws exception
            // => Transaction still commits
        }
    }
}

import org.springframework.transaction.annotation.Transactional
import org.springframework.stereotype.Service
 
@Service
# => Specialized @Component for business logic layer
class PaymentService {  # => Defines PaymentService class
    @Transactional(rollbackFor = [Exception::class])
    # => Wraps test in transaction; rolls back after
    // => Rolls back on ANY exception (checked or unchecked)
    // => Default: rollback only on unchecked exceptions
    @Throws(Exception::class)
    fun processPayment() {
        // => Checked exceptions now trigger rollback
        if (Math.random() > 0.5) {  # => Conditional check
            throw Exception("Payment failed")  # => Throws exception
            // => Transaction rolled back
        }  # => End of processPayment
    }
 
    @Transactional(noRollbackFor = [IllegalArgumentException::class])
    # => Wraps test in transaction; rolls back after
    // => Does NOT rollback for IllegalArgumentException
    // => Commits despite this exception
    fun validatePayment() {
        if (Math.random() > 0.5) {  # => Conditional check
            throw IllegalArgumentException("Invalid amount")  # => Throws exception
            // => Transaction still commits
        }
    }
}

import org.springframework.transaction.support.TransactionTemplate;
import org.springframework.stereotype.Service;
 
@Service  // => Code executes here
// => Specialized @Component for business logic layer
class BatchService {  // => Defines BatchService class
    private final TransactionTemplate transactionTemplate;  // => transactionTemplate: TransactionTemplate field
 
    public BatchService(TransactionTemplate transactionTemplate) {  // => Code executes here
    // => Constructor for BatchService with injected dependencies
        this.transactionTemplate = transactionTemplate;  // => Code executes here
        // => Injected transaction template
    }  // => End of BatchService
 
    public void processBatch() {  // => Method: processBatch(...)
        transactionTemplate.execute(status -> {  // => Calls execute(...)
            // => Transaction started
            try {
            // => Exception-safe block - failures handled by catch clause
                processItems();  // => Business logic
                return true;     // => Commits transaction
            } catch (Exception e) {
                status.setRollbackOnly();  // => Marks for rollback
                return false;  // => Returns false
        });
 
    private void processItems() {  // => Method: processItems(...)
        System.out.println("Processing items");  // => Outputs to console
    }
}

import org.springframework.transaction.support.TransactionTemplate
import org.springframework.stereotype.Service
 
@Service  # => Code executes here
# => Specialized @Component for business logic layer
class BatchService(  # => Defines BatchService class
    private val transactionTemplate: TransactionTemplate  # => Field: transactionTemplate
    // => Injected transaction template
) {  # => Code executes here
    fun processBatch() {  # => Code executes here
    # => Function processBatch executes
        transactionTemplate.execute { status ->
            // => Transaction started
            try {
            # => Exception-safe block - failures handled by catch clause
                processItems()  // => Business logic
                true  // => Commits transaction
            } catch (e: Exception) {
                status.setRollbackOnly()  // => Marks for rollback
                false
    }  # => End of processBatch
 
    private fun processItems() {  # => Method: processItems(...)
        println("Processing items")  # => Outputs to console
}

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
 
@Repository
// => Specialized @Component for data access layer
class DonationRepository {  // => Defines DonationRepository class
    private final JdbcTemplate jdbc;
 
    public DonationRepository(JdbcTemplate jdbc) {
        this.jdbc = jdbc;  // => Injected JdbcTemplate
    }
 
    public int countDonations() {  // => Method: countDonations(...)
        String sql = "SELECT COUNT(*) FROM donations";  // => assigns sql
        // => SQL query string
 
        Integer count = jdbc.queryForObject(sql, Integer.class);  // => count assigned from jdbc.queryForObject(...)
        // => Executes query
        // => Converts result to Integer
 
        return count != null ? count : 0;  // => Returns result
    }
 
    public void save(String donor, double amount) {  // => Method: save(...)
        String sql = "INSERT INTO donations (donor, amount) VALUES (?, ?)";  // => assigns sql
        // => Parameterized query (prevents SQL injection)
 
        jdbc.update(sql, donor, amount);  // => Calls update(...)
        // => Executes INSERT/UPDATE/DELETE
        // => Parameters bound in order
    }
}

import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.stereotype.Repository
 
@Repository
class DonationRepository(  # => Defines DonationRepository class
    private val jdbc: JdbcTemplate
    // => Injected JdbcTemplate
) {
    fun countDonations(): Int {
        val sql = "SELECT COUNT(*) FROM donations"  # => assigns sql
        // => SQL query string
 
        return jdbc.queryForObject(sql, Int::class.java) ?: 0  # => Returns result
        // => Executes query
        // => Converts result to Int
        // => Elvis operator for null safety
    }
 
    fun save(donor: String, amount: Double) {
        val sql = "INSERT INTO donations (donor, amount) VALUES (?, ?)"  # => assigns sql
        // => Parameterized query (prevents SQL injection)
 
        jdbc.update(sql, donor, amount)  # => Calls update(...)
        // => Executes INSERT/UPDATE/DELETE
        // => Parameters bound in order
    }
}

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
import java.util.List;
 
class Donation {  // => Defines Donation class
    private final String donor;  // => donor: String field
    private final 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;  // => Code executes here
    }  // => End of Donation
 
    public String getDonor() { return donor; }  // => Method: getDonor(...)
    public double getAmount() { return amount; }  // => Method: getAmount(...)
}
 
@Repository
// => Specialized @Component for data access layer
class DonationRepository {  // => Defines DonationRepository class
    private final JdbcTemplate jdbc;  // => jdbc: JdbcTemplate field
 
    private final RowMapper<Donation> rowMapper = (rs, rowNum) -> {
        // => Lambda RowMapper
        String donor = rs.getString("donor");   // => Extract column
        double amount = rs.getDouble("amount"); // => Extract column
        return new Donation(donor, amount);     // => Create object
    };
 
    public DonationRepository(JdbcTemplate jdbc) {
    // => Constructor for DonationRepository with injected dependencies
        this.jdbc = jdbc;
    }  // => End of DonationRepository
 
    public List<Donation> findAll() {  // => Method: findAll(...)
        String sql = "SELECT donor, amount FROM donations";  // => assigns sql
        return jdbc.query(sql, rowMapper);  // => Returns result
        // => Executes query
        // => Maps each row using rowMapper
        // => Returns List<Donation>
    }  // => End of final
}

import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.jdbc.core.RowMapper
import org.springframework.stereotype.Repository
 
data class Donation(val donor: String, val amount: Double)  # => Code executes here
 
@Repository
# => Specialized @Component for data access layer
class DonationRepository(private val jdbc: JdbcTemplate) {  # => Defines DonationRepository class
    private val rowMapper = RowMapper<Donation> { rs, _ ->
        // => Lambda RowMapper
        val donor = rs.getString("donor")    // => Extract column
        val amount = rs.getDouble("amount")  // => Extract column
        Donation(donor, amount)              // => Create object
    }
 
    fun findAll(): List<Donation> {
        val sql = "SELECT donor, amount FROM donations"  # => assigns sql
        return jdbc.query(sql, rowMapper)  # => Returns result
        // => Executes query
        // => Maps each row using rowMapper
        // => Returns List<Donation>
    }  # => End of findAll
}

import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.stereotype.Repository;
 
@Repository
// => Specialized @Component for data access layer
class ZakatRepository {  // => Defines ZakatRepository class
    private final NamedParameterJdbcTemplate namedJdbc;  // => namedJdbc: NamedParameterJdbcTemplate field
 
    public ZakatRepository(NamedParameterJdbcTemplate namedJdbc) {
        this.namedJdbc = namedJdbc;
        // => Uses named parameters (:name) instead of ? placeholders
    }  // => End of ZakatRepository
 
    public void save(String payer, double amount) {  // => Method: save(...)
        String sql = "INSERT INTO zakat (payer, amount) VALUES (:payer, :amount)";  // => assigns sql
        // => Named parameters with :name syntax
 
        MapSqlParameterSource params = new MapSqlParameterSource()
        // => params = new MapSqlParameterSource()
            .addValue("payer", payer)    // => Bind :payer parameter
            .addValue("amount", amount); // => Bind :amount parameter
        // => Readable parameter mapping
 
        namedJdbc.update(sql, params);  // => Calls update(...)
        // => Executes with named parameters
    }
}

import org.springframework.jdbc.core.namedparam.MapSqlParameterSource
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
import org.springframework.stereotype.Repository
 
@Repository
# => Specialized @Component for data access layer
class ZakatRepository(  # => Defines ZakatRepository class
    private val namedJdbc: NamedParameterJdbcTemplate
    // => Uses named parameters (:name) instead of ? placeholders
) {
    fun save(payer: String, amount: Double) {
        val sql = "INSERT INTO zakat (payer, amount) VALUES (:payer, :amount)"  # => assigns sql
        // => Named parameters with :name syntax
 
        val params = MapSqlParameterSource()  # => params = MapSqlParameterSource()
            .addValue("payer", payer)    // => Bind :payer parameter
            .addValue("amount", amount)  // => Bind :amount parameter
        // => Readable parameter mapping
 
        namedJdbc.update(sql, params)  # => Calls update(...)
        // => Executes with named parameters
    }  # => End of save
}

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.util.List;
 
@Repository  // => Code executes here
// => Specialized @Component for data access layer
class BulkRepository {  // => Defines BulkRepository class
    private final JdbcTemplate jdbc;  // => jdbc: JdbcTemplate field
 
    public BulkRepository(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
    }  // => End of BulkRepository
 
    public void saveBatch(List<String> donors, List<Double> amounts) {  // => Method: saveBatch(...)
        String sql = "INSERT INTO donations (donor, amount) VALUES (?, ?)";  // => assigns sql
 
        jdbc.batchUpdate(sql, donors, amounts.size(), (ps, i) -> {  // => Calls batchUpdate(...)
            // => Batch PreparedStatement callback
            // => Called once per row
            ps.setString(1, donors.get(i));   // => Set donor parameter
            ps.setDouble(2, amounts.get(i));  // => Set amount parameter
            // => Batched for efficiency
        });
        // => Single network roundtrip for all rows
    }
}

import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.stereotype.Repository
 
@Repository
# => Specialized @Component for data access layer
class BulkRepository(private val jdbc: JdbcTemplate) {  # => Defines BulkRepository class
    fun saveBatch(donors: List<String>, amounts: List<Double>) {
        val sql = "INSERT INTO donations (donor, amount) VALUES (?, ?)"  # => assigns sql
 
        jdbc.batchUpdate(sql, donors, amounts.size) { ps, i ->  # => Calls batchUpdate(...)
            // => Batch PreparedStatement callback
            // => Called once per row
            ps.setString(1, donors[i])   // => Set donor parameter
            ps.setDouble(2, amounts[i])  // => Set amount parameter
            // => Batched for efficiency
        }
        // => Single network roundtrip for all rows
    }
}

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ResultSetExtractor;
import org.springframework.stereotype.Repository;
import java.util.HashMap;
import java.util.Map;
 
@Repository  // => Code executes here
// => Specialized @Component for data access layer
class StatisticsRepository {  // => Defines StatisticsRepository class
    private final JdbcTemplate jdbc;  // => jdbc: JdbcTemplate field
 
    public StatisticsRepository(JdbcTemplate jdbc) {  // => Code executes here
    // => Constructor for StatisticsRepository with injected dependencies
        this.jdbc = jdbc;  // => Code executes here
    }  // => End of StatisticsRepository
 
    public Map<String, Double> getDonationsByCategory() {  // => Code executes here
        String sql = "SELECT category, SUM(amount) as total FROM donations GROUP BY category";  // => assigns sql
 
        ResultSetExtractor<Map<String, Double>> extractor = rs -> {
            // => Custom extraction logic
            Map<String, Double> results = new HashMap<>();
 
            while (rs.next()) {  // => Iterate all rows
                String category = rs.getString("category");  // => category = rs.getString("category")
                double total = rs.getDouble("total");  // => total = rs.getDouble("total")
                results.put(category, total);  // => Build map
 
            return results;  // => Return custom structure
        };
 
        return jdbc.query(sql, extractor);  // => Returns result
        // => Uses custom extractor instead of RowMapper
    }  // => End of Map
}

import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.jdbc.core.ResultSetExtractor
import org.springframework.stereotype.Repository
 
@Repository  # => Code executes here
# => Specialized @Component for data access layer
class StatisticsRepository(private val jdbc: JdbcTemplate) {  # => Defines StatisticsRepository class
    fun getDonationsByCategory(): Map<String, Double> {  # => Code executes here
        val sql = "SELECT category, SUM(amount) as total FROM donations GROUP BY category"  # => assigns sql
 
        val extractor = ResultSetExtractor { rs ->  # => extractor = ResultSetExtractor { rs ->
            // => Custom extraction logic
            val results = mutableMapOf<String, Double>()  # => assigns results
 
            while (rs.next()) {  // => Iterate all rows
                val category = rs.getString("category")  # => category = rs.getString("category")
                val total = rs.getDouble("total")  # => total = rs.getDouble("total")
                results[category] = total  // => Build map
            }  # => End of getDonationsByCategory
 
            results  // => Return custom structure
        }
 
        return jdbc.query(sql, extractor) ?: emptyMap()  # => Returns result
        // => Uses custom extractor instead of RowMapper
    }
}

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
 
@Controller  // => Marks as MVC controller
             // => Handles web requests
public class DonationController {  // => Defines DonationController class
    @GetMapping("/donations")
    // => Maps GET requests to /donations
    @ResponseBody  // => Return value becomes HTTP response body
    public String list() {  // => Method: list(...)
        return "Donation list";  // => Response body text
        // => Content-Type: text/plain
    }
}

import org.springframework.stereotype.Controller
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.ResponseBody
 
@Controller  // => Marks as MVC controller
             // => Handles web requests
class DonationController {  # => Defines DonationController class
    @GetMapping("/donations")
    # => Handles HTTP GET requests
    // => Maps GET requests to /donations
    @ResponseBody  // => Return value becomes HTTP response body
    fun list(): String {
        return "Donation list"  // => Response body text
        // => Content-Type: text/plain
    }
}

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
 
@Controller
public class ZakatController {  // => Defines ZakatController class
    @GetMapping("/zakat/calculate")
    // => Handles HTTP GET requests
    @ResponseBody
    // => Serializes return value to JSON/response
    public String calculate(  // => Method: calculate(...)
        @RequestParam("amount") double amount,
        // => Binds query parameter to method parameter
        // => Captures query param: /zakat/calculate?amount=1000
        @RequestParam(value = "rate", defaultValue = "0.025") double rate
        // => Binds query parameter to method parameter
        // => Optional param with default value
    ) {
        double zakat = amount * rate;  // => zakat = amount * rate
        return "Zakat: $" + zakat;  // => Returns calculated value
 
    @GetMapping("/zakat/{id}")
    // => Handles HTTP GET requests
    @ResponseBody
    // => Serializes return value to JSON/response
    public String getById(@PathVariable("id") Long id) {  // => Method: getById(...)
        // => Captures path variable: /zakat/123
        // => id = 123
        return "Zakat record: " + id;  // => Returns "Zakat record: " + id
    }
}

import org.springframework.stereotype.Controller
import org.springframework.web.bind.annotation.*
 
@Controller
class ZakatController {  # => Defines ZakatController class
    @GetMapping("/zakat/calculate")
    # => Handles HTTP GET requests
    @ResponseBody
    # => Serializes return value to JSON/response
    fun calculate(
        @RequestParam("amount") amount: Double,
        # => Binds query parameter to method parameter
        // => Captures query param: /zakat/calculate?amount=1000
        @RequestParam(value = "rate", defaultValue = "0.025") rate: Double
        # => Binds query parameter to method parameter
        // => Optional param with default value
    ): String {
        val zakat = amount * rate  # => zakat = amount * rate
        return "Zakat: $$zakat"  // => Returns calculated value
 
    @GetMapping("/zakat/{id}")
    # => Handles HTTP GET requests
    @ResponseBody
    # => Serializes return value to JSON/response
    fun getById(@PathVariable("id") id: Long): String {
    # => Function getById executes
        // => Captures path variable: /zakat/123
        // => id = 123
        return "Zakat record: $id"  # => Returns "Zakat record: $id"
    }  # => End of getById
}

import org.springframework.web.bind.annotation.*;
 
class DonationRequest {  // => Defines DonationRequest class
    private String donor;
    private double amount;
 
    // Getters and setters
    public String getDonor() { return donor; }  // => Method: getDonor(...)
    public void setDonor(String donor) { this.donor = donor; }  // => Method: setDonor(...)
    public double getAmount() { return amount; }  // => Method: getAmount(...)
    public void setAmount(double amount) { this.amount = amount; }  // => Method: setAmount(...)
}
 
@RestController  // => Combines @Controller + @ResponseBody
                 // => All methods return response body
@RequestMapping("/api")
// => Maps HTTP requests to this controller
public class DonationApiController {  // => Defines DonationApiController class
    @PostMapping("/donations")
    // => Handles HTTP POST requests
    public String create(@RequestBody DonationRequest request) {  // => Method: create(...)
        // => @RequestBody deserializes JSON to object
        // => Content-Type: application/json expected
 
        String donor = request.getDonor();    // => Access deserialized data
        double amount = request.getAmount();  // => amount = request.getAmount()
 
        return "Created: " + donor + " - $" + amount;  // => Returns result
        // => Serialized to JSON response
    }
}

import org.springframework.web.bind.annotation.*
 
data class DonationRequest(
# => Defines DonationRequest
    val donor: String,
    val amount: Double
)
 
@RestController  // => Combines @Controller + @ResponseBody
                 // => All methods return response body
@RequestMapping("/api")
# => Maps HTTP requests to this controller
class DonationApiController {  # => Defines DonationApiController class
    @PostMapping("/donations")
    # => Handles HTTP POST requests
    fun create(@RequestBody request: DonationRequest): String {
    # => Function create executes
        // => @RequestBody deserializes JSON to object
        // => Content-Type: application/json expected
 
        return "Created: ${request.donor} - $${request.amount}"  # => Returns result
        // => Serialized to JSON response
    }  # => End of create
}