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();
}
