Was sind die Einsatzszenarien von @Configuration in Java?

1. Kurze Einführung

@Configuration-Annotation kann für eine Klasse mit Anmerkungen versehen werden. Beim Starten von Spring wird die mit der @Configuration-Annotation versehene Klasse automatisch gescannt, im IOC-Container registriert und instanziiert Bean-Objekt.
Wenn die mit der @Configuration-Annotation annotierte Klasse eine Methode zum Erstellen eines bestimmten mit der @Bean-Annotation annotierten Klassenobjekts enthält, führt Spring auch automatisch die mit der @Bean-Annotation annotierte Methode aus und registriert die entsprechenden Bean-Definitionsinformationen im IOC-Container. und instanziieren.

2. Annotationsbeschreibung

@Konfigurationsannotation ist eine seit Spring 3.0 hinzugefügte Annotation, die es Spring ermöglicht, annotationsgesteuerte Entwicklung zu unterstützen. Sie wird hauptsächlich für Annotationen in Klassen verwendet. Wenn eine Klasse mit der Annotation @Configuration gekennzeichnet ist, bedeutet dies, dass es sich bei dieser Klasse um eine Spring-Konfigurationsklasse handelt. Die Annotation @Configuration kann die Datei applicationContext.xml von Spring ersetzen, und mit der Annotation @Configuration markierte Klassen können automatisch im IOC-Container registriert und instanziiert werden.

1. @Configuration-Quellcode

Details zum Quellcode finden Sie unter: org.springframework.context.annotation.Configuration.

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
 @AliasFor(annotation = Component.class)
 String value() default "";
 // Since: 5.2
 boolean proxyBeanMethods() default true;
 // Since: 6.0
 boolean enforceUniqueMethods() default true;
}

Die Bedeutung jedes Attributs in der @Configuration-Annotation ist wie folgt:

• Wert: Die ID der Bean, die im Spring IOC-Container gespeichert ist.

• proxyBeanMethods: Ab Spring 5.2 zur @Configuration-Annotation hinzugefügt und gibt an, ob die mit der @Configuration-Annotation annotierte Konfigurationsklasse als Proxy verwendet wird und ob sich das mit der @Bean-Annotation in der Konfigurationsklasse generierte Bean-Objekt in der befindet IOC-Container-Singleton-Objekt, der Wert ist wahr oder falsch. Wenn der Wert wahr ist, zeigt er den vollständigen (globalen) Modus an. In diesem Modus wird die mit der Annotation @Configuration versehene Konfigurationsklasse als Proxy verwendet. Das in den IOC-Container eingefügte Bean-Objekt ist der Singleton-Modus. Unabhängig davon, wie oft Sie eine mit der Annotation @Bean gekennzeichnete Methode aufrufen, wird dasselbe Bean-Objekt zurückgegeben. Wenn der Wert falsch ist, zeigt er den Lite-Modus (Lightweight-Modus) an. In diesem Modus wird die mit der @Configuration-Annotation versehene Konfigurationsklasse nicht per Proxy in den IOC-Container eingefügt Kein einziges Im Beispielmodus wird jedes Mal, wenn eine mit der @Bean-Annotation annotierte Methode aufgerufen wird, ein neues Bean-Objekt zurückgegeben. Der Standardwert ist wahr.

• enforceUniqueMethods: Ab Spring 6.0 zur @Configuration-Annotation hinzugefügt und gibt an, ob die mit der @Bean-Annotation annotierte Methode einen eindeutigen Methodennamen haben muss. Der Wert ist wahr oder falsch. Wenn der Wert wahr ist, bedeutet dies, dass mit @Bean-Annotationen annotierte Methoden eindeutige Methodennamen haben und diese Methodennamen sich nicht überschneiden. Wenn der Wert falsch ist, bedeutet dies, dass die mit der @Bean-Annotation annotierten Methodennamen nicht eindeutig sind und die Gefahr einer Überlappung besteht. Der Standardwert ist wahr.

Aus dem Quellcode der @Configuration-Annotation ist auch ersichtlich, dass die @Configuration-Annotation im Wesentlichen eine @Component-Annotation ist, sodass die mit der @Configuration-Annotation annotierte Konfigurationsklasse selbst auch im IOC-Container registriert wird . Gleichzeitig wird die Annotation @Configuration auch von der Annotation @ComponentScan gescannt.

2. @Configuration-Nutzungsszenarien

Beim Entwickeln einer Anwendung basierend auf Spring-Annotationen können Sie die @Configuration-Annotation einer bestimmten Klasse zuordnen. Wenn eine Klasse mit der Annotation @Configuration versehen ist, bedeutet dies, dass es sich bei der Klasse um eine Konfigurationsklasse handelt. Sie können die Annotation @Bean in dieser Klasse verwenden, um Bean-Objekte in den IOC-Container einzufügen @Resource-Anmerkungen zum Einfügen. Das erforderliche Bean-Objekt.

Hinweis: Wenn Sie eine Anwendung basierend auf dem Annotationsmodus von Spring entwickeln und die AnnotationConfigApplicationContext-Klasse zum Erstellen eines IOC-Containers verwenden, müssen Sie Folgendes beachten:

(1) Wenn Sie den Konstruktor der Klassentypvariablen aufrufen Parameter in der AnnotationConfigApplicationContext-Klasse. Um einen IOC-Container zu erstellen, bedeutet dies, dass das Klassenobjekt der mit der Annotation @Configuration versehenen Konfigurationsklasse übergeben wird, um den IOC-Container zu erstellen. Die Annotation @Configuration an der Konfigurationsklasse kann weggelassen werden.
Wenn die @Configuration-Annotation in der eingehenden Konfigurationsklasse weggelassen wird, wird jedes Mal, wenn eine mit der @Bean-Annotation in der Konfigurationsklasse annotierte Methode aufgerufen wird, ein anderes Bean-Instanzobjekt zurückgegeben.

Der Quellcode des Konstruktors, der Variablenparameter vom Typ „Klasse“ in der Klasse „AnnotationConfigApplicationContext“ übergibt, lautet wie folgt:

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    this();
    register(componentClasses);
    refresh();
}

(2) Wenn der Konstruktor, der Variablenparameter vom Typ „String“ in der Klasse „AnnotationConfigApplicationContext“ übergibt, aufgerufen wird, um einen IOC-Container zu erstellen Dies bedeutet, dass beim Eingeben des Paketnamens der Anwendung zum Erstellen eines IOC-Containers die in der Konfigurationsklasse markierte Annotation @Configuration nicht weggelassen werden kann.

Der Quellcode des Konstruktors, der Variablenparameter vom Typ String in der AnnotationConfigApplicationContext-Klasse übergibt, lautet wie folgt:

public AnnotationConfigApplicationContext(String... basePackages) {
    this();
    scan(basePackages);
    refresh();
}

3. Anwendungsfälle

1. Überprüfen Sie die Rolle des ProxyBeanMethods-Attributs.

Das ProxyBeanMethods-Attribut kann einen Wert annehmen von wahr oder falsch. Wenn der Wert wahr ist, wird unabhängig davon, wie oft die mit der @Bean-Annotation annotierte Methode in der mit der @Configuration-Annotation annotierten Klasse aufgerufen wird, dasselbe Bean-Objekt zurückgegeben. Wenn der Wert falsch ist, wird jedes Mal, wenn eine mit der Annotation @Bean annotierte Methode in einer mit der Annotation @Configuration annotierten Klasse aufgerufen wird, ein anderes Bean-Objekt zurückgegeben.

1.1 Stellen Sie sicher, dass der ProxyBeanMethods-Wert wahr ist.

(1) Erstellen Sie die Person-Klasse.

Die Person-Klasse wird hauptsächlich zum Registrieren im IOC-Container und zum Instanziieren von Objekten verwendet.

public class Person {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

(2) Erstellen Sie die Klasse „ConfigurationAnnotationConfig“

ConfigurationAnnotationConfig类的作用就是充当程序启动的配置类，会在ConfigurationAnnotationConfig类上标注@Configuration注解，说明ConfigurationAnnotationConfig类是Spring启动时的配置类。

@Configuration
public class ConfigurationAnnotationConfig {
    @Bean
    public Person person(){
        return new Person();
    }
}

可以看到，在ConfigurationAnnotationConfig类上标注了@Configuration注解，由于@Configuration注解中的proxyBeanMethods属性默认为true，所以在ConfigurationAnnotationConfig类上的@Configuration注解省略了proxyBeanMethods属性。

（3）创建ConfigurationAnnotationTest类

ConfigurationAnnotationTest类的作用就是整个案例程序的启动类，对整个案例程序进行测试。

public class ConfigurationAnnotationTest {

    private static final Logger LOGGER = LoggerFactory.getLogger(ConfigurationAnnotationTest.class);

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConfigurationAnnotationConfig.class);
        ConfigurationAnnotationConfig config = context.getBean(ConfigurationAnnotationConfig.class);
        Person person1 = config.person();
        Person person2 = config.person();
        LOGGER.info("person1 == person2 ===>> {}", (person1 == person2));
    }
}

可以看到，在ConfigurationAnnotationTest类的main()方法中，首先基于AnnotationConfigApplicationContext常见了IOC容器context，从context中获取了ConfigurationAnnotationConfig类的Bean实例对象config，接下来，调用两次config的person()方法分别赋值给Person类型的局部变量person1和person2，最后打印person1是否等于person2的日志。

（4）测试案例

运行ConfigurationAnnotationTest类的main()方法，输出的结果信息如下所示。

person1 是否等于 person2 ===>> true

通过输出的结果信息可以看出，person1是否等于person2输出的结果为true。说明当@Configuration注解中的proxyBeanMethods属性为true时，每次调用使用@Configuration注解标注的类中被@Bean注解标注的方法时，都会返回同一个Bean实例对象。

1.2 验证proxyBeanMethods取值为false的情况

验证@Configuration注解中的proxyBeanMethods属性为false的情况，与验证proxyBeanMethods属性为true的情况的案例程序基本一致，只是将ConfigurationAnnotationConfig类上标注的@Configuration注解的proxyBeanMethods属性设置为false，案例实现的具体步骤如下所示。

（1）修改proxyBeanMethods属性的值

@Configuration(proxyBeanMethods = false)
public class ConfigurationAnnotationConfig {
    @Bean
    public Person person(){
        return new Person();
    }
}

（2）测试案例
运行ConfigurationAnnotationTest类的main()方法，输出的结果信息如下所示。

person1 是否等于 person2 ===>> false

从输出的结果信息可以看出，person1是否等于person2输出的结果为false。说明当@Configuration注解中的proxyBeanMethods属性为false时，每次调用使用@Configuration注解标注的类中被@Bean注解标注的方法时，都会返回不同的Bean实例对象。

2. 传入配置类创建IOC容器

调用AnnotationConfigApplicationContext类的构造方法传入配置类的Class对象创建IOC容器时，可以省略配置类上的@Configuration注解，案例的具体实现步骤如下所示。

（1）删除@Configuration注解

public class ConfigurationAnnotationConfig {
    @Bean
    public Person person(){
        return new Person();
    }
}

（2）测试案例
运行ConfigurationAnnotationTest类的main()方法，输出的结果信息如下所示。

person1 是否等于 person2 ===>> false

从输出的结果信息可以看到，输出了person1是否等于person2的结果为false。说明调用AnnotationConfigApplicationContext类的构造方法传入配置类的Class对象创建IOC容器时，可以省略配置类上的@Configuration注解，此时每次调用配置类中被@Bean注解标注的方法时，都会返回不同的Bean实例对象。

3. 传入包名创建IOC容器

调用AnnotationConfigApplicationContext类的构造方法传入包名创建IOC容器时，不能省略配置类上的@Configuration注解，案例的具体实现步骤如下所示。

（1）修改测试类

修改ConfigurationAnnotationTest类的main()方法中，创建AnnotationConfigApplicationContext对象的代码，将调用传入Class对象的构造方法修改为调用传入String对象的方法，修改后的代码如下所示。

public class ConfigurationAnnotationTest {

    private static final Logger LOGGER = LoggerFactory.getLogger(ConfigurationAnnotationTest.class);

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.lwk.demo.spring.annocation.configuration.config");
        ConfigurationAnnotationConfig config = context.getBean(ConfigurationAnnotationConfig.class);
        Person person1 = config.person();
        Person person2 = config.person();
        LOGGER.info("person1 是否等于 person2 ===>> {}", (person1 == person2));
    }
}

（2）删除@Configuration注解

public class ConfigurationAnnotationConfig {
    @Bean
    public Person person(){
        return new Person();
    }
}

（3）测试案例

运行ConfigurationAnnotationTest类的main()方法，可以看到程序抛出了异常信息，如下所示。

Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'io.binghe.spring.annotation.chapter01.configuration.config.ConfigurationAnnotationConfig' available

从输出的结果信息可以看出，调用AnnotationConfigApplicationContext类的构造方法传入包名创建IOC容器时，不能省略配置类上的@Configuration注解，否则会抛出NoSuchBeanDefinitionException。

（4）添加@Configuration注解

@Configuration
public class ConfigurationAnnotationConfig {
    @Bean
    public Person person(){
        return new Person();
    }
}

（5）再次测试案例

再次运行ConfigurationAnnotationTest类的main()方法，输出的结果信息如下所示。

person1 是否等于 person2 ===>> true

Aus den Ausgabeergebnisinformationen können wir ersehen, dass das Ausgabeergebnis, ob Person1 gleich Person2 ist, wahr ist. Auch hier gilt: Wenn die Konstruktormethode der AnnotationConfigApplicationContext-Klasse aufgerufen und der Paketname übergeben wird, um einen IOC-Container zu erstellen, wird das @ verwendet. Konfigurationsanmerkungen zur Konfigurationsklasse können nicht weggelassen werden.

Das obige ist der detaillierte Inhalt vonWas sind die Einsatzszenarien von @Configuration in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!