Spring_bean的实例化时机

前言：创建Java对象

 1 public class User {
 2     private String name;
 3     private Integer age;
 4 
 5     public User() {
 6         System.out.println("这是空参构造");
 7     }
 8 
 9     public String getName() {
10         return name;
11     }
12 
13     public Integer getAge() {
14         return age;
15     }
16 
17     public void setName(String name) {
18         this.name = name;
19     }
20 
21     public void setAge(Integer age) {
22         this.age = age;
23     }
24 }

 

 1.默认情况--容器创建，容器管理的bean即被实例化

<!-- 创建方式1：空参构造创建 -->
    <bean id="user" class="cn.rocker.spring.bean.User">
    </bean>

 

 1 public class Demo {
 2     @Test
 3     public void run(){
 4         //1.创建容器对象
 5         ApplicationContext context = new ClassPathXmlApplicationContext("cn\\rocker\\spring\\test\\spring-config.xml");
 6         //2.从容器获取对象
 7         //Object user = context.getBean("user", User.class);
 8         //3.打印对象
 9         //System.out.println(user);
10     }
11 }

2.给bean元素设置lazy-init="true"属性--调用getBean()方法时，bean被实例化，即对容器管理的bean进行请求时，才会实例化

<!-- 创建方式1：空参构造创建 -->
    <bean id="user" class="cn.rocker.spring.bean.User" lazy-init="true">
    </bean>

 

 1 public class Demo {
 2     @Test
 3     public void run(){
 4         //1.创建容器对象
 5         ApplicationContext context = new ClassPathXmlApplicationContext("cn\\rocker\\spring\\test\\spring-config.xml");
 6         //2.从容器获取对象
 7         Object user = context.getBean("user", User.class);
 8         //3.打印对象
 9         //System.out.println(user);
10     }
11 }

3.给bean元素设置scope="singleton"属性(默认)--容器创建，容器管理的bean即被实例化，以后每次请求获得的都是相同对象

<!-- 创建方式1：空参构造创建 -->
    <bean id="user" class="cn.rocker.spring.bean.User" scope="singleton">
    </bean>

 

 1 @Test
 2     public void run4(){
 3         //1.创建容器对象
 4         ApplicationContext context = new ClassPathXmlApplicationContext("cn\\rocker\\spring\\test\\spring-config.xml");
 5         //2.从容器获取对象
 6         Object user1 = context.getBean("user", User.class);
 7         Object user2 = context.getBean("user", User.class);
 8         Object user3 = context.getBean("user", User.class);
 9         //3.打印对象
10         //System.out.println(user1);
11         System.out.println(user2 == user3);
12     }

4.给bean元素设置scope="prototype"属性--调用getBean()方法时，bean被实例化，即对容器管理的bean进行请求时，才会实例化，而且每次请求都会获得新的对象

<!-- 创建方式1：空参构造创建 -->
    <bean id="user" class="cn.rocker.spring.bean.User" scope="prototype">
    </bean>

 

 1 @Test
 2     public void run5(){
 3         //1.创建容器对象
 4         ApplicationContext context = new ClassPathXmlApplicationContext("cn\\rocker\\spring\\test\\spring-config.xml");
 5         //2.从容器获取对象
 6         Object user4 = context.getBean("user", User.class);
 7         Object user5 = context.getBean("user", User.class);
 8         Object user6 = context.getBean("user", User.class);
 9         //3.打印对象
10         //System.out.println(user1);
11         System.out.println(user5 == user6);
12     }

 

总结：1.默认情况下，容器创建，bean即被实例化

　　　2.当scope为singleton(默认)时，设置lazy-init="true"，则会在请求对象时，对对象进行实例化

    　   3.当scope为prototype时，则会在请求对象时，对对象进行实例化，且每次请求都会创建新的实例

 

转载于:https://www.cnblogs.com/rocker-pg/p/7894654.html