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());
}
}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 vonBea bezieht sich auf ein bestimmtes Verhaltensmuster von Bean im gesamten Framework von Spring, wie z. B. Singleton Singleton-Bereich bedeutet Bean nur eine Kopie im gesamten Spring hat und diese global geteilt wird, wenn jemand anderes dies ändert Wert, was eine andere Bea的作⽤域是指Bean在 Spring整个框架中的某种⾏为模式，⽐如singleton单例作⽤域，就表
示Bean在整个Spring中只有⼀份，它是全局共享的，那么当其他⼈修改了这个值之后，那么另⼀个
⼈读取到的就是被修改的值。
在Spring中，bean 的作用域被称为是行为模式，因为在Spring看来，单例模式，就是一种行为，意味着在整个Spring中bean只能存在一份。
singleton：单例作⽤域
prototype：原型作⽤域（多例作⽤域）
request：请求作⽤域
session：会话作⽤域
application：全局作⽤域
websocket：HTTP WebSocket 作⽤域
后四种都是SpringMVC中限定使用的，因此现阶段我们只学前两个就行。
回到刚才的案例，Bean2希望获取到的bean对象是未被修改的，我们就可以将单例模式修改为多例模式。
使用@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
使用@Scope("prototype")
ps
Prototyp:
Prototyp-Domäne (mehrere Beispieldomäne)# 🎜🎜#
Anfrage :Session Domain#🎜🎜 #
Die letzten vier sind auf SpringMVC beschränkt, daher müssen wir zu diesem Zeitpunkt nur die ersten beiden lernen.
1.5 Bereich festlegen 
Verwenden Sie @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
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：实例化和初始化的区别：实例化就是 分配内存空间。初始化，就是把我们一些参数，方法的具体实现逻辑给加载进去。
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>@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!
