4.2.3 静态工厂实例化

4.2.3.1 工厂方式创建 bean

使用工厂方式创建对象，在一定程度上进行解耦，但不如将工厂交给Spring来管理（见4.2.3.2）

• Dao

  public class OrderDaoImpl implements OrderDao {
  public void save() {
      System.out.println("order dao save ...");
  }
  }

• Factory

  //静态工厂创建对象
  public class OrderDaoFactory {
      public static OrderDao getOrderDao(){
          System.out.println("factory setup....");
          return new OrderDaoImpl();
      }
  }

• Main

  public class AppForInstanceOrder {
      public static void main(String[] args) {
          // 通过静态工厂创建对象
          OrderDao orderDao = OrderDaoFactory.getOrderDao();
          orderDao.save();
          /**
           * 控制台输出：
           * factory setup....
           * order dao save ...
           */
      }
  }

4.2.3.2 静态工厂实例化

将工厂交给Spring来管理，实例化 bean

• 核心配置文件

  <!-- property标签 : 表示配置当前Bean的属性 -->
  <!-- class属性 : 所使用的工厂的全类名 -->
  <!-- factory-method属性 ： 工厂中创建bean的方法名 -->
  <bean id="orderDao" class="priv.dandelion.factory.OrderDaoFactory" factory-method="getOrderDao"/>

• Main

  public class AppForInstanceOrder {
      public static void main(String[] args) {
      ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  
      OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");
  
      orderDao.save();
      /**
       * 控制台输出：
       * factory setup....
       * order dao save ...
       */
  }
  }

4.2.4 实例工厂（非静态）与 FactoryBean

4.2.4.1 环境准备

• Dao

  public class UserDaoImpl implements UserDao {
  public void save() {
      System.out.println("user dao save ...");
  }
  }

• Factory

  //实例工厂创建对象
  public class UserDaoFactory {
      public UserDao getUserDao(){
          return new UserDaoImpl();
      }
  }

4.2.4.2 实例工厂实例化

• 核心配置文件

  <!-- 工厂中获取Dao的方法是非静态的，必须拿到工厂对象 -->
  <bean id="userFactory" class="priv.dandelion.factory.UserDaoFactory"/>
  
  <!-- 指定工厂，并使用工厂对应方法获取所需的bean对象 -->
  <!-- factory-bean：指定工厂bean -->
  <bean id="userDao" factory-bean="userFactory" factory-method="getUserDao"/>

• Main

  public class AppForInstanceUser {
      public static void main(String[] args) {
      ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  
      UserDao userDao = (UserDao) ctx.getBean("userDao");
  
      userDao.save();
      /**
       * 控制台输出:
       * user dao save ...
       */
  }
  }

4.2.4.3 FactoryBean 的使用（改良：实例工厂实例化）

4.2.4.2 实例工厂实例化中存在问题，需要进行改进：

使用FactoryBean对其进行改进

• FactoryBean 工厂类

  // FactoryBean创建对象，需要实现FactoryBean<T>接口并指定泛型
  public class UserDaoFactoryBean implements FactoryBean<UserDao> {
  // 代替原始实例工厂中创建对象的方法
  public UserDao getObject() throws Exception {
      return new UserDaoImpl();
  }
  
  // 指定Object的类型，返回对应的类的字节码文件
  public Class&lt;?&gt; getObjectType() {
      return UserDao.class;
  }
  
  // 创建出的 bean 是否为单例，返回 true 为单例，不覆写该方法时默认为为单例
  public boolean isSingleton() {
      return true;
  }
  }

• 核心配置文件

  <!-- <bean id="userFactory" class="priv.dandelion.factory.UserDaoFactory"/> -->
  <!-- <bean id="userDao" factory-bean="userFactory" factory-method="getUserDao"/> -->
  <bean id="userDao" class="priv.dandelion.factory.UserDaoFactoryBean"/>

• Main

  与 4.2.4.2 一致，无需修改

4.3 bean的生命周期

bean 的生命周期有以下几个阶段：

• 初始化容器

• 使用 bean

• 关闭 / 销毁容器

4.3.1 环境准备

• Dao

  public class BookDaoImpl implements BookDao {
      public void save() {
          System.out.println("book dao save ...");
      }
  }

• 核心配置文件

  <bean id="bookDao" class="priv.dandelion.dao.impl.BookDaoImpl"/>

• Main

  public class AppForLifeCycle {
      public static void main( String[] args ) {
          ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
          BookDao bookDao = (BookDao) ctx.getBean("bookDao");
          bookDao.save();
          /**
           * book dao save ...
           */
      }
  }

4.3.2 生命周期设置

1. 类中添加初始化和销毁方法

   public class BookDaoImpl implements BookDao {
       public void save() {
           System.out.println("book dao save ...");
       }
       // 表示bean初始化对应的操作
       public void init(){
           System.out.println("init...");
       }
       // 表示bean销毁前对应的操作
       public void destroy(){
           System.out.println("destroy...");
       }
   }

2. 在核心配置文件中进行配置

   <!--init-method：设置bean初始化生命周期回调函数-->
   <!--destroy-method：设置bean销毁生命周期回调函数，仅适用于单例对象-->
   <bean id="bookDao" class="priv.dandelion.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/><bean id="bookDao" class="priv.dandelion.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>

3. 运行程序，控制台输出仅包含init

   如运行情况中所示，控制台没有输出destroy...，说明销毁方法未被执行，该问题将在 4.3.3 和 4.3.4 得到解决

   /**
    * init...
    * book dao save ...
    */

4.3.3 close关闭容器

• 销毁方法未执行原因与解决方案分析

  • 原因：程序运行结束时，JVM虚拟机直接被关闭，销毁方法来不及执行
  • 解决方案：在关闭JVM虚拟机之前手动关闭容器，可以执行销毁方法

• 实现

  存在问题：ApplicationContext中没有实现close()

  解决方案：其实现类ClassPathXmlApplicationContext对其进行了实现

  public class AppForLifeCycle {
      public static void main( String[] args ) {
          ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
      BookDao bookDao = (BookDao) ctx.getBean("bookDao");
      bookDao.save();
      //关闭容器
      ctx.close();
      /**
       * init...
       * book dao save ...
       * destroy...
       */
  }
  }

4.3.4 注册钩子关闭容器

• 使用该方式的原因

  • close关闭容器相对而言比较暴力，如果在 close 之后还有未执行的语句，可能会发生问题
  • 注册钩子关闭容器语句可以写在任何位置，且仅在JVM虚拟机关闭前执行销毁

• 注册钩子关闭容器的使用方法

  • Main中

    //注册关闭钩子函数，在虚拟机退出之前回调此函数，关闭容器
    ctx.registerShutdownHook();

4.3.5 生命周期管理的接口方式

Spring为生命周期控制提供了接口，在上述代码的基础上添加以下代码进行演示

• 核心配置文件（不需要写 init-method 和 destroy-method 属性）

  <bean id="bookService" class="priv.dandelion.service.impl.BookServiceImpl">
      <property name="bookDao" ref="bookDao"/>
  </bean>

• Service

  public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
      private BookDao bookDao;
  public void setBookDao(BookDao bookDao) {
      System.out.println("set .....");
      this.bookDao = bookDao;
  }
  
  public void save() {
      System.out.println("book service save ...");
      bookDao.save();
  }
  
  public void destroy() throws Exception {
      System.out.println("service destroy");
  }
  
  // 如方法名所述，该方法运行在set方法之后
  public void afterPropertiesSet() throws Exception {
      System.out.println("service init");
  }
  }

• Main

  public class AppForLifeCycle {
      public static void main( String[] args ) {
          ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
      BookDao bookDao = (BookDao) ctx.getBean("bookDao");
      bookDao.save();
      //注册关闭钩子函数，在虚拟机退出之前回调此函数，关闭容器
      ctx.registerShutdownHook();
      /**
       * init...
       * set .....
       * service init
       * book dao save ...
       * service destroy
       * destroy...
       */
  }
  }

• 向一个类中传递数据的方式

  • 普通方法（setter）
  • 构造方法（构造器）

• 容器中的 bean 可能是什么类型的数据

  • 引用类型
  • 简单类型（基本数据类型和 String）

5.1 setter注入 （推荐，使用简单）

5.1.1 注入引用数据类型

1. 类中给出成员变量并实现其setter

   public class BookServiceImpl implements BookService {
       private BookDao bookDao;
       private UserDao userDao;
       //setter注入需要提供要注入对象的set方法
       public void setUserDao(UserDao userDao) {
           this.userDao = userDao;
       }
       //setter注入需要提供要注入对象的set方法
       public void setBookDao(BookDao bookDao) {
           this.bookDao = bookDao;
       }
   public void save() {
       System.out.println("book service save ...");
       bookDao.save();
       userDao.save();
   }
   }

2. 核心配置文件

   <!-- 被注入的需要配置，定义成bean -->
   <bean id="bookDao" class="priv.dandelion.dao.impl.BookDaoImpl"/>
   <bean id="userDao" class="priv.dandelion.dao.impl.UserDaoImpl"/>
   
   <!-- 注入引用类型 -->
   <bean id="bookService" class="priv.dandelion.service.impl.BookServiceImpl">
       <!--property标签：设置注入属性-->
       <!--name属性：设置注入的属性名，实际是set方法对应的名称-->
       <!--ref属性：设置注入引用类型bean的id或name-->
       <property name="bookDao" ref="bookDao"/>
       <property name="userDao" ref="userDao"/>
   </bean>

5.1.2 注入简单数据类型

1. 在类中定义成员变量并实现其 setter

   public class BookDaoImpl implements BookDao {
   private String databaseName;
   private int connectionNum;
   //setter注入需要提供要注入对象的set方法
   public void setConnectionNum(int connectionNum) {
       this.connectionNum = connectionNum;
   }
   //setter注入需要提供要注入对象的set方法
   public void setDatabaseName(String databaseName) {
       this.databaseName = databaseName;
   }
   
   public void save() {
       System.out.println("book dao save ..."+databaseName+","+connectionNum);
   }
   }

2. 核心配置文件

   <!-- 注入简单类型 -->
   <bean id="bookDao" class="priv.dandelion.dao.impl.BookDaoImpl">
       <!--property标签：设置注入属性-->
       <!--name属性：设置注入的属性名，实际是set方法对应的名称-->
       <!--value属性：设置注入简单类型数据值，Spring内部会自动进行类型转换-->
       <property name="connectionNum" value="100"/>
       <property name="databaseName" value="mysql"/>
   </bean>

5.2 构造器注入

5.2.1 构造器注入引用数据类型

1. 类中给出成员变量并使用有参构造对需要注入的成员进行初始化操作

   public class BookServiceImpl implements BookService {
       private BookDao bookDao;
       private UserDao userDao;
   public BookServiceImpl(BookDao bookDao, UserDao userDao) {
       this.bookDao = bookDao;
       this.userDao = userDao;
   }
   
   public void save() {
       System.out.println("book service save ...");
       bookDao.save();
       userDao.save();
   }
   }

2. 核心配置文件

   <bean id="bookDao" class="priv.dandelion.dao.impl.BookDaoImpl"/>
   <bean id="userDao" class="priv.dandelion.dao.impl.UserDaoImpl"/>
   
   <bean id="bookService" class="priv.dandelion.service.impl.BookServiceImpl">
       <!-- 注意此处的 ref 属性值为：构造方法的形参名 -->
       <constructor-arg name="userDao" ref="userDao"/>
       <constructor-arg name="bookDao" ref="bookDao"/>
   </bean>

5.2.2 构造器注入简单数据类型

1. 类中给出成员变量并使用有参构造对需要注入的成员进行初始化操作

   public class BookDaoImpl implements BookDao {
       private String databaseName;
       private int connectionNum;
   public BookDaoImpl(String databaseName, int connectionNum) {
       this.databaseName = databaseName;
       this.connectionNum = connectionNum;
   }
   
   public void save() {
       System.out.println("book dao save ..."+databaseName+","+connectionNum);
   }
   }

2. 核心配置文件

   <bean id="bookDao" class="priv.dandelion.dao.impl.BookDaoImpl">
       <!-- 根据构造方法参数名称注入 -->
       <constructor-arg name="connectionNum" value="10"/>
       <constructor-arg name="databaseName" value="mysql"/>
   </bean>

5.2.3 【补充】不同场景构造器注入简单数据类型的其他写法 —— 用于解耦

<!-- 1. 标准书写 -->
<bean id="bookDao" class="priv.dandelion.dao.impl.BookDaoImpl">
    <constructor-arg name="connectionNum" value="10"/>
    <constructor-arg name="databaseName" value="mysql"/>
</bean>

<!-- 2. 解决形参名称的问题，与形参名不耦合 -->
<bean id="bookDao" class="priv.dandelion.dao.impl.BookDaoImpl">
    <constructor-arg type="int" value="10"/>
    <constructor-arg type="java.lang.String" value="mysql"/>
</bean>

<!-- 3. 解决参数类型重复问题，使用位置解决参数匹配 -->
<bean id="bookDao" class="priv.dandelion.dao.impl.BookDaoImpl">
    <constructor-arg index="0" value="mysql"/>
    <constructor-arg index="1" value="100"/>
</bean>

5.3 自动配置

• IoC 容器根据 bean 所依赖的资源在容器中自动查找并注入到 bean 中的过程称为自动装配

• 自动装配的方式：

  • 按类型（常用）

  • 按名称（耦合度高）

  • 按构造器（不推荐）

  • 不启用自动装配

• 依赖自动装配特征

  • 自动装配用于引用类型依赖注入，不能对简单类型进行操作
  • 使用按类型装配时（byType）必须保障容器中相同类型（class）的 bean 唯一，推荐使用
  • 使用按名称装配时（byName）必须保障容器中具有指定名称（id）的 bean，因变量名与配置耦合，不推荐使用
  • 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

• 按类型（推荐）

  • 注意事项

  • 配置

    <bean id="bookDao" class="priv.dandelion.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="priv.dandelion.service.impl.BookServiceImpl" autowire="byType"/>

• 按名称

  • 注意事项

  • 配置代码

    <bean id="bookDao" class="priv.dandelion.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="priv.dandelion.service.impl.BookServiceImpl" autowire="byName"/>

5.4 集合注入

• List 和 Array 可以相互通用

• 如果集合的元素是引用类型则不使用 <value></value>

  <ref bean="bean的id"/>

• Dao

  public class BookDaoImpl implements BookDao {
  private int[] array;
  
  private List<String> list;
  
  private Set<String> set;
  
  private Map<String,String> map;
  
  private Properties properties;
  
  public void setArray(int[] array) {
      this.array = array;
  }
  
  public void setList(List<String> list) {
      this.list = list;
  }
  
  public void setSet(Set<String> set) {
      this.set = set;
  }
  
  public void setMap(Map<String, String> map) {
      this.map = map;
  }
  
  public void setProperties(Properties properties) {
      this.properties = properties;
  }
  
  public void save() {
      System.out.println("book priv.dandelion.dao save ...");
  
      System.out.println("遍历数组:" + Arrays.toString(array));
  
      System.out.println("遍历List" + list);
  
      System.out.println("遍历Set" + set);
  
      System.out.println("遍历Map" + map);
  
      System.out.println("遍历Properties" + properties);
  }
  }

• 核心配置文件

  <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
      <bean id="bookDao" class="priv.dandelion.dao.impl.BookDaoImpl">
          <!--数组注入-->
          <property name="array">
              <array>
                  <value>100</value>
                  <value>200</value>
                  <value>300</value>
              </array>
          </property>
          <!--list集合注入-->
          <property name="list">
              <list>
                  <value>dande</value>
                  <value>dandel</value>
                  <value>dandelio</value>
                  <value>dandelion</value>
              </list>
          </property>
          <!--set集合注入-->
          <property name="set">
              <set>
                  <value>dande</value>
                  <value>dandel</value>
                  <value>dandelio</value>
                  <value>dandelio</value>
              </set>
          </property>
          <!--map集合注入-->
          <property name="map">
              <map>
                  <entry key="country" value="china"/>
                  <entry key="province" value="henan"/>
                  <entry key="city" value="kaifeng"/>
              </map>
          </property>
          <!--Properties注入-->
          <property name="properties">
              <props>
                  <prop key="country">china</prop>
                  <prop key="province">henan</prop>
                  <prop key="city">kaifeng</prop>
              </props>
          </property>
      </bean>
  </beans>

• Main

  public class AppForDICollection {
      public static void main( String[] args ) {
          ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
      BookDao bookDao = (BookDao) ctx.getBean("bookDao");
  
      bookDao.save();
  }
  /**
   * book priv.dandelion.dao save ...
   * 遍历数组:[100, 200, 300]
   * 遍历List[dande, dandel, dandelio, dandelion]
   * 遍历Set[dande, dandel, dandelio]
   * 遍历Map{country=china, province=henan, city=kaifeng}
   * 遍历Properties{province=henan, city=kaifeng, country=china}
   */
  }