Eingehende Analyse und Quellcode-Analyse des Umfangs und Lebenszyklus von Spring Bean in Java

Bean-Bereich und Lebenszyklus

Bean-Bereich

Der Bean-Bereich bezieht sich auf einen bestimmten Verhaltensmodus von Bean im gesamten Spring-Framework.

Ein Singleton-Singleton-Bereich bedeutet beispielsweise, dass Bean in der gesamten Spring One-Kopie nur einen Bereich hat Es wird global geteilt. Wenn also jemand anderes den Wert ändert, liest die andere Person den geänderten Wert (Mehrfachinstanzbereich)

Anfrage: Anforderungsbereich

• Sitzung: Rückrufbereich

• Anwendung: Globaler Bereich

• Websocket: HTTP

• # Hinweis# Die letzten vier Zustände sind Werte ​In Spring MVC gibt es nur die ersten beiden in gewöhnlichen Spring-Projekten. Wir alle wussten, dass die Verwendung von Singletons die Leistung erheblich verbessern kann, daher ist der Umfang von Beans in Spring standardmäßig auch Singleton-Muster.
Beschreibung: Es gibt nur eine Instanz der Bean in diesem Bereich im IoC-Container: die erhaltene Bean (d. h. über applicationContext.getBean und andere Methoden erhalten) und die zusammengesetzte Bean (d. h. über @ injiziert) Autowired) sind das gleiche Objekt.
Szenario: Normalerweise verwenden zustandslose Beans diesen Bereich (Zustandslos bedeutet, dass der Attributstatus des Bean-Objekts nicht aktualisiert werden muss)

Prototyp

Beschreibung: Jeder Zeitlich werden in diesem Bereich Bean-Anfragen neue Instanzen erstellen: Das Abrufen von Beans (d. h. das Abrufen über applicationContext.getBean und andere Methoden) und das Zusammenstellen von Beans (d. h. durch @Autowired-Injection) sind beide neue Objektinstanzen.

• Szenario: Normalerweise verwenden Stateful Beans diesen Bereich.

• request

Beschreibung: Jede http-Anfrage erstellt eine neue Bean-Instanz, ähnlich dem Prototyp

• Szenario: ⼀ mal Shared Bean für http-Anfrage und Antwort

• Hinweis: Beschränkt auf die Verwendung in SpringMVC. Freigegebene Beans, die auf Konversationen reagieren, zum Beispiel: Aufzeichnen der Anmeldeinformationen eines Benutzers

Hinweis: Nur in SpringMVC verfügbar. ⽤

• Anwendung (verstehen)
Beschreibung: Definieren Sie in einem HTTP-Servlet-Kontext eine Bean-Instanz.
Szenario: Kontextinformationen einer Webanwendung, z. B.: Aufzeichnen gemeinsam genutzter Informationen einer Anwendung.

Hinweis: Beschränkt auf Spring MVC mit ⽤
• websocket (verstehen)

• Beschreibung: Definieren Sie im Lebenszyklus eines HTTP-WebSockets eine Bean-Instanz.

Szenario: In jeder WebSocket-Sitzung werden die Header-Informationen einer Map-Struktur zum Umschließen gespeichert die Client-Nachricht im zukünftigen Kopf. Nach der ersten Initialisierung ist es bis zum Ende von WebSocket dasselbe Bean.

Bemerkungen: Beschränkt auf die Verwendung in Spring WebSocket ⽤
• Singleton-Bereich (Singleton) VS globaler Bereich (Anwendung)

• Singleton ist der Bereich von Spring Core, Anwendung ist der Bereich von Spring Web Scope .

Singleton wirkt auf den IoC-Container, Anwendung wirkt auf den Servlet-Container Einstellungen: @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

@Component
public class UserBeans {
  	@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    @Bean
    public User user1() {
        User user = new User();
        user.setId(1);
        user.setName("Gujiu");
        user.setPassword("123456");
        return user;
    }
}

Legen Sie den Wert direkt fest: @Scope("prototype")

@Component
public class UserBeans {
    @Scope("prototype")
    @Bean
    public User user1() {
        User user = new User();
        user.setId(1);
        user.setName("Gujiu");
        user.setPassword("123456");
        return user;
    }
}

Spring-Ausführungsprozess
Container starten (Startprojekt)
Konfigurationsdatei lesen (Initialisierung)
Verwenden Sie xml, um Bean direkt zu registrieren

Konfigurieren Sie Bean-Stammpfad (Scannen)

• Speichern Sie die Bean in Spring: Scannen und assemblieren Sie durch Klassenanmerkungen

• Bean wird assembliert die erforderliche Klasse (Abrufvorgang)

Bean-Lebenszyklus

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.

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

//@Component
public class BeanLifeComponent implements BeanNameAware {

    @Override
    public void setBeanName(String s) {
        System.out.println("执行了通知");
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println("执行了 @PostConstruct");
    }

    public void init() {
        System.out.println("执行了 init-method");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("执行了销毁方法");
    }
}

直接设置值: @Scope("prototype")

<?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">

    <bean id="myComponent" class="com.demo.component.BeanLifeComponent"
          init-method="init" ></bean>
</beans>

Spring 执行流程

• 启动容器 (启动项目)

• 读取配置文件 (初始化)

• 使用 xml 直接注册 Bean

• 配置 Bean 根 (扫描) 路径

• 将 Bean 存储到 Spring 中: 通过类注解进行扫描和装配

• 将 BeanBean-Lebenszyklus:

Bean instanziieren (entspricht dem „Laden“ in JVM, von vorne beginnen, Bytecode in Objekte im Speicher umwandeln, nur Speicher zuweisen) [Einen Satz gekauft]

Eigenschaften festlegen (Bohneninjektion und -montage) [Dekorationsmaterialien kaufen (Einführung externer Ressourcen)]

Bohneninitialisierung [Hausdekoration]

• • 实现了各种 Aware 通知的方法，如 BeanNameAware、BeanFactoryAware、ApplicationContextAware 的接口方法 [打电话给各个装修的师傅]

  • 执行 BeanPostProcessor 初始化前置方法 [师傅勘察环境, 指定装修方案 (前置工作)]

  • 执行 @PostConstruct 初始化方法，依赖注入操作之后被执行 [两类装修师傅进行装修]

  • 执行自己指定的 init-method 方法 (如果有指定的话) [两类装修师傅进行装修]

  • 执行 BeanPostProcessor 初始化后置方法 [装修之后的清理工作]

• 使用 Bean [房子可以入住使用了]

• 销毁 Bean [卖掉房子]

生命周期演示

BeanLifeComponent 类:

//@Component
public class BeanLifeComponent implements BeanNameAware {

    @Override
    public void setBeanName(String s) {
        System.out.println("执行了通知");
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println("执行了 @PostConstruct");
    }

    public void init() {
        System.out.println("执行了 init-method");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("执行了销毁方法");
    }
}

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">

    <bean id="myComponent" class="com.demo.component.BeanLifeComponent"
          init-method="init" ></bean>
</beans>

调用类:

public class App2 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("spring-config.xml");
        BeanLifeComponent beanLifeComponent =
                applicationContext.getBean("myComponent", BeanLifeComponent.class);
        System.out.println("使用Bean");
        applicationContext.destroy();
    }
}

运行结果展示:

Das obige ist der detaillierte Inhalt vonEingehende Analyse und Quellcode-Analyse des Umfangs und Lebenszyklus von Spring Bean in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!