Spring笔记03（Spring创建对象的三种方式）

1.创建对象的三种方式和bean的生命周期的验证：

Animal接口代码：

package cn.pb.dao;

/**
 * 动物接口
 */
public interface Animal {
    //吃饭
    String eat();
    //睡觉
    void sleep();
}

Animal接口的实现类Dog的代码：

package cn.pb.dao.impl;
/**
 * animal的实现类
 */

import cn.pb.dao.Animal;

public class Dog implements Animal{
    /**
     * 无参构造 验证什么时候实例被创建
     */
    public Dog(){
        System.out.println("dog被实例化了！");
    }

    public String eat() {
        System.out.println("吃饭的方法");
        return null;
    }

    public void sleep() {
        System.out.println("睡觉的方法");
    }

    //初始化之后的方法
    public void  init(){
        System.out.println("初始化之后的方法");
    }

    //销毁之前的方法
    public void  destroy(){
        System.out.println("销毁之前的方法");
    }


}

01.通过构造方法创建对象（常用的方式）：

 001.appicationContext.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"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--配置我们的Dog类  spring 框架在底层 
  通过反射的机制  执行了我们的构造方法-->

<bean id="dog" class="cn.pb.dao.impl.Dog"></bean>

</beans>

 002.测试代码：

 @Test
    public void test05(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");

        System.out.println("********");

        /**
         * 因为我们在容器中定义了id  根据id找到对应的类
         * 这里的dog是通过构造方法创建的
         */
        Animal dog=(Animal) context.getBean("dog");
        dog.eat();
        dog.sleep();

    }

02.通过静态工厂方法创建对象：

 001.静态工厂类：

package cn.pb.dao;

import cn.pb.dao.impl.Dog;

/**
 * AnimalFactory静态工厂类
 */
public class AnimalFactory {
    /**
     * 可以看到程序没有走构造方法
     */
    public AnimalFactory(){
        System.out.println("静态工厂的无参构造====");
    }
//静态工厂，不会走无参构造
    public static Animal getDog(){
        System.out.println("工厂中静态获取Dog实例的方法");
        return new Dog();
    }
}

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

    <!--配置我们的Dog类  spring 框架在底层 01.  通过反射的机制  执行了我们的构造方法
    <bean id="dog" class="cn.pb.dao.impl.Dog"></bean>
    -->

    <!--02.通过静态工厂 来创建我们对象的实例
     工厂的本身构造不会执行 因为我们的方法是静态的 ！类只会被加载，不会被实例化！
     getDog必须是静态的-->


    <bean id="dog" class="cn.pb.util.AnimalFactory" factory-method="getDog"></bean>  

</beans>

 003.测试代码：

//使用静态工厂来创建对象
    @Test
    public  void  test06(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("*************************");
        /**
         * 因为我们在容器中定义了id 根据id找到对应的类
         * 是通过静态工厂来创建的 不走静态工厂的构造方法
         * 工厂的本身构造不会执行 因为我们的方法是静态的 ！类只会被加载，不会被实例化！
         */
        Animal dog=(Animal) context.getBean("dog");
        dog.eat();
        dog.sleep();
    }

03.通过动态工厂方法创建对象：

 001.动态工厂类：

package cn.pb.dao;

import cn.pb.dao.impl.Dog;

/**
 * AnimalFactory动态工厂类
 */
public class AnimalFactory {
    /**
     * 程序会先创建工厂实例 再调用getDog()方法
     */
    public AnimalFactory(){
        System.out.println("动态工厂的无参构造====");
    }
//动态工厂 会先走无参构造  创建实例
    public Animal getDog(){
        System.out.println("工厂中动态工厂获取Dog实例的方法");
        return new Dog();
    }
}

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

    <!--配置我们的Dog类  spring 框架在底层 01.  通过反射的机制  执行了我们的构造方法
    <bean id="dog" class="cn.pb.dao.impl.Dog"></bean>
    -->

    <!--02.通过静态工厂 来创建我们对象的实例
     工厂的本身构造不会执行 因为我们的方法是静态的 ！类只会被加载，不会被实例化！
     getDog必须是静态的
      <bean id="dog" class="cn.pb.util.AnimalFactory" factory-method="getDog"></bean>
     -->

    <!--03.动态工厂创建 对象的实例-->
    <bean id="factory" class="cn.pb.util.AnimalFactory"></bean><!-- 调用哪个工厂里的哪个方法  来创建对象  对象的id是dog-->
    <bean id="dog" factory-bean="factory" factory-method="getDog"/>

</beans>

 003.测试代码：

 //使用动态工厂来创建对象
    @Test
    public  void  test06(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("*************************");
        /**
         * 因为我们在容器中定义了id 根据id找到对应的类
         * 是通过动态工厂来创建的 首先要获得动态工厂的bean
         * 然后再dog的bean
         */
        Animal dog=(Animal) context.getBean("dog");
        dog.eat();
        dog.sleep();
    }

04.验证bean的生命周期：

 001.在Dog类中新增两个方法：

  //初始化之后的方法
    public void  init(){
        System.out.println("初始化之后的方法");
    }

    //销毁之前的方法
    public void  destroy(){
        System.out.println("销毁之前的方法");
    }

 

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

    <!--配置我们的Dog类  spring 框架在底层 01.  通过反射的机制  执行了我们的构造方法
    <bean id="dog" class="cn.pb.dao.impl.Dog"></bean>
    -->

    <!--02.通过静态工厂 来创建我们对象的实例
     工厂的本身构造不会执行 因为我们的方法是静态的 ！类只会被加载，不会被实例化！
     getDog必须是静态的
      <bean id="dog" class="cn.pb.util.AnimalFactory" factory-method="getDog"></bean>
     -->

    <!--03.动态工厂创建 对象的实例
    <bean id="factory" class="cn.pb.util.AnimalFactory"></bean>实例化工厂-->
    <!-- 调用哪个工厂里的哪个方法  来创建对象  对象的id是dog
    <bean id="dog" factory-bean="factory" factory-method="getDog2"/>-->

    <!--
      设置bean的生命始末
    -->
<bean id="dog" class="cn.pb.dao.impl.Dog" init-method="init" destroy-method="destroy"></bean>


</beans>

 003.测试代码：

 

   /**
    * 设置bean的生命周期始末
    * 01.在Dog类中新增两个方法  init()　destroy()
    * 02.在容器中 配置
    *    init-method="init" destroy-method="destroy"
    */
@Test
public  void  test08(){
    ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
    System.out.println("*************************");
    Animal dog=(Animal) context.getBean("dog");
    System.out.println(dog);
    /*
     * 想看到destroy-method="destroy" 的效果 有两个前提
     * 01.bean必须是单例的
     * 02.容器需要手动的关闭
     */
    ((ClassPathXmlApplicationContext)context).close();
}