`IOC`中`Bean`生命周期及引入外部属性文件

IOC中Bean生命周期

Bean生命周期【重点】

1. 通过构造器创建bean对象实例(无参构造)
2. 为JavaBean的属性设置值和对象其他bean引用赋值（调用stter方法）
3. 调用bean的初始化方法（需要进行配置初始化方法）
4. bean可以使用了（对象获取到了）
5. 当容器关闭时，调用bean的销毁方法（需要进行配置销毁的方法，注意是需要手动关闭容器，注意是ApplicationContext中关闭方法，需要使用子类ClassPathXmlApplicationContext中的close方法）

javabean类

public class Orders {
    private String name;

    public Orders() {
        System.out.println("1.无构造器被执行了。。。");
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("2.set方法被执行了");
    }

    public void initMethod(){
        System.out.println("3.初始化方法被执行了");
    }

    public void destroyMethod(){
        System.out.println("5.销毁方法被执行了");
    }
}

xml文件

<!--
        Bean生命周期
    -->
    <bean id="order" class="com.haikang.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="name" value="电脑"/>
    </bean>

test方法

@Test
    public void test(){
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        Orders order = context.getBean("order", Orders.class);
        System.out.println("4.获取Bean对象了");
        System.out.println(order);
        // 注意是：要想销毁方法被执行，
        // 必须自动手动关闭流，因为当容器销毁时，还没有来的及执行销毁方法，所以需要我们手动关闭
        // ApplicationContext注意没有关闭方法，
        // ApplicationContext的子类ClassPathXmlApplicationContext才有，需要向下强转
        context.close();
    }

Bean生命周期加上Bean后置处理器，Bean生命周期有七步

前提是：定义一个类并实现BeanPostProcessor接口

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

添加后置处理器步骤：
添加后置处理器步骤：

1. 定义一个类，并且实现接口BeanPostProcessor，重写类中的postProcessBeforeInitialization方法和postProcessAfterInitalization方法，并且在这个两个方法中添加相关业务逻辑
2. xml文件中配置该为后置处理器类
3. 测试

1. 创建一个类，实现接口BeanPostProcessor

package com.haikang.bean;

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

/**
 * @Author 海康
 * @Version 1.0
 */
public class MyBeanPost 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;
    }
}

2. 在xml配置文件中，配置该类作为后置处理器

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

注意是：后置处理器只对同一个xml文件中的javabean起作用，如果与后置处理器的配置不在同一个xml文件则不作用，如下只有orders类才起作用，因为在一个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">
    <!--
        Bean生命周期
    -->
    <bean id="order" class="com.haikang.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="name" value="电脑"/>
    </bean>
    <!--配置后置处理器类-->
    <bean id="myBeanPost" class="com.haikang.bean.MyBeanPost"/>
</beans>

后置处理器

package com.haikang.bean;

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

/**
 * @Author 海康
 * @Version 1.0
 */
public class MyBeanPost 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;
    }
}

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">
    <!--
        Bean生命周期
    -->
    <bean id="order" class="com.haikang.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="name" value="电脑"/>
    </bean>
    <!--配置后置处理器类-->
    <bean id="myBeanPost" class="com.haikang.bean.MyBeanPost"/>
</beans>

test类

@Test
    public void test(){
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        Orders order = context.getBean("order", Orders.class);
        System.out.println("4.获取Bean对象了");
        System.out.println(order);
        // 注意是：要想销毁方法被执行，
        // 必须自动手动关闭流，因为当容器销毁时，还没有来的及执行销毁方法，所以需要我们手动关闭
        // ApplicationContext注意没有关闭方法，
        // ApplicationContext的子类ClassPathXmlApplicationContext才有，需要向下强转
        context.close();
    }

IOC操作Bean管理引入外部属性文件【用于数据库信息配置】

Spring注入JDBCTemplate对象

注入步骤

1. 引入相关jar包

   druid mysql-connector spring-jdbc spring-tx spring-orm包

2. 创建数据库连接池properties文件

3. 在spring配置文件中引入peroperties文件和配置数据库池

4. 配置JdbcTemplate对象，注入DataSource对象属性

5. 测试获取JdbcTemplate对象

第一步：引入相关jar包

druid，mysql-connector srping-jdbc spring-tx spring-orm

第二步：创建数据库连接池properties文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=root

第三步：在spring配置文件中引入peroperties文件和配置数据库池

第四步：配置JdbcTemplate对象，注入DataSource对象属性

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                                                                                                                ">
    <!--引入context命名空间,引入jdbc.properties数据库连接池基本信息-->
    <context:property-placeholder location="jdbc.properties"/>
    <!--注入数据源对象属性DruidDataSource-->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--配置JdbcTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="druidDataSource"/>
    </bean>
    
<!--开启组件扫描，使用注解注入-->
    <context:component-scan base-package="com.haikang.jdbc.dao"/>
</beans>

第五步：测试获取JdbcTemplate对象

    public static void main(String[] args) {
        ApplicationContext context = new
                ClassPathXmlApplicationContext("JdbcTemplateBean.xml");
        JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);
        System.out.println(jdbcTemplate);
    }