Spring——IOC（Inversion of Control）容器（2）

IOC（Inversion of Control）容器（2）

1、IOC 操作 Bean 管理（FactoryBean）

Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）：

1. 普通 bean：在配置文件中定义 bean 类型就是返回类型
2. 工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样

第一步：创建类，让这个类作为工厂 bean，实现接口 FactoryBean

import org.springframework.beans.factory.FactoryBean;
import spring5.collectiontype.Course;

public class MyBean implements FactoryBean<Course> {
    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }

    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }
}

第二步：实现接口里面的方法，在实现的方法中定义返回的 bean 类型

<bean id="myBean" class="spring5.factorybean.MyBean"></bean>

测试代码：

@Test
public void testCollection3() {
	ApplicationContext applicationContext =
		new ClassPathXmlApplicationContext("bean3.xml");
	Course course = applicationContext.getBean("myBean", Course.class);

	System.out.println(course); //Course{cname='abc'}
}

---

2、IOC 操作 Bean 管理（bean 作用域）

1. 在 Spring 里面，设置创建 bean 实例是单实例还是多实例
2. 在 Spring 里面，默认情况下， bean 是单实例对象

@Test
public void testCollection2() {
    ApplicationContext applicationContext =
            new ClassPathXmlApplicationContext("bean2.xml");
    Book book1 = applicationContext.getBean("book", Book.class);

    Book book2 = applicationContext.getBean("book", Book.class);
    
    //book.add();
    System.out.println(book1);	//spring5.collectiontype.Book@5db6b9cd
    System.out.println(book2);	//spring5.collectiontype.Book@5db6b9cd
}

地址相同，证明是一个单实例对象。

如何设置是单实例还是多实例：

• 在 spring 配置文件 bean 标签里面有属性（ scope）用于设置单实例还是多实例

• scope 属性值

  第一个值：默认值， singleton，表示是单实例对象

  第二个值：prototype，表示是多实例对象

<bean id="book" class="spring5.collectiontype.Book" scope="prototype">
    <property name="list" ref="bookList"></property>
</bean>

@Test
public void testCollection2() {
    ApplicationContext applicationContext =
            new ClassPathXmlApplicationContext("bean2.xml");
    Book book1 = applicationContext.getBean("book", Book.class);

    Book book2 = applicationContext.getBean("book", Book.class);
    
    //book.add();
    System.out.println(book1);	//spring5.collectiontype.Book@5db6b9cd
    System.out.println(book2);	//spring5.collectiontype.Book@210ab13f
}

地址不同，证明是一个多实例对象。

singleton 和 prototype 区别：

1. singleton 单实例， prototype 多实例；

2. 设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象

   设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建对象，在调用 getBean 方法时候创建多实例对象

---

3、IOC 操作 Bean 管理（bean 生命周期）

3.1、什么是生命周期？

从对象创建到对象销毁的过程

3.2、bean 生命周期

1. 通过构造器创建 bean 实例（无参数构造）
2. 为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
3. 调用 bean 的初始化的方法（需要进行配置初始化的方法）
4. bean 可以使用了（对象获取到了）
5. 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

3.3、演示 bean 生命周期

创建 order 类：

public class Orders {

    //无参数构造
    public Orders() {
        System.out.println("第一步 执行无参数构造创建bean实例");
    }

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步 调用set方法设置属性的值");
    }

    //创建执行的初始化的方法
    public void initMethod() {
        System.out.println("第三步 执行初始化的方法");
    }

    //销毁的方法
    public void destroyMethod() {
        System.out.println("第五步 执行销毁的方法");
    }
}

创建 spring 配置文件：

<bean id="orders" class="spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
    <property name="oname" value="手机"></property>
</bean>

测试代码：

@Test
public void testbean3() {
    ApplicationContext applicationContext =
            new ClassPathXmlApplicationContext("bean4.xml");
    Orders orders = applicationContext.getBean("orders", Orders.class);

    System.out.println("第四步 获取创建bean实例对象");
    System.out.println(orders);

    //手动执行的销毁方法
    ((ClassPathXmlApplicationContext) applicationContext).close();
}
/*
第一步 执行无参数构造创建bean实例
第二步 调用set方法设置属性的值
第三步 执行初始化的方法
第四步 获取创建bean实例对象
spring5.bean.Orders@61c4eee0
第五步 执行销毁的方法
*/

3.4、bean 的后置处理器， bean 生命周期有七步

1. 通过构造器创建 bean 实例（无参数构造）
2. 为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
3. 把 bean 实例传递 bean 后置处理器的方法：postProcessBeforeInitialization
4. 调用 bean 的初始化的方法（需要进行配置初始化的方法）
5. 把 bean 实例传递 bean 后置处理器的方法：postProcessAfterInitialization
6. bean 可以使用了（对象获取到了）
7. 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

创建类，实现接口 BeanPostProcessor，创建后置处理器：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化执行之后执行的方法");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

修改 spring 配置文件：

<bean id="orders" class="spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
    <property name="oname" value="手机"></property>
</bean>

<!--配置后置处理器-->
<bean id="myBeanPost" class="spring5.bean.MyBeanPost"></bean>

执行测试代码：

第一步 执行无参数构造创建bean实例
第二步 调用set方法设置属性的值
在初始化之前执行的方法
第三步 执行初始化的方法
在初始化执行之后执行的方法
第四步 获取创建bean实例对象
spring5.bean.Orders@3f4faf53
第五步 执行销毁的方法

---

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

4.1、什么是自动装配？

根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入。

4.2、演示自动装配过程

（1）根据属性名称自动注入

<!--实现自动装配
    bean标签属性autowire，配置自动装配
    autowire属性常用两个值：
        byName根据属性名称注入，注入值bean的id值和类属性名称要一样
        byType根据属性类型注入
 -->
<bean id="emp" class="spring5.autowire.Emp" autowire="byName">
    <!--<property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="spring5.autowire.Dept"></bean>

（2）根据属性类型自动注入

<!--实现自动装配
    bean标签属性autowire，配置自动装配
    autowire属性常用两个值：
        byName根据属性名称注入，注入值bean的id值和类属性名称要一样
        byType根据属性类型注入
 -->
<bean id="emp" class="spring5.autowire.Emp" autowire="byType">
    <!--<property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="spring5.autowire.Dept"></bean>

---

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

5.1、直接配置数据库信息

（1）配置德鲁伊连接池

（2）引入德鲁伊连接池依赖 jar 包

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

5.2、引入外部属性文件配置数据库连接池

（1）创建外部属性文件， properties 格式文件，写数据库信息：

prop.driver = com.mysql.jdbc.Driver
prop.url = jdbc:mysql:///user_db
prop.userName = root
prop.password = root

（2）把外部 properties 属性文件引入到 spring 配置文件中：

引入 context 名称空间：

<?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:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
                           http://www.springframework.org/schema/context http://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="url" value="${prop.url}" />
    <property name="username" value="${prop.userName}" />
    <property name="password" value="${prop.password}" />
    <property name="driverClassName" value="${prop.driver}" />
</bean>