Beginner

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
// => Annotation-based Spring container implementation
// => Reads @Configuration classes to build application context
import org.springframework.context.annotation.Configuration;
// => Annotation marking configuration classes
// => Spring processes these to discover bean definitions
 
@Configuration  // => Marks this as Spring configuration class
                // => Spring scans for @Bean methods here
                // => Container processes this during initialization
class AppConfig {
    // => Empty config for now, just bootstrapping Spring
    // => No beans defined yet (will add in later examples)
}
 
public class Example01 {  // => Main application entry point
                          // => Demonstrates minimal Spring context creation
    public static void main(String[] args) {  // => Application starts here
        // => Creates Spring IoC container from Java config
        // => Scans AppConfig class for bean definitions
        AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(AppConfig.class);
        // => context is now initialized, ready to manage beans
        // => Container has processed @Configuration and registered definitions
 
        System.out.println("Spring Context ID: " + context.getId());
        // => Prints unique context identifier
        // => Output: Spring Context ID: org.springframework.context.annotation.AnnotationConfigApplicationContext@5fd0d5ae
 
        context.close();  // => Releases resources, calls bean destruction callbacks
                          // => Shuts down container gracefully
                          // => Triggers @PreDestroy methods if any beans defined
    }
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext
// => Annotation-based Spring container implementation
// => Reads @Configuration classes to build application context
import org.springframework.context.annotation.Configuration
// => Annotation marking configuration classes
// => Spring processes these to discover bean definitions
 
@Configuration  // => Marks this as Spring configuration class
                // => Spring scans for @Bean methods here
                // => Container processes this during initialization
class AppConfig {
    // => Empty config for now, just bootstrapping Spring
    // => No beans defined yet (will add in later examples)
}
 
fun main() {  // => Application entry point for Kotlin
              // => Demonstrates minimal Spring context creation
    // => Creates Spring IoC container from Kotlin config
    // => Scans AppConfig class for bean definitions (::class.java gets Java class)
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)
    // => context is now initialized, ready to manage beans
    // => Container has processed @Configuration and registered definitions
 
    println("Spring Context ID: ${context.id}")
    // => Prints unique context identifier
    // => Output: Spring Context ID: org.springframework.context.annotation.AnnotationConfigApplicationContext@5fd0d5ae
 
    context.close()  // => Releases resources, calls bean destruction callbacks
                     // => Shuts down container gracefully
                     // => Triggers @PreDestroy methods if any beans defined
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
// => Annotation-based Spring container implementation
import org.springframework.context.annotation.Bean;
// => Annotation marking factory methods for bean creation
import org.springframework.context.annotation.Configuration;
// => Annotation marking configuration classes
 
class ZakatCalculator {  // => Simple POJO for Zakat calculations
                          // => Will be managed by Spring as a bean
    public double calculateZakat(double wealth) {  // => Public method for calculation
        return wealth * 0.025;  // => 2.5% of wealth (Zakat rate)
                                 // => Result: wealth multiplied by 0.025
    }
}
 
@Configuration  // => Marks this as Spring configuration class
                // => Spring scans for @Bean methods here
class AppConfig {
    @Bean  // => Tells Spring to manage this object as a bean
           // => Bean name defaults to method name: "zakatCalculator"
           // => Spring calls this method during container initialization
    public ZakatCalculator zakatCalculator() {  // => Factory method for ZakatCalculator bean
        return new ZakatCalculator();  // => Creates new ZakatCalculator instance
        // => Spring stores bean in container, reused for subsequent requests (singleton)
        // => Returns reference to bean for dependency injection
    }
}
 
public class Example02 {  // => Main application entry point
                          // => Demonstrates bean definition and retrieval
    public static void main(String[] args) {  // => Application starts here
        AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(AppConfig.class);
        // => Context initialized, Spring processes @Configuration
        // => zakatCalculator bean created and stored in container
 
        ZakatCalculator calc = context.getBean(ZakatCalculator.class);
        // => Retrieves bean by type (ZakatCalculator.class)
        // => calc references the singleton instance from container
        // => Same instance returned for all getBean(ZakatCalculator.class) calls
 
        double zakat = calc.calculateZakat(100000);  // => Calculates 2.5% of 100000
                                                       // => zakat is 2500.0
        System.out.println("Zakat: " + zakat);       // => Prints result
                                                      // => Output: Zakat: 2500.0
 
        context.close();  // => Releases resources, destroys beans
                          // => Shuts down Spring container
    }
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext
// => Annotation-based Spring container implementation
import org.springframework.context.annotation.Bean
// => Annotation marking factory methods for bean creation
import org.springframework.context.annotation.Configuration
// => Annotation marking configuration classes
 
class ZakatCalculator {  // => Simple Kotlin class for Zakat calculations
                          // => Will be managed by Spring as a bean
    fun calculateZakat(wealth: Double): Double {  // => Function for calculation
        return wealth * 0.025  // => 2.5% of wealth (Zakat rate)
                                // => Result: wealth multiplied by 0.025
    }
}
 
@Configuration  // => Marks this as Spring configuration class
                // => Spring scans for @Bean methods here
class AppConfig {
    @Bean  // => Tells Spring to manage this object as a bean
           // => Bean name defaults to method name: "zakatCalculator"
           // => Spring calls this method during container initialization
    fun zakatCalculator(): ZakatCalculator {  // => Factory method for ZakatCalculator bean
        return ZakatCalculator()  // => Creates new ZakatCalculator instance
        // => Spring stores bean in container, reused for subsequent requests (singleton)
        // => Returns reference to bean for dependency injection
    }
}
 
fun main() {  // => Application entry point for Kotlin
              // => Demonstrates bean definition and retrieval
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)
    // => Context initialized, Spring processes @Configuration
    // => zakatCalculator bean created and stored in container (::class.java gets Java class)
 
    val calc = context.getBean(ZakatCalculator::class.java)
    // => Retrieves bean by type (ZakatCalculator::class.java)
    // => calc references the singleton instance from container
    // => Same instance returned for all getBean calls with this type
 
    val zakat = calc.calculateZakat(100000.0)  // => Calculates 2.5% of 100000.0
                                                 // => zakat is 2500.0
    println("Zakat: $zakat")                    // => Prints result
                                                 // => Output: Zakat: 2500.0
 
    context.close()  // => Releases resources, destroys beans
                     // => Shuts down Spring container
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
class SadaqahRepository {  // => Data access layer for Sadaqah donations
    public void save(String donation) {  // => Method: save(...)
        System.out.println("Saved: " + donation);  // => Simulates database save
    }
}
 
class SadaqahService {  // => Business logic layer
    private final SadaqahRepository repository;  // => Dependency (immutable)
 
    // => Constructor injection - Spring injects dependency here
    public SadaqahService(SadaqahRepository repository) {
        this.repository = repository;  // => Assigns injected dependency
        // => Constructor called by Spring, not by you
    }  // => End of SadaqahService
 
    public void recordDonation(String donor, double amount) {  // => Method: recordDonation(...)
        String donation = donor + ": $" + amount;  // => donation = donor + ": $" + amount
        repository.save(donation);  // => Uses injected dependency
    }
}
 
@Configuration
// => Marks class as Spring bean factory
class AppConfig {  // => Defines AppConfig class
    @Bean
    // => Registers return value as Spring-managed bean
    public SadaqahRepository sadaqahRepository() {  // => Method: sadaqahRepository(...)
        return new SadaqahRepository();  // => Creates repository bean
    }
 
    @Bean
    // => Registers return value as Spring-managed bean
    // => Spring sees SadaqahService constructor needs SadaqahRepository
    // => Automatically finds and injects sadaqahRepository bean
    public SadaqahService sadaqahService(SadaqahRepository repository) {  // => Method: sadaqahService(...)
        return new SadaqahService(repository);  // => Spring passes dependency
        // => Method parameter resolved from container
    }
}
 
public class Example03 {  // => Defines Example03 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 repository bean first, then service bean
 
        SadaqahService service = context.getBean(SadaqahService.class);  // => Retrieves SadaqahService bean from container
            // => Retrieves SadaqahService bean from container
        service.recordDonation("Ahmad", 500.0);  // => Calls recordDonation(...)
        // => Output: Saved: Ahmad: $500.0
 
        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
 
class SadaqahRepository {  // => Data access layer for Sadaqah donations
    fun save(donation: String) {
        println("Saved: $donation")  // => Simulates database save
    }  # => End of save
}
 
// => Primary constructor with dependency parameter
class SadaqahService(private val repository: SadaqahRepository) {  # => Defines SadaqahService class
    // => Constructor injection - Spring injects dependency here
    // => 'val' makes dependency immutable
 
    fun recordDonation(donor: String, amount: Double) {
        val donation = "$donor: $$amount"  # => donation = "$donor: $$amount"
        repository.save(donation)  // => Uses injected dependency
    }  # => End of recordDonation
}
 
@Configuration
# => Marks class as Spring bean factory
class AppConfig {  # => Defines AppConfig class
    @Bean
    # => Registers return value as Spring-managed bean
    fun sadaqahRepository(): SadaqahRepository {
        return SadaqahRepository()  // => Creates repository bean
    }  # => End of sadaqahRepository
 
    @Bean
    # => Registers return value as Spring-managed bean
    // => Spring sees SadaqahService constructor needs SadaqahRepository
    // => Automatically finds and injects sadaqahRepository bean
    fun sadaqahService(repository: SadaqahRepository): SadaqahService {
        return SadaqahService(repository)  // => Spring passes dependency
        // => Method parameter resolved from container
    }  # => End of sadaqahService
}
 
fun main() {
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
    // => Spring creates repository bean first, then service bean
 
    val service = context.getBean(SadaqahService::class.java)  # => assigns service
    service.recordDonation("Ahmad", 500.0)  # => Calls recordDonation(...)
    // => Output: Saved: Ahmad: $500.0
 
    context.close()  # => Shuts down Spring container, releases resources
}  # => End of main

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
 
@Component  // => Marks class as Spring-managed component
            // => Spring automatically creates bean (no @Bean method needed)
class QardHassanCalculator {  // => Qard Hassan (interest-free loan) calculator
    public double calculateMonthlyPayment(double principal, int months) {  // => Method: calculateMonthlyPayment(...)
        return principal / months;  // => No interest, simple division
    }
}
 
@Configuration
// => Marks class as Spring bean factory
@ComponentScan  // => Tells Spring to scan current package for @Component classes
                // => Automatically discovers and registers beans
class AppConfig {  // => Defines AppConfig class
    // => No @Bean methods needed for @Component classes
}
 
public class Example04 {  // => Defines Example04 class
    public static void main(String[] args) {
        // => Application entry point - Spring context created here
        AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(AppConfig.class);
                // => Creates Spring IoC container, processes @Configuration
        // => @ComponentScan discovers QardHassanCalculator
        // => Bean created automatically with name "qardHassanCalculator"
 
        QardHassanCalculator calc = context.getBean(QardHassanCalculator.class);
            // => Retrieves QardHassanCalculator bean from container
        double payment = calc.calculateMonthlyPayment(12000, 12);  // => assigns payment
        System.out.println("Monthly Payment: " + payment);  // => Outputs to console
        // => Output: Monthly Payment: 1000.0
 
        context.close();  // => Shuts down Spring container, releases resources
    }
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
import org.springframework.stereotype.Component
 
@Component  // => Marks class as Spring-managed component
            // => Spring automatically creates bean (no @Bean method needed)
class QardHassanCalculator {  // => Qard Hassan (interest-free loan) calculator
    fun calculateMonthlyPayment(principal: Double, months: Int): Double {
        return principal / months  // => No interest, simple division
    }
}
 
@Configuration
# => Marks class as Spring bean factory
@ComponentScan  // => Tells Spring to scan current package for @Component classes
                // => Automatically discovers and registers beans
class AppConfig {  # => Defines AppConfig class
    // => No @Bean methods needed for @Component classes
}
 
fun main() {
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
    // => @ComponentScan discovers QardHassanCalculator
    // => Bean created automatically with name "qardHassanCalculator"
 
    val calc = context.getBean(QardHassanCalculator::class.java)  # => assigns calc
    val payment = calc.calculateMonthlyPayment(12000.0, 12)  # => assigns payment
    println("Monthly Payment: $payment")  # => Outputs to console
    // => Output: Monthly Payment: 1000.0
 
    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.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
             // => Semantically indicates database/storage interaction
class MurabahaRepository {  // => Defines MurabahaRepository class
    public void save(String contract) {  // => Method: save(...)
        System.out.println("Saved contract: " + contract);  // => Outputs to console
    }
}
 
@Service  // => Specialized @Component for business logic layer
          // => Semantically indicates service/business operations
class MurabahaService {  // => Defines MurabahaService class
    private final MurabahaRepository repository;  // => repository: MurabahaRepository field
 
    @Autowired  // => Tells Spring to inject dependency via constructor
                // => Optional in Spring 4.3+ if only one constructor
    public MurabahaService(MurabahaRepository repository) {
        this.repository = repository;  // => Injected by Spring
        // => Spring finds MurabahaRepository bean and passes it
    }
 
    public void createContract(String client, double amount) {  // => Method: createContract(...)
        String contract = "Murabaha for " + client + ": $" + amount;  // => assigns contract
        repository.save(contract);  // => Uses injected dependency
    }
}
 
@Configuration
// => Marks class as Spring bean factory
@ComponentScan  // => Discovers @Repository and @Service beans
class AppConfig {  // => Defines AppConfig class
}
 
public class Example05 {  // => Defines Example05 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 discovers repository and service beans
        // => Automatically wires repository into service
 
        MurabahaService service = context.getBean(MurabahaService.class);  // => Retrieves MurabahaService bean from container
            // => Retrieves MurabahaService bean from container
        service.createContract("Fatimah", 50000.0);  // => Calls createContract(...)
        // => Output: Saved contract: Murabaha for Fatimah: $50000.0
 
        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.ComponentScan
import org.springframework.context.annotation.Configuration
import org.springframework.stereotype.Repository
import org.springframework.stereotype.Service
 
@Repository  // => Specialized @Component for data access layer
             // => Semantically indicates database/storage interaction
class MurabahaRepository {  # => Defines MurabahaRepository class
    fun save(contract: String) {
        println("Saved contract: $contract")  # => Outputs to console
    }  # => End of save
}
 
@Service  // => Specialized @Component for business logic layer
          // => Semantically indicates service/business operations
// => Kotlin primary constructor - @Autowired automatic for single constructor
class MurabahaService @Autowired constructor(  # => Defines MurabahaService class
    private val repository: MurabahaRepository
    // => Spring finds MurabahaRepository bean and passes it
) {
    fun createContract(client: String, amount: Double) {
        val contract = "Murabaha for $client: $$amount"  # => assigns contract
        repository.save(contract)  // => Uses injected dependency
    }  # => End of createContract
 
@Configuration
# => Marks class as Spring bean factory
@ComponentScan  // => Discovers @Repository and @Service beans
class AppConfig  # => Defines AppConfig class
 
fun main() {
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
    // => Spring discovers repository and service beans
    // => Automatically wires repository into service
 
    val service = context.getBean(MurabahaService::class.java)  # => assigns service
    service.createContract("Fatimah", 50000.0)  # => Calls createContract(...)
    // => Output: Saved contract: Murabaha for Fatimah: $50000.0
 
    context.close()  # => Shuts down Spring container, releases resources
}  # => End of main

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
class Calculator {  // => Simple POJO for arithmetic operations
    public double add(double a, double b) {  // => Addition method
        return a + b;  // => Returns sum of two numbers
    }
}
 
@Configuration  // => Marks this as Spring configuration source
class AppConfig {  // => Defines AppConfig class
    @Bean(name = "primaryCalculator")  // => Custom bean name
                                         // => Overrides default "calculator"
                                         // => name attribute explicitly sets bean identifier
    public Calculator calculator() {  // => Method: calculator(...)
        return new Calculator();  // => Bean registered as "primaryCalculator"
                                   // => Spring stores with custom name, not method name
    }
 
    @Bean("backupCalculator")  // => Shorthand for name attribute
                                // => Equivalent to @Bean(name = "backupCalculator")
    public Calculator anotherCalculator() {  // => Method: anotherCalculator(...)
        return new Calculator();  // => Bean registered as "backupCalculator"
                                   // => Different instance from primaryCalculator
    }
}
 
public class Example06 {  // => Defines Example06 class
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(AppConfig.class);
                // => Creates Spring IoC container, processes @Configuration
        // => Spring initializes both calculator beans
 
        Calculator primary = context.getBean("primaryCalculator", Calculator.class);
            // => Retrieves bean from container
        // => Retrieves bean by custom name and type
        // => primary references the "primaryCalculator" bean
        System.out.println("5 + 3 = " + primary.add(5, 3));  // => Outputs to console
        // => Calls add method on retrieved bean
        // => Output: 5 + 3 = 8.0
 
        Calculator backup = context.getBean("backupCalculator", Calculator.class);  // => Retrieves bean from container
        // => Retrieves second bean by its custom name
        // => backup is separate instance from primary
        System.out.println("10 + 2 = " + backup.add(10, 2));  // => Outputs to console
        // => Uses second calculator instance
        // => Output: 10 + 2 = 12.0
 
        context.close();  // => Cleanup resources
    }
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
 
class Calculator {  // => Simple Kotlin class for arithmetic
    fun add(a: Double, b: Double): Double = a + b  // => Expression body function
                                                     // => Returns sum directly
}
 
@Configuration  // => Marks this as Spring configuration source
class AppConfig {  # => Defines AppConfig class
    @Bean(name = ["primaryCalculator"])  // => Custom bean name (array syntax)
                                          // => Overrides default "calculator"
                                          // => Kotlin requires array syntax for single value
    fun calculator(): Calculator {
        return Calculator()  // => Bean registered as "primaryCalculator"
                              // => Spring stores with custom name, not method name
    }
 
    @Bean("backupCalculator")  // => Shorthand for name attribute
                                // => Equivalent to @Bean(name = ["backupCalculator"])
    fun anotherCalculator(): Calculator {
        return Calculator()  // => Bean registered as "backupCalculator"
                              // => Different instance from primaryCalculator
    }
}
 
fun main() {
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
    // => Spring initializes both calculator beans
 
    val primary = context.getBean("primaryCalculator", Calculator::class.java)  # => assigns primary
    // => Retrieves bean by custom name and type
    // => primary references the "primaryCalculator" bean
    println("5 + 3 = ${primary.add(5.0, 3.0)}")  # => Outputs to console
    // => Calls add method on retrieved bean
    // => Output: 5 + 3 = 8.0
 
    val backup = context.getBean("backupCalculator", Calculator::class.java)  # => assigns backup
    // => Retrieves second bean by its custom name
    // => backup is separate instance from primary
    println("10 + 2 = ${backup.add(10.0, 2.0)}")  # => Outputs to console
    // => Uses second calculator instance
    // => Output: 10 + 2 = 12.0
 
    context.close()  // => Cleanup resources
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
class ZakatCalculator {  // => Zakat calculation service
    public double calculate(double wealth) {  // => Calculates 2.5% zakat
        return wealth * 0.025;  // => Standard zakat rate for cash/gold
    }
}
 
@Configuration  // => Spring configuration class
class AppConfig {  // => Defines AppConfig class
    @Bean(name = {"zakatCalc", "zakatCalculator", "zakahService"})
    // => Defines three aliases for same bean
    // => All names reference the SAME instance (singleton)
    // => Primary name is first: "zakatCalc"
    public ZakatCalculator calculator() {  // => Method: calculator(...)
        return new ZakatCalculator();  // => Single bean, multiple names
                                         // => Only one instance created
    }
}
 
public class Example07 {  // => Defines Example07 class
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(AppConfig.class);
                // => Creates Spring IoC container, processes @Configuration
        // => Spring creates one ZakatCalculator bean with three names
 
        ZakatCalculator calc1 = context.getBean("zakatCalc", ZakatCalculator.class);
            // => Retrieves bean from container
        // => Retrieves via first alias
        ZakatCalculator calc2 = context.getBean("zakatCalculator", ZakatCalculator.class);
            // => Retrieves bean from container
        // => Retrieves via second alias
        ZakatCalculator calc3 = context.getBean("zakahService", ZakatCalculator.class);
            // => Retrieves bean from container
        // => Retrieves via third alias
        // => All three retrieve the SAME bean instance
 
        System.out.println("Same instance? " + (calc1 == calc2 && calc2 == calc3));  // => Outputs to console
        // => Checks reference equality
        // => Output: Same instance? true
 
        context.close();  // => Cleanup resources
    }
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
 
class ZakatCalculator {  // => Zakat calculation service
    fun calculate(wealth: Double): Double = wealth * 0.025  // => Calculates 2.5% zakat
                                                             // => Standard rate for cash/gold
}
 
@Configuration  // => Spring configuration class
class AppConfig {  # => Defines AppConfig class
    @Bean(name = ["zakatCalc", "zakatCalculator", "zakahService"])
    // => Defines three aliases for same bean
    // => All names reference the SAME instance (singleton)
    // => Primary name is first: "zakatCalc"
    fun calculator(): ZakatCalculator {
        return ZakatCalculator()  // => Single bean, multiple names
                                   // => Only one instance created
    }
}
 
fun main() {
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
    // => Spring creates one ZakatCalculator bean with three names
 
    val calc1 = context.getBean("zakatCalc", ZakatCalculator::class.java)  # => assigns calc1
    // => Retrieves via first alias
    val calc2 = context.getBean("zakatCalculator", ZakatCalculator::class.java)  # => assigns calc2
    // => Retrieves via second alias
    val calc3 = context.getBean("zakahService", ZakatCalculator::class.java)  # => assigns calc3
    // => Retrieves via third alias
    // => All three retrieve the SAME bean instance
 
    println("Same instance? ${calc1 === calc2 && calc2 === calc3}")  # => Outputs to console
    // => Checks reference equality (=== in Kotlin)
    // => Output: Same instance? true
 
    context.close()  // => Cleanup resources
}

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;
import org.springframework.stereotype.Service;
 
@Component  // => Spring-managed component
class EmailService {  // => Email sending service
    public void send(String message) {  // => Sends email notification
        System.out.println("Email sent: " + message);  // => Simulates email delivery
    }
}
 
@Service  // => Business logic component
class NotificationService {  // => Notification coordination service
    private EmailService emailService;  // => Dependency (not final)
                                          // => Allows post-construction modification
 
    @Autowired  // => Spring calls setter after object construction
                // => Injects emailService bean via setter method
                // => Optional on single setter in Spring 4.3+
    public void setEmailService(EmailService emailService) {  // => Method: setEmailService(...)
        this.emailService = emailService;  // => Setter injection assigns dependency
        // => Allows changing dependency after construction (if needed)
        // => Less safe than constructor injection
    }
 
    public void notifyDonation(String donor) {  // => Business method
        emailService.send("Thank you, " + donor);  // => Uses injected dependency
                                                     // => Delegates to EmailService
    }
}
 
@Configuration  // => Spring configuration source
@ComponentScan  // => Scans for @Component, @Service beans
class AppConfig {  // => Defines AppConfig class
}
 
public class Example08 {  // => Defines Example08 class
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(AppConfig.class);
                // => Creates Spring IoC container, processes @Configuration
        // => Spring discovers EmailService and NotificationService beans
        // => Creates NotificationService first, then calls setEmailService
 
        NotificationService service = context.getBean(NotificationService.class);
            // => Retrieves NotificationService bean from container
        // => Retrieves fully-wired NotificationService bean
        service.notifyDonation("Ali");  // => Calls business method
        // => Output: Email sent: Thank you, Ali
 
        context.close();  // => Cleanup resources
    }
}

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
import org.springframework.stereotype.Service
 
@Component  // => Spring-managed component
class EmailService {  // => Email sending service
    fun send(message: String) {  // => Sends email notification
        println("Email sent: $message")  // => Simulates email delivery
    }
}
 
@Service  // => Business logic component
class NotificationService {  // => Notification coordination service
    private lateinit var emailService: EmailService  // => Late-init dependency
                                                      // => Not initialized in constructor
                                                      // => Set later via setter
 
    @Autowired  // => Spring calls setter after object construction
                // => Injects emailService bean via setter method
                // => Optional on single setter in Spring 4.3+
    fun setEmailService(emailService: EmailService) {
        this.emailService = emailService  // => Setter injection assigns dependency
        // => lateinit allows setting non-null var after construction
        // => Less safe than constructor injection
    }
 
    fun notifyDonation(donor: String) {  // => Business method
        emailService.send("Thank you, $donor")  // => Uses injected dependency
                                                 // => Delegates to EmailService
    }
}
 
@Configuration  // => Spring configuration source
@ComponentScan  // => Scans for @Component, @Service beans
class AppConfig  # => Defines AppConfig class
 
fun main() {
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
    // => Spring discovers EmailService and NotificationService beans
    // => Creates NotificationService first, then calls setEmailService
 
    val service = context.getBean(NotificationService::class.java)  # => assigns service
    // => Retrieves fully-wired NotificationService bean
    service.notifyDonation("Ali")  // => Calls business method
    // => Output: Email sent: Thank you, Ali
 
    context.close()  // => Cleanup resources
}

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;
import org.springframework.stereotype.Service;
 
@Component  // => Spring-managed component
class AuditLogger {  // => Audit logging service
    public void log(String action) {  // => Logs audit events
        System.out.println("AUDIT: " + action);  // => Writes to console
    }
}
 
@Service  // => Business logic component
class TransactionService {  // => Transaction processing service
    @Autowired  // => Spring injects directly into field via reflection
                // => No constructor or setter needed
                // => Happens after object construction
    private AuditLogger logger;  // => Field injection (simplest syntax)
                                  // => Cannot be final (reflection requirement)
 
    public void processTransaction(String type, double amount) {  // => Business method
        logger.log(type + " transaction: $" + amount);  // => Uses injected dependency
        // => Delegates to AuditLogger bean
    }
}
 
@Configuration  // => Spring configuration source
@ComponentScan  // => Scans for @Component, @Service beans
class AppConfig {  // => Defines AppConfig class
}
 
public class Example09 {  // => Defines Example09 class
    public static void main(String[] args) {
        // => Application entry point - Spring context created here
        AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(AppConfig.class);
                // => Creates Spring IoC container, processes @Configuration
        // => Spring discovers AuditLogger and TransactionService beans
        // => Creates beans, injects logger field via reflection
 
        TransactionService service = context.getBean(TransactionService.class);
            // => Retrieves TransactionService bean from container
        // => Retrieves fully-wired TransactionService
        service.processTransaction("Sadaqah", 200.0);  // => Calls business method
        // => Output: AUDIT: Sadaqah transaction: $200.0
 
        context.close();  // => Cleanup resources
    }
}

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
import org.springframework.stereotype.Service
 
@Component  // => Spring-managed component
class AuditLogger {  // => Audit logging service
    fun log(action: String) {  // => Logs audit events
        println("AUDIT: $action")  // => Writes to console
    }
}
 
@Service  // => Business logic component
class TransactionService {  // => Transaction processing service
    @Autowired  // => Spring injects directly into field via reflection
                // => No constructor or setter needed
                // => Happens after object construction
    private lateinit var logger: AuditLogger  // => Field injection with lateinit
                                               // => Cannot be val (reflection requirement)
                                               // => Must use var with lateinit
 
    fun processTransaction(type: String, amount: Double) {  // => Business method
        logger.log("$type transaction: $$amount")  // => Uses injected dependency
        // => Delegates to AuditLogger bean
    }
}
 
@Configuration  // => Spring configuration source
@ComponentScan  // => Scans for @Component, @Service beans
class AppConfig  # => Defines AppConfig class
 
fun main() {
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
    // => Spring discovers AuditLogger and TransactionService beans
    // => Creates beans, injects logger field via reflection
 
    val service = context.getBean(TransactionService::class.java)  # => assigns service
    // => Retrieves fully-wired TransactionService
    service.processTransaction("Sadaqah", 200.0)  // => Calls business method
    // => Output: AUDIT: Sadaqah transaction: $200.0
 
    context.close()  // => Cleanup resources
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
interface PaymentProcessor {  // => Common interface for payment types
    void process(double amount);  // => Process payment contract
}
 
class CashPayment implements PaymentProcessor {  // => Cash payment implementation
    public void process(double amount) {  // => Handles cash transactions
        System.out.println("Cash payment: $" + amount);  // => Simulates cash processing
    }
}
 
class CardPayment implements PaymentProcessor {  // => Card payment implementation
    public void process(double amount) {  // => Handles card transactions
        System.out.println("Card payment: $" + amount);  // => Simulates card processing
    }
}
 
@Configuration  // => Spring configuration source
class AppConfig {  // => Defines AppConfig class
    @Bean  // => Defines PaymentProcessor bean
    @Qualifier("cash")  // => Tags this bean as "cash" processor
                         // => Allows disambiguation when injecting
    public PaymentProcessor cashProcessor() {  // => Method: cashProcessor(...)
        return new CashPayment();  // => Registered with "cash" qualifier
                                    // => Type: PaymentProcessor
    }
 
    @Bean  // => Defines second PaymentProcessor bean
    @Qualifier("card")  // => Tags this bean as "card" processor
                         // => Different qualifier from cash
    public PaymentProcessor cardProcessor() {  // => Method: cardProcessor(...)
        return new CardPayment();  // => Registered with "card" qualifier
                                    // => Same type, different qualifier
    }
 
    @Bean  // => Defines DonationService bean
    public DonationService donationService(  // => Method: donationService(...)
        @Qualifier("cash") PaymentProcessor processor
        // => Specifies which bean implementation to inject
        // => Specifies which bean to inject when multiple exist
        // => Injects cashProcessor, not cardProcessor
        // => Without @Qualifier would throw NoUniqueBeanDefinitionException
    ) {
        return new DonationService(processor);  // => Creates service with cash processor
    }
}
 
class DonationService {  // => Business service for donations
    private final PaymentProcessor processor;  // => Injected payment processor
 
    public DonationService(PaymentProcessor processor) {  // => Constructor injection
        this.processor = processor;  // => Assigns injected dependency
    }
 
    public void acceptDonation(double amount) {  // => Business method
        processor.process(amount);  // => Delegates to injected processor
                                     // => Uses cash processor from qualifier
    }
}
 
public class Example10 {  // => Defines Example10 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 payment processors and donation service
        // => Injects cash processor into service
 
        DonationService service = context.getBean(DonationService.class);  // => Retrieves DonationService bean from container
            // => Retrieves DonationService bean from container
        // => Retrieves wired DonationService bean
        service.acceptDonation(100.0);  // => Processes donation
        // => Output: Cash payment: $100.0
        // => Uses cashProcessor due to @Qualifier("cash")
 
        context.close();  // => Cleanup resources
    }
}

import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
 
interface PaymentProcessor {  // => Common interface for payment types
    fun process(amount: Double)  // => Process payment contract
}
 
class CashPayment : PaymentProcessor {  // => Cash payment implementation
    override fun process(amount: Double) {  // => Handles cash transactions
        println("Cash payment: $$amount")  // => Simulates cash processing
    }
}
 
class CardPayment : PaymentProcessor {  // => Card payment implementation
    override fun process(amount: Double) {  // => Handles card transactions
        println("Card payment: $$amount")  // => Simulates card processing
    }
}
 
@Configuration  // => Spring configuration source
class AppConfig {  # => Defines AppConfig class
    @Bean  // => Defines PaymentProcessor bean
    @Qualifier("cash")  // => Tags this bean as "cash" processor
                         // => Allows disambiguation when injecting
    fun cashProcessor(): PaymentProcessor {
        return CashPayment()  // => Registered with "cash" qualifier
                               // => Type: PaymentProcessor
    }  # => End of cashProcessor
 
    @Bean  // => Defines second PaymentProcessor bean
    @Qualifier("card")  // => Tags this bean as "card" processor
                         // => Different qualifier from cash
    fun cardProcessor(): PaymentProcessor {
        return CardPayment()  // => Registered with "card" qualifier
                               // => Same type, different qualifier
    }  # => End of cardProcessor
 
    @Bean  // => Defines DonationService bean
    fun donationService(
        @Qualifier("cash") processor: PaymentProcessor
        # => Specifies which bean implementation to inject
        // => Specifies which bean to inject when multiple exist
        // => Injects cashProcessor, not cardProcessor
        // => Without @Qualifier would throw NoUniqueBeanDefinitionException
    ): DonationService {
        return DonationService(processor)  // => Creates service with cash processor
}
 
class DonationService(private val processor: PaymentProcessor) {  // => Business service
                                                                    // => Constructor injection
    fun acceptDonation(amount: Double) {  // => Business method
        processor.process(amount)  // => Delegates to injected processor
                                    // => Uses cash processor from qualifier
    }
}
 
fun main() {
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
    // => Spring creates both payment processors and donation service
    // => Injects cash processor into service
 
    val service = context.getBean(DonationService::class.java)  # => assigns service
    // => Retrieves wired DonationService bean
    service.acceptDonation(100.0)  // => Processes donation
    // => Output: Cash payment: $100.0
    // => Uses cashProcessor due to @Qualifier("cash")
 
    context.close()  // => Cleanup resources
}  # => End of main

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
class Counter {  // => Defines Counter class
    private int count = 0;  // => Mutable state
 
    public void increment() {  // => Method: increment(...)
        count++;  // => Modifies state
    }
 
    public int getCount() {  // => Method: getCount(...)
        return count;  // => Returns count
    }
}
 
@Configuration  // => Code executes here
// => Marks class as Spring bean factory
class AppConfig {  // => Defines AppConfig class
    @Bean  // => Default scope is singleton
           // => Only ONE instance created per container
    public Counter counter() {  // => Method: counter(...)
        return new Counter();  // => Called once during context initialization
    }
}
 
public class Example11 {  // => Defines Example11 class
    public static void main(String[] args) {  // => Field: void
        // => 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
 
        Counter c1 = context.getBean(Counter.class);  // => Retrieves Counter bean from container
        Counter c2 = context.getBean(Counter.class);  // => Retrieves Counter bean from container
        // => Both reference the SAME instance
 
        c1.increment();  // => Modifies shared instance, count = 1
        c1.increment();  // => count = 2
 
        System.out.println("c1 count: " + c1.getCount());  // => Output: c1 count: 2
        System.out.println("c2 count: " + c2.getCount());  // => Output: c2 count: 2
        System.out.println("Same? " + (c1 == c2));         // => Output: Same? true
 
        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
 
class Counter {  # => Defines Counter class
    private var count = 0  // => Mutable state
 
    fun increment() {
    # => Function increment executes
        count++  // => Modifies state
    }  # => End of increment
 
    fun getCount(): Int = count
    # => Function getCount executes
}
 
@Configuration
# => Marks class as Spring bean factory
class AppConfig {  # => Defines AppConfig class
    @Bean  // => Default scope is singleton
           // => Only ONE instance created per container
    fun counter(): Counter {
    # => Function counter executes
        return Counter()  // => Called once during context initialization
    }  # => End of counter
}
 
fun main() {
# => Function main executes
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
 
    val c1 = context.getBean(Counter::class.java)  # => assigns c1
    val c2 = context.getBean(Counter::class.java)  # => assigns c2
    // => Both reference the SAME instance
 
    c1.increment()  // => Modifies shared instance, count = 1
    c1.increment()  // => count = 2
 
    println("c1 count: ${c1.getCount()}")  // => Output: c1 count: 2
    println("c2 count: ${c2.getCount()}")  // => Output: c2 count: 2
    println("Same? ${c1 === c2}")           // => Output: Same? true
 
    context.close()  # => Shuts down Spring container, releases resources
}  # => End of main

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
 
class Transaction {  // => Defines Transaction class
    private final String id;  // => id: String field
 
    public Transaction() {  // => Code executes here
    // => No-arg constructor for Transaction
        this.id = java.util.UUID.randomUUID().toString();
        // => Unique ID per instance
    }  // => End of Transaction
 
    public String getId() {  // => Method: getId(...)
        return id;  // => Returns id
    }
}
 
@Configuration
// => Marks class as Spring bean factory
class AppConfig {  // => Defines AppConfig class
    @Bean
    // => Registers return value as Spring-managed bean
    @Scope("prototype")  // => Creates NEW instance for each getBean() call
                          // => Not cached in container
    public Transaction transaction() {  // => Method: transaction(...)
        return new Transaction();  // => Called multiple times
    }
}
 
public class Example12 {  // => Defines Example12 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
 
        Transaction t1 = context.getBean(Transaction.class);  // => Retrieves Transaction bean from container
        Transaction t2 = context.getBean(Transaction.class);  // => Retrieves Transaction bean from container
        // => Two DIFFERENT instances created
 
        System.out.println("t1 ID: " + t1.getId());  // => Output: t1 ID: [uuid-1]
        System.out.println("t2 ID: " + t2.getId());  // => Output: t2 ID: [uuid-2]
        System.out.println("Same? " + (t1 == t2));   // => Output: Same? false
 
        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
import org.springframework.context.annotation.Scope
import java.util.UUID
 
class Transaction {  # => Defines Transaction class
    val id: String = UUID.randomUUID().toString()  # => id = UUID.randomUUID().toString()
    // => Unique ID per instance
}
 
@Configuration
# => Marks class as Spring bean factory
class AppConfig {  # => Defines AppConfig class
    @Bean
    # => Registers return value as Spring-managed bean
    @Scope("prototype")  // => Creates NEW instance for each getBean() call
                          // => Not cached in container
    fun transaction(): Transaction {
    # => Function transaction executes
        return Transaction()  // => Called multiple times
    }  # => End of transaction
}
 
fun main() {
# => Function main executes
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
 
    val t1 = context.getBean(Transaction::class.java)  # => assigns t1
    val t2 = context.getBean(Transaction::class.java)  # => assigns t2
    // => Two DIFFERENT instances created
 
    println("t1 ID: ${t1.id}")  // => Output: t1 ID: [uuid-1]
    println("t2 ID: ${t2.id}")  // => Output: t2 ID: [uuid-2]
    println("Same? ${t1 === t2}")  // => Output: Same? false
 
    context.close()  # => Shuts down Spring container, releases resources
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
 
@Component
// => Component scanning will discover and register this class
class DatabaseConnection {  // => Defines DatabaseConnection class
    private boolean connected = false;
 
    public DatabaseConnection() {
        System.out.println("1. Constructor called");  // => Outputs to console
        // => Constructor runs first
        // => Dependencies not yet injected
    }
 
    @PostConstruct  // => Called AFTER dependencies injected
                    // => Runs once per bean initialization
    public void initialize() {  // => Method: initialize(...)
        System.out.println("2. @PostConstruct called");  // => Outputs to console
        this.connected = true;  // => Setup logic after DI complete
        System.out.println("   Database connected: " + connected);  // => Outputs to console
    }
 
    public boolean isConnected() {  // => Method: isConnected(...)
        return connected;  // => Returns connected
    }
}
 
@Configuration
// => Marks class as Spring bean factory
@ComponentScan
// => Scans packages for @Component and stereotype annotations
class AppConfig {  // => Defines AppConfig class
}
 
public class Example13 {  // => Defines Example13 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
        // => Constructor → DI → @PostConstruct sequence
 
        DatabaseConnection db = context.getBean(DatabaseConnection.class);  // => Retrieves DatabaseConnection bean from container
        // => Assigns db
            // => Retrieves DatabaseConnection bean from container
        System.out.println("3. Bean ready, connected: " + db.isConnected());  // => Outputs to console
        // => Output: 3. Bean ready, connected: true
 
        context.close();  // => Shuts down Spring container, releases resources
    }
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
import org.springframework.stereotype.Component
import javax.annotation.PostConstruct
 
@Component
# => Component scanning will discover and register this class
class DatabaseConnection {  # => Defines DatabaseConnection class
    private var connected = false
 
    init {
        println("1. Constructor called")  # => Outputs to console
        // => Constructor runs first
        // => Dependencies not yet injected
 
    @PostConstruct  // => Called AFTER dependencies injected
                    // => Runs once per bean initialization
    fun initialize() {
    # => Function initialize executes
        println("2. @PostConstruct called")  # => Outputs to console
        this.connected = true  // => Setup logic after DI complete
        println("   Database connected: $connected")  # => Outputs to console
    }  # => End of initialize
 
    fun isConnected(): Boolean = connected
    # => Function isConnected executes
}
 
@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
    // => Constructor → DI → @PostConstruct sequence
 
    val db = context.getBean(DatabaseConnection::class.java)  # => assigns db
    println("3. Bean ready, connected: ${db.isConnected()}")  # => Outputs to console
    // => Output: 3. Bean ready, connected: true
 
    context.close()  # => Shuts down Spring container, releases resources
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import javax.annotation.PreDestroy;
 
@Component
// => Component scanning will discover and register this class
class FileWriter {  // => Defines FileWriter class
    public FileWriter() {
        System.out.println("FileWriter created");  // => Outputs to console
        // => Constructor called when bean created
    }  // => End of FileWriter
 
    public void write(String data) {  // => Method: write(...)
        System.out.println("Writing: " + data);  // => Outputs to console
    }
 
    @PreDestroy  // => Called BEFORE bean destroyed
                 // => Runs when context.close() called
    public void cleanup() {  // => Method: cleanup(...)
        System.out.println("@PreDestroy: Closing file handles");  // => Outputs to console
        // => Cleanup logic: close files, connections, release resources
    }
}
 
@Configuration
// => Marks class as Spring bean factory
@ComponentScan
// => Scans packages for @Component and stereotype annotations
class AppConfig {  // => Defines AppConfig class
}
 
public class Example14 {  // => Defines Example14 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
 
        FileWriter writer = context.getBean(FileWriter.class);  // => Retrieves FileWriter bean from container
        writer.write("Zakat record");  // => Calls write(...)
        // => Output: Writing: Zakat record
 
        System.out.println("Closing context...");  // => Outputs to console
        context.close();  // => Triggers @PreDestroy methods
        // => Output: @PreDestroy: Closing file handles
    }
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
import org.springframework.stereotype.Component
import javax.annotation.PreDestroy
 
@Component
# => Component scanning will discover and register this class
class FileWriter {  # => Defines FileWriter class
    init {
        println("FileWriter created")  # => Outputs to console
        // => Constructor called when bean created
 
    fun write(data: String) {
    # => Function write executes
        println("Writing: $data")  # => Outputs to console
    }  # => End of write
 
    @PreDestroy  // => Called BEFORE bean destroyed
                 // => Runs when context.close() called
    fun cleanup() {
    # => Function cleanup executes
        println("@PreDestroy: Closing file handles")  # => Outputs to console
        // => Cleanup logic: close files, connections, release resources
    }
}
 
@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 writer = context.getBean(FileWriter::class.java)  # => assigns writer
    writer.write("Zakat record")  # => Calls write(...)
    // => Output: Writing: Zakat record
 
    println("Closing context...")  # => Outputs to console
    context.close()  // => Triggers @PreDestroy methods
    // => Output: @PreDestroy: Closing file handles
}

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 org.springframework.context.annotation.Primary;
 
interface Notifier {  // => Common notification interface
    void notify(String message);  // => Notification contract method
}
 
class EmailNotifier implements Notifier {  // => Email notification implementation
    public void notify(String message) {  // => Sends email notification
        System.out.println("Email: " + message);  // => Simulates email delivery
    }
}
 
class SmsNotifier implements Notifier {  // => SMS notification implementation
    public void notify(String message) {  // => Sends SMS notification
        System.out.println("SMS: " + message);  // => Simulates SMS delivery
    }
}
 
@Configuration  // => Spring configuration source
class AppConfig {  // => Defines AppConfig class
    @Bean  // => Defines Notifier bean
    @Primary  // => Marks this as default bean for Notifier type
              // => Used when no @Qualifier specified
              // => Resolves ambiguity automatically
    public Notifier emailNotifier() {  // => Method: emailNotifier(...)
        return new EmailNotifier();  // => Primary (default) notifier
                                      // => Injected when type is Notifier and no qualifier
    }
 
    @Bean  // => Defines alternative Notifier bean
    public Notifier smsNotifier() {  // => Method: smsNotifier(...)
        return new SmsNotifier();  // => Alternative notifier (not primary)
                                    // => Must use @Qualifier to inject this
    }
 
    @Bean  // => Defines AlertService bean
    public AlertService alertService(Notifier notifier) {  // => Method: alertService(...)
        // => Parameter type is Notifier
        // => @Primary makes emailNotifier inject here automatically
        // => No @Qualifier needed (uses primary bean)
        return new AlertService(notifier);  // => Creates service with email notifier
    }
}
 
class AlertService {  // => Alert coordination service
    private final Notifier notifier;  // => Injected notifier dependency
 
    public AlertService(Notifier notifier) {  // => Constructor injection
        this.notifier = notifier;  // => Assigns injected notifier
    }
 
    public void sendAlert(String message) {  // => Business method
        notifier.notify(message);  // => Delegates to injected notifier
                                    // => Uses EmailNotifier (primary bean)
    }
}
 
public class Example15 {  // => Defines Example15 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 notifiers and alert service
        // => Injects emailNotifier (primary) into alertService
 
        AlertService service = context.getBean(AlertService.class);  // => Retrieves AlertService bean from container
        // => Retrieves wired AlertService bean
        service.sendAlert("Donation received");  // => Sends alert
        // => Output: Email: Donation received
        // => Uses emailNotifier (marked @Primary)
 
        context.close();  // => Cleanup resources
    }
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Primary
 
interface Notifier {  // => Common notification interface
    fun notify(message: String)  // => Notification contract method
}
 
class EmailNotifier : Notifier {  // => Email notification implementation
    override fun notify(message: String) {  // => Sends email notification
        println("Email: $message")  // => Simulates email delivery
    }
}
 
class SmsNotifier : Notifier {  // => SMS notification implementation
    override fun notify(message: String) {  // => Sends SMS notification
        println("SMS: $message")  // => Simulates SMS delivery
    }
}
 
@Configuration  // => Spring configuration source
class AppConfig {  # => Defines AppConfig class
    @Bean  // => Defines Notifier bean
    @Primary  // => Marks this as default bean for Notifier type
              // => Used when no @Qualifier specified
              // => Resolves ambiguity automatically
    fun emailNotifier(): Notifier {
        return EmailNotifier()  // => Primary (default) notifier
                                 // => Injected when type is Notifier and no qualifier
    }  # => End of emailNotifier
 
    @Bean  // => Defines alternative Notifier bean
    fun smsNotifier(): Notifier {
        return SmsNotifier()  // => Alternative notifier (not primary)
                               // => Must use @Qualifier to inject this
    }  # => End of smsNotifier
 
    @Bean  // => Defines AlertService bean
    fun alertService(notifier: Notifier): AlertService {
        // => Parameter type is Notifier
        // => @Primary makes emailNotifier inject here automatically
        // => No @Qualifier needed (uses primary bean)
        return AlertService(notifier)  // => Creates service with email notifier
    }
}
 
class AlertService(private val notifier: Notifier) {  // => Alert coordination service
                                                        // => Constructor injection
    fun sendAlert(message: String) {  // => Business method
        notifier.notify(message)  // => Delegates to injected notifier
                                   // => Uses EmailNotifier (primary bean)
    }
}
 
fun main() {
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
    // => Spring creates both notifiers and alert service
    // => Injects emailNotifier (primary) into alertService
 
    val service = context.getBean(AlertService::class.java)  # => assigns service
    // => Retrieves wired AlertService bean
    service.sendAlert("Donation received")  // => Sends alert
    // => Output: Email: Donation received
    // => Uses emailNotifier (marked @Primary)
 
    context.close()  // => Cleanup resources
}

import org.springframework.beans.factory.annotation.Value;
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 ZakatConfig {  // => Defines ZakatConfig class
    @Value("0.025")  // => Injects literal double value (2.5%)
                      // => Converted from String to double
    private double rate;  // => rate: double field
 
    @Value("85")  // => Injects literal int value (85 grams of gold nisab)
                   // => Converted from String to int
    private int nisabGrams;  // => nisabGrams: int field
 
    public double getRate() {  // => Method: getRate(...)
        return rate;  // => Returns rate
    }
 
    public int getNisabGrams() {  // => Method: getNisabGrams(...)
        return nisabGrams;  // => Returns nisabGrams
    }
}
 
@Configuration
// => Marks class as Spring bean factory
@ComponentScan
// => Scans packages for @Component and stereotype annotations
class AppConfig {  // => Defines AppConfig class
}
 
public class Example16 {  // => Defines Example16 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
 
        ZakatConfig config = context.getBean(ZakatConfig.class);  // => Retrieves ZakatConfig bean from container
        System.out.println("Rate: " + config.getRate());        // => Output: Rate: 0.025
        System.out.println("Nisab: " + config.getNisabGrams());  // => Output: Nisab: 85
 
        context.close();  // => Shuts down Spring container, releases resources
    }  // => End of static
}

import org.springframework.beans.factory.annotation.Value
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 ZakatConfig {  # => Defines ZakatConfig class
    @Value("0.025")  // => Injects literal double value (2.5%)
                      // => Converted from String to Double
    private var rate: Double = 0.0
 
    @Value("85")  // => Injects literal int value (85 grams of gold nisab)
                   // => Converted from String to Int
    private var nisabGrams: Int = 0
 
    fun getRate(): Double = rate
    # => Function getRate executes
    fun getNisabGrams(): Int = nisabGrams
    # => Function getNisabGrams executes
}
 
@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 config = context.getBean(ZakatConfig::class.java)  # => assigns config
    println("Rate: ${config.getRate()}")        // => Output: Rate: 0.025
    println("Nisab: ${config.getNisabGrams()}")  // => Output: Nisab: 85
 
    context.close()  # => Shuts down Spring container, releases resources
}  # => End of main

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
 
// Assume application.properties exists with:
// app.name=Zakat Management System
// app.version=1.0.0
// app.enabled=true
 
@Component
// => Component scanning will discover and register this class
class AppInfo {  // => Defines AppInfo class
    @Value("${app.name}")  // => Reads property "app.name" from properties file
                            // => Placeholder syntax: ${property.key}
    private String name;
 
    @Value("${app.version}")  // => Reads "app.version"
    private String version;
 
    @Value("${app.enabled}")  // => Reads boolean property
                               // => Converted from String "true" to boolean
    private boolean enabled;
 
    public void printInfo() {  // => Method: printInfo(...)
        System.out.println("App: " + name + " v" + version);  // => Outputs to console
        System.out.println("Enabled: " + enabled);  // => Outputs to console
    }
}
 
@Configuration
// => Marks class as Spring bean factory
@ComponentScan
@PropertySource("classpath:application.properties")
// => Loads properties file into Spring Environment
// => Makes properties available for ${...} placeholders
class AppConfig {  // => Defines AppConfig class
}
 
public class Example17 {  // => Defines Example17 class
    public static void main(String[] args) {
        // => Application entry point - Spring context created here
        AnnotationConfigApplicationContext context =
            // => Spring IoC container initialized
            new AnnotationConfigApplicationContext(AppConfig.class);
                // => Creates Spring IoC container, processes @Configuration
 
        AppInfo info = context.getBean(AppInfo.class);  // => Retrieves AppInfo bean from container
        info.printInfo();  // => Calls printInfo(...)
        // => Output: App: Zakat Management System v1.0.0
        // => Output: Enabled: true
 
        context.close();  // => Shuts down Spring container, releases resources
    }
}

import org.springframework.beans.factory.annotation.Value
import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.PropertySource
import org.springframework.stereotype.Component
 
// Assume application.properties exists with:
// app.name=Zakat Management System
// app.version=1.0.0
// app.enabled=true
 
@Component
# => Component scanning will discover and register this class
class AppInfo {  # => Defines AppInfo class
    @Value("\${app.name}")  // => Reads property "app.name" from properties file
                             // => Placeholder syntax: \${property.key}
                             // => Escaped in Kotlin strings
    private lateinit var name: String
 
    @Value("\${app.version}")  // => Reads "app.version"
    private lateinit var version: String
 
    @Value("\${app.enabled}")  // => Reads boolean property
                                // => Converted from String "true" to Boolean
    private var enabled: Boolean = false
 
    fun printInfo() {
        println("App: $name v$version")  # => Outputs to console
        println("Enabled: $enabled")  # => Outputs to console
    }
}
 
@Configuration
@ComponentScan
@PropertySource("classpath:application.properties")
// => Loads properties file into Spring Environment
// => Makes properties available for \${...} placeholders
class AppConfig  # => Defines AppConfig class
 
fun main() {
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
 
    val info = context.getBean(AppInfo::class.java)  # => assigns info
    info.printInfo()  # => Calls printInfo(...)
    // => Output: App: Zakat Management System v1.0.0
    // => Output: Enabled: true
 
    context.close()  # => Shuts down Spring container, releases resources
}

import org.springframework.beans.factory.annotation.Value;
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 ServiceConfig {  // => Defines ServiceConfig class
    @Value("${service.host:localhost}")
    // => Syntax: ${property:default}
    // => If "service.host" property missing, use "localhost"
    private String host;
 
    @Value("${service.port:8080}")
    // => If "service.port" missing, use 8080
    // => Converted from String "8080" to int
    private int port;
 
    @Value("${service.timeout:5000}")
    // => Default 5000ms if property missing
    private int timeout;
 
    public void printConfig() {  // => Method: printConfig(...)
        System.out.println("Host: " + host);  // => Outputs to console
        System.out.println("Port: " + port);  // => Outputs to console
        System.out.println("Timeout: " + timeout + "ms");  // => Outputs to console
    }
}
 
@Configuration
// => Marks class as Spring bean factory
@ComponentScan
class AppConfig {  // => Defines AppConfig class
    // => No @PropertySource - properties missing
    // => Defaults will be used
}
 
public class Example18 {  // => Defines Example18 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
 
        ServiceConfig config = context.getBean(ServiceConfig.class);  // => Retrieves ServiceConfig bean from container
        config.printConfig();  // => Calls printConfig(...)
        // => Output: Host: localhost
        // => Output: Port: 8080
        // => Output: Timeout: 5000ms
        // => All defaults used since properties missing
 
        context.close();  // => Shuts down Spring container, releases resources
    }
}

import org.springframework.beans.factory.annotation.Value
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 ServiceConfig {  # => Defines ServiceConfig class
    @Value("\${service.host:localhost}")
    # => Injects value from property source or SpEL expression
    // => Syntax: \${property:default}
    // => If "service.host" property missing, use "localhost"
    private lateinit var host: String
 
    @Value("\${service.port:8080}")
    # => Injects value from property source or SpEL expression
    // => If "service.port" missing, use 8080
    // => Converted from String "8080" to Int
    private var port: Int = 0
 
    @Value("\${service.timeout:5000}")
    // => Default 5000ms if property missing
    private var timeout: Int = 0
 
    fun printConfig() {
        println("Host: $host")  # => Outputs to console
        println("Port: $port")  # => Outputs to console
        println("Timeout: ${timeout}ms")  # => Outputs to console
    }
}
 
@Configuration
# => Marks class as Spring bean factory
@ComponentScan
class AppConfig {  # => Defines AppConfig class
    // => No @PropertySource - properties missing
    // => Defaults will be used
}
 
fun main() {
    val context = AnnotationConfigApplicationContext(AppConfig::class.java)  # => assigns context
 
    val config = context.getBean(ServiceConfig::class.java)  # => assigns config
    config.printConfig()  # => Calls printConfig(...)
    // => Output: Host: localhost
    // => Output: Port: 8080
    // => Output: Timeout: 5000ms
    // => All defaults used since properties missing
 
    context.close()  # => Shuts down Spring container, releases resources
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
 
interface DatabaseConnection {  // => Defines DatabaseConnection class
    void connect();  // => Code executes here
}
 
class DevDatabase implements DatabaseConnection {  // => Defines DevDatabase class
    public void connect() {  // => Method: connect(...)
        System.out.println("Connected to DEV database (H2 in-memory)");  // => Outputs to console
    }
}
 
class ProdDatabase implements DatabaseConnection {  // => Defines ProdDatabase class
    public void connect() {  // => Method: connect(...)
        System.out.println("Connected to PROD database (PostgreSQL)");  // => 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
    @Profile("dev")  // => Only active when "dev" profile active
                      // => Bean registered conditionally
    public DatabaseConnection devDatabase() {  // => Method: devDatabase(...)
        return new DevDatabase();  // => Created only in dev profile
    }
 
    @Bean
    // => Registers return value as Spring-managed bean
    @Profile("prod")  // => Only active when "prod" profile active
    public DatabaseConnection prodDatabase() {  // => Method: prodDatabase(...)
        return new ProdDatabase();  // => Created only in prod profile
    }
}
 
public class Example19 {  // => Defines Example19 class
    public static void main(String[] args) {
        // => Application entry point - Spring context created here
        AnnotationConfigApplicationContext context =
            // => Spring IoC container initialized
            new AnnotationConfigApplicationContext();  // => Creates Spring IoC container, processes @Configuration
 
        context.getEnvironment().setActiveProfiles("dev");  // => Calls getEnvironment(...)
        // => Activates "dev" profile
        // => Only @Profile("dev") beans registered
 
        context.register(AppConfig.class);  // => Calls register(...)
        context.refresh();  // => Calls refresh(...)
        // => Context initialized with dev profile
 
        DatabaseConnection db = context.getBean(DatabaseConnection.class);  // => Retrieves DatabaseConnection bean from container
            // => Retrieves DatabaseConnection bean from container
        db.connect();  // => Calls connect(...)
        // => Output: Connected to DEV database (H2 in-memory)
        // => Uses devDatabase bean
 
        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
import org.springframework.context.annotation.Profile
 
interface DatabaseConnection {  # => Defines DatabaseConnection class
    fun connect()
    # => Function connect executes
}
 
class DevDatabase : DatabaseConnection {  # => Defines DevDatabase class
    override fun connect() {
        println("Connected to DEV database (H2 in-memory)")  # => Outputs to console
    }  # => End of connect
}
 
class ProdDatabase : DatabaseConnection {  # => Defines ProdDatabase class
    override fun connect() {
        println("Connected to PROD database (PostgreSQL)")  # => Outputs to console
    }  # => End of connect
}
 
@Configuration
# => Marks class as Spring bean factory
class AppConfig {  # => Defines AppConfig class
    @Bean
    # => Registers return value as Spring-managed bean
    @Profile("dev")  // => Only active when "dev" profile active
                      // => Bean registered conditionally
    fun devDatabase(): DatabaseConnection {
    # => Function devDatabase executes
        return DevDatabase()  // => Created only in dev profile
    }  # => End of devDatabase
 
    @Bean
    # => Registers return value as Spring-managed bean
    @Profile("prod")  // => Only active when "prod" profile active
    fun prodDatabase(): DatabaseConnection {
    # => Function prodDatabase executes
        return ProdDatabase()  // => Created only in prod profile
    }  # => End of prodDatabase
}
 
fun main() {
# => Function main executes
    val context = AnnotationConfigApplicationContext()  # => assigns context
 
    context.environment.setActiveProfiles("dev")  # => Calls setActiveProfiles(...)
    // => Activates "dev" profile
    // => Only @Profile("dev") beans registered
 
    context.register(AppConfig::class.java)  # => Calls register(...)
    context.refresh()  # => Calls refresh(...)
    // => Context initialized with dev profile
 
    val db = context.getBean(DatabaseConnection::class.java)  # => assigns db
    db.connect()  # => Calls connect(...)
    // => Output: Connected to DEV database (H2 in-memory)
    // => Uses devDatabase bean
 
    context.close()  # => Shuts down Spring container, releases resources
}  # => End of main