Spring5 IOC容器管理------基于XML方式（续集）

IOC *** 作 Bean 管理 （factoryBean）

a) Spring中有两种bean，一种是普通的bean，另外一种是工厂bean（faceoryBean）
b）普通类型的bean 定义了什么类型就返回什么类型
c）工厂bean 定了的类型和返回的类型可以不一致

package com.zh.Day_02.Bean_Demo_05;
import org.springframework.beans.factory.FactoryBean;
//演示工厂bean

//    实现factoryBean这个接口
public class MyBean implements FactoryBean {
//    这个方法可以指定返回的类型
    @Override
    public Temp getObject() throws Exception {
        Temp temp = new Temp();
        temp.name="小浩浩~";
        return temp;
    }

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

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

//指定返回的类型
public class Temp {
    public String name;

    @Override
    public String toString() {
        return "Temp{" +
                "name='" + name + '\'' +
                '}';
    }
}

  <bean id="ZhouHao" class="com.zh.Day_02.Bean_Demo_05.MyBean ">bean>

//测试
public class Test {
    @org.junit.jupiter.api.Test
    public void Test_(){
        ClassPathXmlApplicationContext
                context = new ClassPathXmlApplicationContext("com/zh/Day_02/Bean_demo_05/zh.xml");
//        可以看出 xml创建的对象是MyBean 返回的是Temp
        Temp mmm= context.getBean("ZhouHao", Temp.class);
        System.out.println(mmm);
    }
}

bean作用域

a) Spring中 默认的是一个单例的对象

public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext
                context = new ClassPathXmlApplicationContext("com/zh/Day_02/Bean_demo_06/zh.xml");
        Dome dome1 = context.getBean("Dome", Dome.class);
        Dome dome2 = context.getBean("Dome", Dome.class);
        System.out.println(dome1);
        System.out.println(dome2);
//        默认的对象是单例的 所以地址值是一样的
//        com.zh.Day_02.Bean_Demo_06.Dome@1e127982
//        com.zh.Day_02.Bean_Demo_06.Dome@1e127982

    }
}

b）通过scope 标签来设置是否是单例对象

    <bean id="Dome" class="com.zh.Day_02.Bean_Demo_06.Dome" scope="singleton">bean>

c）singleton 和 prototype 的区别
singleton 是单例的 、 prototype是多实例的
singleton 在加载 spring xml 文件的时候会创建对象
prototype 加载xml 不会创建对象 在调用getBean() 方法的时候才会创建对象

bean的生命周期

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

demo:

//演示 bean的生命周期
public class AAA {
    public String name;


    public AAA() {
        System.out.println("第一步 会调用这个对象的无参构造方法");
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("第二步 会调用这个set的属性方法");
    }
//    创建 初始化方法
    public void  initMethod(){
        System.out.println("第三步 调用这个初始化方法");
    }
//    创建 销毁方法
    public void destroyMethod(){
        System.out.println("第五步 执行这个销毁方法");
    }
}

    <bean id="AAA" class="com.zh.Day_02.Bean_Demo_07.AAA" init-method="initMethod" destroy-method="destroyMethod" >
        <property name="name" value="小浩纸~~">property>
    bean>

public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext
                context = new ClassPathXmlApplicationContext("com/zh/Day_02/Bean_demo_07/zh.xml");
        AAA aaa = context.getBean("AAA", AAA.class);
        System.out.println("第四步 获取创建bean实例对象");
//        手动调用这个销毁方法
        aaa.destroyMethod();
        /*  第一步 会调用这个对象的无参构造方法
            第二步 会调用这个set的属性方法
            第三步 调用这个初始化方法
            第四步 获取创建bean实例对象
            第五步 执行这个销毁方法*/

    }
}

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

IOC *** 作 Bean 管理 （引入外部属性文件）

方式一 直接配置数据库信息：1、配置druid 连接池 2、引入 druid依赖

        
        <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>

方式二 引入外部属性文件配置数据库连接池

1、创建外部 properties文件

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.userName=root
prop.password=root

2.把外部 properties 属性文件引入到 spring 配置文件中 —— 引入 context 名称空间

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       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">


        <context:property-placeholder location="classpath:com/zh/Day_02/Bean_Demo_08/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>
beans>