Java进阶知识17 Spring Bean对象的创建细节和创建方式

本文知识点（目录）：

1、创建细节
         1) 对象创建： 单例/多例
         2) 什么时候创建?
         3)是否延迟创建（懒加载）
         4) 创建对象之后，初始化/销毁
     2、创建方式  
         2.1、默认无参构造器
         2.2、带参构造器（有两种方式，第一种：一个实体类；第二种：两个实体类合为一个[嵌套]）
         2.3、工厂类创建对象（两种：一个是工厂实体类，另一个是工厂实体类内部的静态方法）
     3、附录（第二大点“Bean的创建方式”的所有完整代码）

---

---

1、创建细节

1) 对象创建： 单例/多例
       scope="singleton"   默认值， 即默认是单例 【service/dao/工具类】
       scope="prototype"  多例； 【Action对象】
  2) 什么时候创建?
       scope="singleton"  在启动(容器初始化之前)，就已经创建了bean，且整个应用只有一个。
       scope="prototype"  在用到对象的时候，才创建对象。
  3)是否延迟创建（懒加载）
       lazy-init="false"  默认为false,不延迟创建，即在启动(容器初始化之前)时候就创建对象（只对单例有效）
       lazy-init="true"   延迟初始化， 在用到对象的时候才创建对象（只对单例有效）
  4) 创建对象之后，初始化/销毁
       init-method="init_user"   【对应对象的init_user方法，在对象创建之后执行 】
       destroy-method="destroy_user"  【在调用容器对象的destroy方法时候执行，(容器用实现类)】

 <?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:aop="http://www.springframework.org/schema/aop"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

       <!--
           id：指定bean对象的id
           class：指定bean的类，不能用接口
           scope：单例/多例，默认是“singleton”（此时在初始化容器之前就创建对象），多例：用到的时候才创建
           lazy-init：懒加载，只针对单例有效，默认是false，如果是true——用到的时候才创建
           init-method：指定对象的初始化方法，时间由创建对象的时间来决定
        -->
        <!-- UserDao userDao = new UserDao() -->
     <bean id="userDao" class="com.bw.dao.UserDao" scope="singleton" lazy-init="false"
     init-method="init" destroy-method="destroy"><!-- 默认是单例 -->
         <property name="name" value="Mr Zhang"></property>
     </bean>

     <bean id="userService" class="com.bw.service.UserService" scope="singleton"><!-- 默认是单例 -->
         <property name="userDao" ref="userDao"></property>
     </bean>    

     <bean id="userAction" class="com.bw.action.UserAction" scope="prototype"><!-- 多个 -->
         <property name="userService" ref="userService"></property>
     </bean>
 </beans>

2、创建方式

  2.1、默认无参构造器

spring容器

 <bean id="user1" class="com.shore.entity.User">
      <property name="id" value="101"></property>
      <property name="name" value="张三"></property>
      <property name="sex" value="true"></property>
 </bean>

User实体类

 public class User {
     private Integer id;
     private String name;
     private Boolean sex;
     //set、get和toString方法省略
 }

测试类

 @Test
  public void test1() { //使用无参构造器创建一个User对象
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
       User user1 = (User) context.getBean("user1");
       System.out.println(user1.toString()); //返回结果：User [id=101, name=张三, sex=true]
  }

  2.2、带参构造器

第一种方式：

spring容器

 <!-- 有参构造器01 -->
 <bean id="user2" class="com.shore.entity.User">
     <constructor-arg name="id" value="102" type="java.lang.Integer" /><!-- type可以省略 -->
     <constructor-arg name="name" value="李四" type="java.lang.String" />
     <constructor-arg name="sex" value="true" type="java.lang.Boolean" />
 </bean>

User实体类

 public class User {
     private Integer id;
     private String name;
     private Boolean sex;

     public User() {

     }

     public User(Integer id, String name, Boolean sex) {
         super();
         this.id = id;
         this.name = name;
         this.sex = sex;
     }
       //set、get和toString方法省略
 }

测试类

 @Test
 public void test2() { //使用无参构造器创建一个User对象
      ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
      User user2 = (User) context.getBean("user2");
      System.out.println(user2.toString()); //返回结果：User [id=102, name=李四, sex=true]
 }

第二种方式：

spring容器

 <!-- 有参构造器02 -->
 <bean id="str" class="com.shore.entity.Company">
       <constructor-arg index="0" value="华为技术有限公司"></constructor-arg>
       <constructor-arg index="1" value="广东省深圳市xxxxx"></constructor-arg>
 </bean> <!-- index的值从0开始，value的值要与构造器的字段的顺序对应 -->
 <bean id="user3" class="com.shore.entity.User">
      <constructor-arg index="0" value="103" type="java.lang.Integer" />
      <constructor-arg index="1" value="王五" type="java.lang.String" />
      <constructor-arg index="2" value="true" type="java.lang.Boolean" />
      <constructor-arg index="3" type="java.util.Set" ref="str" /> <!-- ref：参照-->
 </bean>

User实体类

 public class User {
     private Integer id;
     private String name;
     private Boolean sex;
     private Set<Company> company = new HashSet<Company>();

     public User() {

     }

     public User(Integer id, String name, Boolean sex, Set<Company> company) {
         super();
         this.id = id;
         this.name = name;
         this.sex = sex;
         this.company = company;
     }
       //下面省略了set、get和toString方法
 }

Company实体类

 public class Company {
     private String name; //公司名称
     private String address; //地址

     public Company() {
     }

     public Company(String name, String address) {
         super();
         this.name = name;
         this.address = address;
     }
    //下面省略了 set、get和toString方法
 }

测试类

 @Test
     public void test3() { //使用有参构造器创建一个User对象02
         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
         User user3 = (User) context.getBean("user3");
         System.out.println(user3.toString()); //返回结果：User [id=103, name=王五, sex=true, company=[Company [name=华为技术有限公司, address=广东省深圳市xxxxx]]]
     }

  2.3、工厂类创建对象

spring容器

 <!-- 工厂模式创建实例对象 -->
 <bean id="factory" class="com.shore.factory.StudentFactory"></bean>
 <bean id="student1" factory-bean="factory" factory-method="getInstance"></bean>

Student实体类

 public class Student {
     private Integer id;
     private String name;
     private Boolean sex;

     public Student() {

     }

     public Student(Integer id, String name, Boolean sex) {
         super();
         this.id = id;
         this.name = name;
         this.sex = sex;
     }
       //下面省略了set、get和toString方法
 }

StudentFactory实体类

 public class StudentFactory {
     // 实例方法创建对象
     public Student getInstance() {
         return new Student(104,"实例方法创建对象",true);
     }
 }

测试类

 @Test
     public void test4() { //使用工厂创建一个Student对象
         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
         Student student1 = (Student) context.getBean("student1");
         System.out.println(student1.toString()); //返回结果：Student [id=104, name=实例方法创建对象, sex=true]
     }

  2.4、使用工厂类的静态方法创建对象

spring容器

 <!-- 工厂模式静态方法创建实例对象 -->
 <bean id="student2" class="com.shore.factory.StudentFactory" factory-method="getStaticInstance"></bean>

StudentFactory实体类

 public class StudentFactory {
     //静态方法创建一个实例对象
     public static Student getStaticInstance() {
         return new Student(105,"静态方法创建对象",false);
     }
 }

测试类

 @Test
     public void test5() { //使用工厂静态方法创建一个Student对象象
         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
         Student student2 = (Student) context.getBean("student2");
         System.out.println(student2.toString()); //返回结果：Student [id=105, name=静态方法创建对象, sex=false]
     }

附录

上面第二大点“创建方式”的所有完整代码

User实体类

 package com.shore.entity;

 import java.util.HashSet;
 import java.util.Set;

 /**
  * @author DSHORE/2019-10-16
  *
  */
 public class User {
     private Integer id;
     private String name;
     private Boolean sex;
     private Set<Company> company = new HashSet<Company>();

     public User() {

     }

     public User(Integer id, String name, Boolean sex, Set<Company> company) {
         super();
         this.id = id;
         this.name = name;
         this.sex = sex;
         this.company = company;
     }

     public Integer getId() {
         return id;
     }
     public void setId(Integer id) {
         this.id = id;
     }

     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }

     public Boolean getSex() {
         return sex;
     }
     public void setSex(Boolean sex) {
         this.sex = sex;
     }

     public Set<Company> getCompany() {
         return company;
     }

     public void setCompany(Set<Company> company) {
         this.company = company;
     }

     @Override
     public String toString() {
         return "User [id=" + id + ", name=" + name + ", sex=" + sex
                 + ", company=" + company + "]";
     }
 }

Company实体类

 package com.shore.entity;

 /**
  * @author DSHORE/2019-10-16
  *
  */
 public class Company {
     private String name; //公司名称
     private String address; //地址

     public Company() {
     }

     public Company(String name, String address) {
         super();
         this.name = name;
         this.address = address;
     }

     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getAddress() {
         return address;
     }
     public void setAddress(String address) {
         this.address = address;
     }

     @Override
     public String toString() {
         return "Company [name=" + name + ", address=" + address + "]";
     }
 }

Student实体类

 package com.shore.entity;

 /**
  * @author DSHORE/2019-10-16
  *
  */
 public class Student {
     private Integer id;
     private String name;
     private Boolean sex;

     public Student() {

     }

     public Student(Integer id, String name, Boolean sex) {
         super();
         this.id = id;
         this.name = name;
         this.sex = sex;
     }

     public Integer getId() {
         return id;
     }
     public void setId(Integer id) {
         this.id = id;
     }

     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }

     public Boolean getSex() {
         return sex;
     }
     public void setSex(Boolean sex) {
         this.sex = sex;
     }

     @Override
     public String toString() {
         return "Student [id=" + id + ", name=" + name + ", sex=" + sex + "]";
     }
 }

StudentFactory实体类

 package com.shore.factory;

 import com.shore.entity.Student;

 /**
  * @author DSHORE/2019-10-16
  *
  */
 public class StudentFactory {
     // 实例方法创建对象
     public Student getInstance() {
         return new Student(104,"实例方法创建对象",true);
     }

     //静态方法创建一个实例对象
     public static Student getStaticInstance() {
         return new Student(105,"静态方法创建对象",false);
     }
 }

Spring容器（applicationContext.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:tx="http://www.springframework.org/schema/tx"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
             http://www.springframework.org/schema/tx
             http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
             http://www.springframework.org/schema/aop
             http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
             http://www.springframework.org/schema/context
             http://www.springframework.org/schema/context/spring-context-3.2.xsd">
                                                <!-- 后面的3.2：这些版本号，要与你引入的包的版本号一致  -->
            <!-- 默认无参构造器 -->
         <!-- 当spring框架加载时，spring会自动创建一个bean对象，相当于User user1 = new User(); 调用了set方法给每个属性注入值 -->
            <bean id="user1" class="com.shore.entity.User">
                <property name="id" value="101"></property>
             <property name="name" value="张三"></property>
             <property name="sex" value="true"></property>
            </bean>

         <!-- 有参构造器01 -->
         <!-- User user2 = new User(249,"李四",true) -->
         <!-- <bean id="user2" class="com.shore.entity.User">
             <constructor-arg name="id" value="102" type="java.lang.Integer" />type可以省略
             <constructor-arg name="name" value="李四" type="java.lang.String" />
             <constructor-arg name="sex" value="true" type="java.lang.Boolean" />
         </bean> -->

         <!-- 有参构造器02 -->
         <!-- User user3 = new User(103,"王五",true,company) -->
         <bean id="str" class="com.shore.entity.Company">
             <constructor-arg index="0" value="华为技术有限公司"></constructor-arg>
             <constructor-arg index="1" value="广东省深圳市xxxxx"></constructor-arg>
         </bean> <!-- index的值从0开始，value的值要与构造器的字段的顺序对应 -->
         <bean id="user3" class="com.shore.entity.User">
             <constructor-arg index="0" value="103" type="java.lang.Integer" />
             <constructor-arg index="1" value="王五" type="java.lang.String" />
             <constructor-arg index="2" value="true" type="java.lang.Boolean" />
             <constructor-arg index="3" type="java.util.Set" ref="str" />
         </bean>

         <!-- 工厂模式创建实例对象 -->
         <bean id="factory" class="com.shore.factory.StudentFactory"></bean>
         <bean id="student1" factory-bean="factory" factory-method="getInstance"></bean>

         <!-- 工厂模式静态方法创建实例对象 -->
         <bean id="student2" class="com.shore.factory.StudentFactory" factory-method="getStaticInstance"></bean>

 </beans>

测试类

 package com.shore.test;

 import org.junit.Test;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.shore.entity.Student;
 import com.shore.entity.User;

 /**
  * @author DSHORE/2019-10-16
  *
  */
 public class MyTest {
     @Test
     public void test1() { //使用无参构造器创建一个User对象
         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
         User user1 = (User) context.getBean("user1");
         System.out.println(user1.toString());//返回结果：User [id=101, name=张三, sex=true]
     }

     @Test
     public void test2() { //使用有参构造器创建一个User对象01
         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
         User user2 = (User) context.getBean("user2");
         System.out.println(user2.toString());//返回结果：User [id=102, name=李四, sex=true]
     }

     @Test
     public void test3() { //使用有参构造器创建一个User对象02
         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
         User user3 = (User) context.getBean("user3");
         System.out.println(user3.toString()); //返回结果：User [id=103, name=王五, sex=true, company=[Company [name=华为技术有限公司, address=广东省深圳市xxxxx]]]
     }

     @Test
     public void test4() { //使用工厂创建一个Student对象
         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
         Student student1 = (Student) context.getBean("student1");
         System.out.println(student1.toString()); //返回结果：Student [id=104, name=实例方法创建对象, sex=true]
     }

     @Test
     public void test5() { //使用工厂静态方法创建一个Student对象象
         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
         Student student2 = (Student) context.getBean("student2");
         System.out.println(student2.toString()); //返回结果：Student [id=105, name=静态方法创建对象, sex=false]
     }
 }

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：https://www.cnblogs.com/dshore123/p/11686438.html

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的 推荐，或评论，谢谢！）

2）带参构造器