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!