Was ist der Umfang und Lebenszyklus von Beans in Java Spring?

1.Bean-Bereich

1.1 Modifizierter Bean-Fall

Grund: Der Geltungsbereich von Bean ist standardmäßig der Singleton-Modus, was bedeutet, dass jeder dasselbe Objekt verwendet! Als wir zuvor den Singleton-Modus kennengelernt haben, wussten wir alle, dass die Verwendung von Singletons die Leistung erheblich verbessern kann. Daher ist der Umfang von Beans in Spring standardmäßig auch der Singleton-Modus.

@Component
public class Users {

    @Bean
    public User user1(){
        User user = new User();
        user.setId(1);
        user.setName("Java");
        return user;
    }
}

@Component
public class Bean1 {

    @Autowired
    private User user;
    public User getUser(){
        System.out.println("Bean1对象未修改name之前 ： "+user);
        user.setName("C++");
        return user;
    }
}

@Component
public class Bean2 {
    @Autowired
    private User user;

    public User getUser(){
        return user;
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

        Bean1 bean1 = context.getBean("bean1",Bean1.class);
        System.out.println(bean1.getUser());
        Bean2 bean2 = context.getBean("bean2",Bean2.class);
        System.out.println(bean2.getUser());
    }
}

1.2 Warum den Singleton-Modus als Standardbereich verwenden?

• Erstellen Sie nur eine Kopie derselben Ressource, um Platz zu sparen. 🏜 🎜# Unter Geltungsbereich versteht man im Allgemeinen: Die Begrenzung des verfügbaren Variablenbereichs in einem Programm wird als Geltungsbereich bezeichnet, oder ein bestimmter Bereich im Quellcode, in dem Variablen definiert sind, wird als Geltungsbereich bezeichnet.

  ⽽Der Umfang von Bea bezieht sich auf ein bestimmtes Verhaltensmuster von Bean im gesamten Framework von Spring, wie z. B. Singleton Singleton-Bereich bedeutet
, dass Bean nur eine Kopie im gesamten Spring hat und diese global geteilt wird, wenn jemand anderes dies ändert Wert, was eine andere
• Person liest, ist der geänderte Wert.

Im Frühling wird der Umfang einer Bean als Verhaltensmodell bezeichnet, da aus Sicht von Spring das Singleton-Modell ein Verhalten ist, was bedeutet, dass die Bean im gesamten Frühling nur A Kopie kann existieren.

Bea的作⽤域是指Bean在 Spring整个框架中的某种⾏为模式，⽐如singleton单例作⽤域，就表
示Bean在整个Spring中只有⼀份，它是全局共享的，那么当其他⼈修改了这个值之后，那么另⼀个
⼈读取到的就是被修改的值。

在Spring中，bean 的作用域被称为是行为模式，因为在Spring看来，单例模式，就是一种行为，意味着在整个Spring中bean只能存在一份。

1.4 Bean的6种作用域

• singleton：单例作⽤域

• prototype：原型作⽤域（多例作⽤域）

• request：请求作⽤域

• session：会话作⽤域

• application：全局作⽤域

• websocket：HTTP WebSocket 作⽤域

后四种都是SpringMVC中限定使用的，因此现阶段我们只学前两个就行。

1.5 设置作用域

回到刚才的案例，Bean2希望获取到的bean对象是未被修改的，我们就可以将单例模式修改为多例模式。

使用@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

使用@Scope("prototype")

2.Spring执行流程和Bean的生命周期

ps

Singleton:

Prototyp:

• # 🎜🎜#

  Anfrage :
Request Domain
• session:

  Session Domain#🎜🎜 #

#🎜🎜 Nr.

Die letzten vier sind auf SpringMVC beschränkt, daher müssen wir zu diesem Zeitpunkt nur die ersten beiden lernen.

1.5 Bereich festlegen

• 
  
• Use @Scope("prototype ")
  #🎜🎜##🎜🎜#2. Spring-Ausführungsprozess und Bean-Lebenszyklus#🎜🎜##🎜🎜##🎜🎜##🎜🎜#ps : Wann Die Ausführung erreicht den Schritt des Zusammenstellens der Eigenschaften der Bean. Wenn die Attributinjektion gescannt wird, wird die Klasseninjektion zuerst gestoppt und der Attributinjektion wird Priorität eingeräumt, da das Attribut möglicherweise in späteren Methoden verwendet wird. #🎜🎜##🎜🎜#2.1 Bohnenlebenszyklus#🎜🎜##🎜🎜#Der sogenannte Lebenszyklus bezieht sich auf den gesamten Lebensprozess eines Objekts von der Geburt bis zur Zerstörung. Wir nennen diesen Prozess den Lebenszyklus eines Objekts . . #🎜🎜##🎜🎜##🎜🎜#Der Lebenszyklus einer Bean ist in die folgenden 5 Teile unterteilt: #🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#1 Bean (damit Bean Speicherplatz zuweist) #🎜🎜##🎜🎜##🎜🎜##🎜🎜#2. Eigenschaften festlegen (Bean-Injektion und Assemblierung) #🎜🎜##🎜🎜##🎜🎜##🎜🎜# 3.Bean-Initialisierung #🎜🎜##🎜🎜##🎜🎜##🎜🎜# implementiert verschiedene Aware-Benachrichtigungsmethoden, wie z. B. BeanNameAware-, BeanFactoryAware- und ApplicationContextAware-Schnittstellenmethoden: Wenn Spring eine Bean initialisiert, muss sie zugewiesen werden eine ID für die Bean (Name). Wenn der BeanName erfolgreich festgelegt wurde, wird eine BeadNameAware-Benachrichtigung generiert. Führen Sie die Initialisierungsmethode BeanPostProcessor aus (wenn diese Methode nicht überschrieben wird, führen Sie die Initialisierungsmethode @PostConstruct aus, die nach der Abhängigkeitsinjektion ausgeführt wird). Operation; Führen Sie die von Ihnen angegebene Init-Methode aus (falls angegeben). Dies ist die im Bean-Tag angegebene Methode Dasselbe wie die Methode, die oben mit Annotationen initialisiert wurde. Methoden sind Produkte aus zwei verschiedenen Epochen, init ist ein Produkt der XML-Ära und @PostConstruct ist ein Produkt der Annotation-Ära. Priorität: Wenn die Methode von Herrn Liang gleichzeitig vorhanden ist, wird zuerst die Annotation ausgeführt, und dann wird init ausgeführt, um die Post-Methode zur Initialisierung des BeanPostProcessor auszuführen (wenn diese Methode nicht überschrieben wird, folgen Sie dem Quellcode). #🎜🎜##🎜🎜##🎜🎜##🎜🎜#4. Verwenden Sie Bean #🎜🎜##🎜🎜##🎜🎜##🎜🎜#5. Zerstören Sie Bean mit verschiedenen Methoden, z. B. @ PreDestroy, DisposibleBean-Schnittstellenmethode, Destroy-Methode. #🎜🎜#

@PreDestroy和destroy-method的关系和初始化方法的两个关系差不多
优先级：@ProDestroy > 重写的DisposableBean接口方法 > destroy-method

执行流程图如下：

ps：实例化和初始化的区别：实例化就是 分配内存空间。初始化，就是把我们一些参数，方法的具体实现逻辑给加载进去。

2.1.1生命周期演示

xml配置如下：

Bean

public class BeanLifeComponent implements BeanNameAware {
    @PostConstruct
    public void PostConstruct(){
        System.out.println("执行@PostConstruct");
    }
    public void init(){
        System.out.println("执行bean-init-method");
    }
    public void use(){
        System.out.println("正在使用bean");
    }
    @PreDestroy
    public void PreDestroy(){
        System.out.println("执行@PreDestroy");
    }
    public void setBeanName(String s){
        System.out.println("执行了Aware通知");
    }
}

启动类

public class App2 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        BeanLifeComponent beanLifeComponent = context.getBean(BeanLifeComponent.class);
        beanLifeComponent.use();
        context.destroy();
    }
}

xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:content="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <content:component-scan base-package="com.beans"></content:component-scan>
    <bean id="1" class="com.beans.BeanLifeComponent" init-method="init"></bean>
</beans>

2.1.2 为什么要先设置属性，在进行初始化

@Controller
public class TestUser {
    @Autowired
    private Test test;

    public TestUser(){
        test.sayHi();
        System.out.println("TestUser->调用构造方法");
    }
}

如果这段代码先执行了初始化，也就是其构造方法，会用到test对象，此时还没有设置属性，test就为null，会造成空指针异常。因此必须先设置属性，在进行初始化。

Das obige ist der detaillierte Inhalt vonWas ist der Umfang und Lebenszyklus von Beans in Java Spring?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!