Dependency Injection và Autowiring

03-dependency-injection/
  pom.xml
  src/main/java/dev/canhdominich/spring/di/
    PaymentService.java, PaypalPayment.java, StripePayment.java   interface và hai cài đặt
    InjectionStylesDemo.java     ba kiểu tiêm, trong và ngoài container
    ResolutionDemo.java          hai ứng viên, @Qualifier, @Primary
    OptionalDemo.java            phụ thuộc tùy chọn khi không có bean
    CollectionDemo.java          tiêm List và Map, thứ tự @Order
    ValueDemo.java               @Value, giá trị mặc định, thiếu giá trị
  src/main/resources/
    app.properties               hai thuộc tính cho @Value

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>dev.canhdominich.javabackend</groupId>
    <artifactId>spring-dependency-injection</artifactId>
    <version>1.0.0</version>
    <name>Spring Core - Dependency Injection</name>

    <properties>
        <maven.compiler.release>17</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <main.class>dev.canhdominich.spring.di.InjectionStylesDemo</main.class>
        <spring.version>7.0.9</spring.version>
        <junit.version>6.0.3</junit.version>
        <assertj.version>3.27.7</assertj.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>jakarta.annotation</groupId>
            <artifactId>jakarta.annotation-api</artifactId>
            <version>3.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.assertj</groupId>
            <artifactId>assertj-core</artifactId>
            <version>${assertj.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.5.6</version>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.6.3</version>
                <configuration>
                    <executable>java</executable>
                    <arguments>
                        <argument>-classpath</argument>
                        <classpath/>
                        <argument>${main.class}</argument>
                    </arguments>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

package dev.canhdominich.spring.di;

public interface PaymentService {

    String name();
}

package dev.canhdominich.spring.di;

public class PaypalPayment implements PaymentService {

    @Override
    public String name() {
        return "paypal";
    }
}

package dev.canhdominich.spring.di;

public class StripePayment implements PaymentService {

    @Override
    public String name() {
        return "stripe";
    }
}

package dev.canhdominich.spring.di;

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;

public class InjectionStylesDemo {

    public static void main(String[] args) {
        run();
    }

    static class ConstructorOrder {

        private final PaymentService payment;

        ConstructorOrder(PaymentService payment) {
            this.payment = payment;
        }

        String place() {
            return payment.name();
        }
    }

    static class SetterOrder {

        private PaymentService payment;

        @Autowired
        void setPayment(PaymentService payment) {
            this.payment = payment;
        }

        String place() {
            return payment.name();
        }
    }

    static class FieldOrder {

        @Autowired
        private PaymentService payment;

        String place() {
            return payment.name();
        }
    }

    @Configuration
    static class StylesConfig {

        @Bean
        PaymentService payment() {
            return new PaypalPayment();
        }

        @Bean
        ConstructorOrder constructorOrder(PaymentService payment) {
            return new ConstructorOrder(payment);
        }

        @Bean
        SetterOrder setterOrder() {
            return new SetterOrder();
        }

        @Bean
        FieldOrder fieldOrder() {
            return new FieldOrder();
        }
    }

    public static String[] run() {
        String[] results = new String[5];
        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(StylesConfig.class)) {
            results[0] = context.getBean(ConstructorOrder.class).place();
            results[1] = context.getBean(SetterOrder.class).place();
            results[2] = context.getBean(FieldOrder.class).place();
        }
        System.out.println("inside the container: constructor=" + results[0] + ", setter=" + results[1] + ", field=" + results[2]);
        results[3] = outsideTheContainer("setter", () -> new SetterOrder().place());
        results[4] = outsideTheContainer("field", () -> new FieldOrder().place());
        System.out.println("constructor injection outside a container: new ConstructorOrder() does not compile without a PaymentService");
        return results;
    }

    private static String outsideTheContainer(String style, java.util.function.Supplier<String> action) {
        try {
            return action.get();
        } catch (NullPointerException e) {
            System.out.println("outside the container, " + style + " injection: NullPointerException on first use");
            return "NullPointerException";
        }
    }
}

inside the container: constructor=paypal, setter=paypal, field=paypal
outside the container, setter injection: NullPointerException on first use
outside the container, field injection: NullPointerException on first use
constructor injection outside a container: new ConstructorOrder() does not compile without a PaymentService

package dev.canhdominich.spring.di;

import org.springframework.beans.BeansException;
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;
import org.springframework.context.annotation.Primary;

public class ResolutionDemo {

    public static void main(String[] args) {
        ambiguous();
        withQualifier();
        withPrimary();
        qualifierBeatsPrimary();
    }

    static class Consumer {

        private final PaymentService payment;

        Consumer(PaymentService payment) {
            this.payment = payment;
        }

        String uses() {
            return payment.name();
        }
    }

    static class QualifiedConsumer {

        private final PaymentService payment;

        QualifiedConsumer(@Qualifier("stripe") PaymentService payment) {
            this.payment = payment;
        }

        String uses() {
            return payment.name();
        }
    }

    @Configuration
    static class TwoBeansConfig {

        @Bean
        PaymentService paypal() {
            return new PaypalPayment();
        }

        @Bean
        PaymentService stripe() {
            return new StripePayment();
        }

        @Bean
        Consumer consumer(PaymentService payment) {
            return new Consumer(payment);
        }
    }

    @Configuration
    static class QualifierConfig {

        @Bean
        PaymentService paypal() {
            return new PaypalPayment();
        }

        @Bean
        PaymentService stripe() {
            return new StripePayment();
        }

        @Bean
        QualifiedConsumer qualifiedConsumer(@Qualifier("stripe") PaymentService payment) {
            return new QualifiedConsumer(payment);
        }
    }

    @Configuration
    static class PrimaryConfig {

        @Bean
        @Primary
        PaymentService paypal() {
            return new PaypalPayment();
        }

        @Bean
        PaymentService stripe() {
            return new StripePayment();
        }

        @Bean
        Consumer consumer(PaymentService payment) {
            return new Consumer(payment);
        }

        @Bean
        QualifiedConsumer qualifiedConsumer(@Qualifier("stripe") PaymentService payment) {
            return new QualifiedConsumer(payment);
        }
    }

    static String ambiguous() {
        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TwoBeansConfig.class)) {
            return "started";
        } catch (BeansException e) {
            Throwable cause = e;
            while (cause.getCause() != null) {
                cause = cause.getCause();
            }
            String message = cause.getClass().getSimpleName() + ": " + cause.getMessage();
            System.out.println("two candidates, nothing to choose with: " + message);
            return message;
        }
    }

    static String withQualifier() {
        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(QualifierConfig.class)) {
            String uses = context.getBean(QualifiedConsumer.class).uses();
            System.out.println("@Qualifier(\"stripe\") selects: " + uses);
            return uses;
        }
    }

    static String withPrimary() {
        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(PrimaryConfig.class)) {
            String uses = context.getBean(Consumer.class).uses();
            System.out.println("@Primary on paypal, plain parameter selects: " + uses);
            return uses;
        }
    }

    static String qualifierBeatsPrimary() {
        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(PrimaryConfig.class)) {
            String uses = context.getBean(QualifiedConsumer.class).uses();
            System.out.println("@Primary on paypal and @Qualifier(\"stripe\") on the parameter selects: " + uses);
            return uses;
        }
    }
}

two candidates, nothing to choose with: NoUniqueBeanDefinitionException: No qualifying bean of type 'dev.canhdominich.spring.di.PaymentService' available: expected single matching bean but found 2: paypal,stripe
@Qualifier("stripe") selects: stripe
@Primary on paypal, plain parameter selects: paypal
@Primary on paypal and @Qualifier("stripe") on the parameter selects: stripe

package dev.canhdominich.spring.di;

import java.util.Optional;
import org.springframework.beans.factory.ObjectProvider;
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;

public class OptionalDemo {

    public static void main(String[] args) {
        run();
    }

    static class WithOptional {

        private final Optional<PaymentService> payment;

        WithOptional(Optional<PaymentService> payment) {
            this.payment = payment;
        }

        String describe() {
            return payment.map(PaymentService::name).orElse("none");
        }
    }

    static class WithProvider {

        private final ObjectProvider<PaymentService> payment;

        WithProvider(ObjectProvider<PaymentService> payment) {
            this.payment = payment;
        }

        String describe() {
            PaymentService found = payment.getIfAvailable();
            return found == null ? "none" : found.name();
        }
    }

    static class WithSetter {

        private PaymentService payment;

        @Autowired(required = false)
        void setPayment(PaymentService payment) {
            this.payment = payment;
        }

        String describe() {
            return payment == null ? "none" : payment.name();
        }
    }

    @Configuration
    static class NoPaymentConfig {

        @Bean
        WithOptional withOptional(Optional<PaymentService> payment) {
            return new WithOptional(payment);
        }

        @Bean
        WithProvider withProvider(ObjectProvider<PaymentService> payment) {
            return new WithProvider(payment);
        }

        @Bean
        WithSetter withSetter() {
            return new WithSetter();
        }
    }

    public static String[] run() {
        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(NoPaymentConfig.class)) {
            String[] results = {
                    context.getBean(WithOptional.class).describe(),
                    context.getBean(WithProvider.class).describe(),
                    context.getBean(WithSetter.class).describe()};
            System.out.println("no PaymentService bean at all: Optional=" + results[0] + ", ObjectProvider=" + results[1] + ", required=false setter=" + results[2]);
            return results;
        }
    }
}

no PaymentService bean at all: Optional=none, ObjectProvider=none, required=false setter=none

package dev.canhdominich.spring.di;

import java.util.List;
import java.util.Map;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;

public class CollectionDemo {

    public static void main(String[] args) {
        run();
    }

    static class AllPayments {

        private final List<PaymentService> ordered;
        private final Map<String, PaymentService> byName;

        AllPayments(List<PaymentService> ordered, Map<String, PaymentService> byName) {
            this.ordered = ordered;
            this.byName = byName;
        }

        List<String> orderedNames() {
            return ordered.stream().map(PaymentService::name).toList();
        }

        List<String> keys() {
            return byName.keySet().stream().sorted().toList();
        }
    }

    @Configuration
    static class CollectionConfig {

        @Bean
        @Order(2)
        PaymentService paypal() {
            return new PaypalPayment();
        }

        @Bean
        @Order(1)
        PaymentService stripe() {
            return new StripePayment();
        }

        @Bean
        AllPayments allPayments(List<PaymentService> ordered, Map<String, PaymentService> byName) {
            return new AllPayments(ordered, byName);
        }
    }

    public static List<List<String>> run() {
        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(CollectionConfig.class)) {
            AllPayments all = context.getBean(AllPayments.class);
            System.out.println("List<PaymentService> in @Order: " + all.orderedNames());
            System.out.println("Map<String, PaymentService> keys: " + all.keys());
            return List.of(all.orderedNames(), all.keys());
        }
    }
}

List<PaymentService> in @Order: [stripe, paypal]
Map<String, PaymentService> keys: [paypal, stripe]

app.name=Course Platform
app.owner=Carnell

package dev.canhdominich.spring.di;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;

public class ValueDemo {

    public static void main(String[] args) {
        run();
        missing();
        strict();
    }

    static class Settings {

        @Value("${app.name}")
        String name;

        @Value("${app.max-size:100}")
        int maxSize;

        @Value("${app.owner}")
        String owner;
    }

    static class BrokenSettings {

        @Value("${app.missing}")
        String missing;
    }

    @Configuration
    @PropertySource("classpath:app.properties")
    static class SettingsConfig {

        @Bean
        Settings settings() {
            return new Settings();
        }
    }

    @Configuration
    @PropertySource("classpath:app.properties")
    static class BrokenConfig {

        @Bean
        BrokenSettings brokenSettings() {
            return new BrokenSettings();
        }
    }

    public static String run() {
        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SettingsConfig.class)) {
            Settings settings = context.getBean(Settings.class);
            String line = "name=" + settings.name + ", owner=" + settings.owner + ", maxSize=" + settings.maxSize;
            System.out.println(line);
            return line;
        }
    }

    public static String missing() {
        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BrokenConfig.class)) {
            String value = context.getBean(BrokenSettings.class).missing;
            System.out.println("placeholder without a value and without a default: context started, field = \"" + value + "\"");
            return value;
        } catch (BeansException e) {
            Throwable cause = e;
            while (cause.getCause() != null) {
                cause = cause.getCause();
            }
            String message = cause.getClass().getSimpleName() + ": " + cause.getMessage();
            System.out.println("placeholder without a value and without a default: " + message);
            return message;
        }
    }

    @Configuration
    @PropertySource("classpath:app.properties")
    static class StrictConfig {

        @Bean
        static PropertySourcesPlaceholderConfigurer placeholders() {
            return new PropertySourcesPlaceholderConfigurer();
        }

        @Bean
        BrokenSettings brokenSettings() {
            return new BrokenSettings();
        }
    }

    public static String strict() {
        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(StrictConfig.class)) {
            return "started, field = " + context.getBean(BrokenSettings.class).missing;
        } catch (BeansException e) {
            Throwable cause = e;
            while (cause.getCause() != null) {
                cause = cause.getCause();
            }
            String message = cause.getClass().getSimpleName() + ": " + cause.getMessage();
            System.out.println("with PropertySourcesPlaceholderConfigurer: " + message);
            return message;
        }
    }
}

name=Course Platform, owner=Carnell, maxSize=100
placeholder without a value and without a default: context started, field = "${app.missing}"
with PropertySourcesPlaceholderConfigurer: PlaceholderResolutionException: Could not resolve placeholder 'app.missing' in value "${app.missing}"