Spring-day2

IOC操作Bean管理（FactoryBean管理）

Spring有两种类型的bean，一种普通bean，一种工厂bean（FactoryBean）
1.普通bean：在配置文件中定义bean类型就是返回类型
2.工厂bean：在配置文件中定义bean类型可以和返回类型不一样
第一步 创建类，让这个类作为工厂bean，实现接口FactoryBean
第二步 实现接口里面的方法，在实现的方法中定义返回的bean类型
public class MyBean implements FactoryBean<Course> {
    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("工厂创建的课程");
        return course;
    }
    @Override
    public Class<?> getObjectType() {
        return null;
    }
}
xml：
<bean id="myBean" class="com.kpp.facbean.MyBean"></bean>
调用：
ApplicationContext context = new ClassPathXmlApplicationContext("facbean.xml");
Course myBean = context.getBean("myBean", Course.class);
System.out.println(myBean);
输出：
工厂创建的课程

IOC操作Bean管理（Bean的作用域）

1.在Spring里面可以设置创建的bean是单实例还是多实例
2.在Spring里面，默认情况下，bean是单实例
ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
Book book =context.getBean("book",Book.class);
Book book1 = context.getBean("book",Book.class);
book.show();
System.out.println(book==book1);
输出：
[三国, 西游, 红楼梦]
true
3.如何设置是单实例还是多实例
（1）在xml创建bean中用scope属性指定单实例或多实例
（2）scope属性值：
singleton（默认值）：表示是单实例对象
prototype：表示是多实例对象
改进：
<bean id="book" class="com.kpp.collectiontype.Book" scope="prototype">
    <property name="bookList" ref="bookist"></property>
</bean>
输出：
[三国, 西游, 红楼梦]
false
（3）singleton和prototype的区别：
（.）singleton是单实例，prototype是多实例
（..）设置scope值是singleton的时候，加载spring配置文件时就会自动创建实例对象
	  设置scope值是prototype的时候，不是在加载spring配置文件时候创建对象，在调用getBean方法时创建多实例对象。

IOC操作Bean管理（Bean的生命周期）

1.生命周期
（1）从对象创建到对象销毁的过程
2.bean的生命周期
（1）通过构造器创建bean实例（无参构造）
（2）为bean的属性设置值和对其他bean引用（调用set方法）
（3）调用bean的初始化方法（需要进行配置）
（4）使用bean
（5）当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）
。。。。。演示：
类：
public class Order {
    private String oname;
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("Order为bean的属性设置值和对其他bean引用（调用set方法）");
    }
    //无参构造
    public Order() {
        System.out.println("Order通过构造器创建bean实例（无参构造）");
    }
    //创建执行的初始化方法
    public void initMethod(){
        System.out.println("调用bean的初始化方法（需要进行配置）");
    }
    //创建执行的销毁方法
    public void destoryMethod(){
        System.out.println("当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）");
    }
}
配置文件：
<bean id="order" class="com.kpp.life.Order" init-method="initMethod" destroy-method="destoryMethod">
    <property name="oname" value="朱兴义的订单"></property>
</bean>
测试：
@Test
public void testlife(){
    ApplicationContext context = new ClassPathXmlApplicationContext("life.xml");
    Order order = context.getBean("order",Order.class);
    System.out.println("获取bean实例对象");
    System.out.println(order);
    //手动让bean实例销毁
    ((ClassPathXmlApplicationContext)context).close();
    //或者
    ClassPathXmlApplicationContext context1 = new ClassPathXmlApplicationContext("life.xml");
    context1.close();
}
输出：
/*
Order通过构造器创建bean实例（无参构造）
Order为bean的属性设置值和对其他bean引用（调用set方法）
调用bean的初始化方法（需要进行配置）
获取bean实例对象
com.kpp.life.Order@206a70ef
当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）
Order通过构造器创建bean实例（无参构造）
Order为bean的属性设置值和对其他bean引用（调用set方法）
调用bean的初始化方法（需要进行配置）
当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）
*/
3.bean的后置处理器，bean生命周期有7步：
（1）通过构造器创建bean实例（无参构造）
（2）为bean的属性设置值和对其他bean引用（调用set方法）
（*）把bean实例传递给后置处理器的方法：postProcessBeforeInitialization
（3）调用bean的初始化方法（需要进行配置）
（*）把bean实例传递给后置处理器的方法：postProcessAfterInitialization
（4）使用bean
（5）当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）
。。。。。。演示：
/*后置处理器类：*/
public class beanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后执行的方法");
        return bean;
    }
}
/*配置后置处理器：*/
<bean id="order" class="com.kpp.life.Order" init-method="initMethod" destroy-method="destoryMethod">
    <property name="oname" value="朱兴义的订单"></property>
</bean>
<!--配置后置处理器-->
<bean id="beanpost" class="com.kpp.life.beanPost"></bean>
/*测试：*/
public void testlife(){
    ApplicationContext context = new ClassPathXmlApplicationContext("life.xml");
    Order order = context.getBean("order",Order.class);
    System.out.println("获取bean实例对象");
    System.out.println(order);
}
输出：
/*
Order通过构造器创建bean实例（无参构造）
Order为bean的属性设置值和对其他bean引用（调用set方法）
在初始化之前执行的方法
调用bean的初始化方法（需要进行配置）
在初始化之后执行的方法
获取bean实例对象
*/

IOC操作Bean管理（xml自动装配）

1.什么是自动装配
（1）根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入
2.演示自动装配过程
（1）根据属性名称自动注入
。。。。。。演示：
原来：
<bean id="emp" class="com.kpp.autoWire.Emp" autowire="byName">
   <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.kpp.autoWire.Dept">
    <property name="dname" value="开发部"></property>
</bean>
自动装配：
<bean id="emp" class="com.kpp.autoWire.Emp" autowire="byName"></bean>
<bean id="dept" class="com.kpp.autoWire.Dept">
    <property name="dname" value="开发部"></property>
</bean>
或根据类型：
<bean id="emp" class="com.kpp.autoWire.Emp" autowire="byType"></bean>
<bean id="dept" class="com.kpp.autoWire.Dept">
    <property name="dname" value="开发部"></property>
</bean>

<!--实现自动装配-->
<!--
bean标签属性autowire，配置自动装配
autowire属性有两个值：
byName根据属性名称进行注入，注入值bean的id值和类属性名称一样
byType根据属性类型注入
-->

IOC操作Bean管理（外部属性文件）

1.直接配置数据库信息
（1）配置德鲁伊连接池
（2）引入德鲁伊连接池依赖jar包

<!--直接配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
</bean>

2.引入外部属性文件配置数据库连接池
（1）创建外部属性文件，properties格式文件，写数据库信息

（2）把外部properties属性文件引入到spring配置文件中
*在spring配置文件中引入context名称空间
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
                    https://www.springframework.org/schema/beans/spring-beans.xsd
                    http://www.springframework.org/schema/util
                    https://www.springframework.org/schema/util/spring-util.xsd
                    http://www.springframework.org/schema/context
                    https://www.springframework.org/schema/context/spring-context.xsd">
在spring配置文件使用标签引入外部属性文件
<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${prop.driverClass}"></property>
    <property name="url" value="${prop.url}"></property>
    <property name="username" value="${prop.username}"></property>
    <property name="password" value="${prop.password}"></property>
</bean>