Spring5（三）——DI

一、装配Bean

1、介绍

　　在spring容器内拼凑bean叫做装配。装配bean的时候，需要告诉容器有哪些bean以及容器如何使用依赖注入将它们配合在一起。
　　使用XML装配，XML是最常见的spring应用系统配置源。几种spring容器都支持使用XML装配bean，包括：
　　XmlBeanFactory：调用ClassPathResource载入上下文定义文件(比如applicationContext.xml)。
　　ClassPathXmlApplicationContext：从类路径载入上下文定义文件。
　　XmlWebApplicationContext：从web应用上下文中载入定义文件。

2、实例化与销毁

　　spring实例化bean或销毁bean时，有时需要作一些处理工作，因此spring可以在创建和拆卸bean的时候调用bean的两个生命周期方法。
　　// 非注解的方式

<bean class="Foo" init-method="function-name" destory-method="function-name">

　　// 注解的方式

@PostConstruct public void init(){…}
@PreDestroy public void destroy(){…}

　　注意：注解的方式，bean只能扫描注入，不能与配置的方式混合用。且注解时步骤7、8顺序（bean的生命周期中的步骤）似乎有差别。

<bean class="...CommonAnnotationBeanPostProcessor">

　　spring也提供了两个接口来实现相同的功能：InitializingBean和DisposableBean，不推荐使用该接口，它将你的bean和springAPI邦定在一起，他们是一对。定制化是一对。

3、自动装配

　　Spring Ioc容器可以自动装配（autowire）相互协作bean之间的关联关系。因此，可以自动让Spring通过检查BeanFactory中的内容来替我们指定bean的协作者。autowire的方便之处在减少或者消除属性或构造器参数的设置。

模式	描述
no	不自动装配
byName	根据属性名自动装配。检查容器并根据名字查找与属性名完全一致的bean，将其与属性自动装配。
byType	根据类型自动装配。检查容器中存在一个与指定属性类型相同的bean，将其与属性自动装配。
constructor	应用于构造参数。查找和bean的构造参数一致的一个或多个bean，若找不到或找到多个，抛异常。按照参数的类型装配。
autodetect	自动检测装配。先constructor后byType。
default	这个需要在   当在指定了default-atuowrite后，所有的bean的默认的autowire就是指定的装配方法。不写，则默认是defualt-autorwire=“no”

　　bean的autowire不写，即autowire="default"，表明模式跟随default-atuowrite
　　bean的autowire指定，此时以bean的autowire为准。

　　若default-atuowrite不写，即default-atuowrite="no"，表明不自动装配。
　　若default-atuowrite指定，所有的bean的默认的autowire就是指定的装配方法。

public class Master {
    private String name;
    private Dog myDog;

    public Master() {
        System.out.println("====Master()====");
    }

    public Master(Dog dog) {
        System.out.println("====Master(Dog dog)====");
        this.myDog = dog;
    }

   // getter && setter
}

public class Dog {
   private String name;
   private int age;

   // getter && setter
}

application.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-4.3.xsd"
       default-autowire="byName"
>

    <bean id="master" class="com.lx.test8.Master">
        <property name="name" value="小明"/>
        <!-- <property name="dog" ref="a"/> -->
    </bean>

    <bean id="myDog" class="com.lx.test8.Dog">
        <property name="name" value="大黄"/>
        <property name="age" value="3"/>
    </bean>

</beans>

public class Test {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
        Master master = app.getBean(Master.class);
        System.out.println(JSON.toJSONString(master));
    }
}

// ====Master()====
// {"myDog":{"age":3,"name":"大黄"},"name":"小明"}

　　这里是按名字（id = 属性名）装配。其他情况修改测试一下即可。

二、DI

1、set方式注入

　　<bean>元素的<property>子元素指明了使用它们的set方法来注入。

public class Department {
    private String name;
    private String[] strArray; // 数组
    private List<Employee> empList; // list集合
    private Set<Employee> empSet; // set集合
    private Map<String, Employee> empMap; // map集合
    private Properties properties; // Properties的使用
    private List<String> listStr; // list集合
    
    // getter && setter
}
public class Employee {
    private String name;
    private int id;

    // getter && setter
}

application.xml

<bean id="emp1" class="com.lx.spring.day1.Employee">
    <property name="name" value="张三"/>
    <property name="id" value="20200001"/>
</bean>

<bean id="emp2" class="com.lx.spring.day1.Employee">
    <property name="name" value="李四"/>
    <property name="id" value="20200002"/>
</bean>

<bean id="department" class="com.lx.spring.day1.Department">
    <property name="name" value="财务部"/>
    <!--  <property name="name"><null/></property>  注入null-->

    <!-- 给数组注入值 -->
    <property name="strArray">
        <list>
            <value>strArray1</value>
            <value>strArray2</value>
            <value>strArray3</value>
        </list>
    </property>
    <!-- 给list注入值.有序 -->
    <property name="empList">
        <list>
            <ref bean="emp2"/>
            <ref bean="emp1"/>
            <ref bean="emp1"/>
            <bean class="com.lx.spring.day1.Employee">
                <property name="name" value="配置的bean"/>
                <property name="id" value="2020"/>
            </bean>
        </list>
    </property>
    <!-- 给set注入值.无序.不重复 -->
    <property name="empSet">
        <set>
            <ref bean="emp1"/>
            <ref bean="emp2"/>
            <ref bean="emp2"/>
        </set>
    </property>
    <!-- 给map注入值. -->
    <property name="empMap">
        <map>
            <entry key="11" value-ref="emp1"/>
            <entry key="22" value-ref="emp2"/>
            <entry key="22" value-ref="emp1"/>
        </map>
    </property>
    <!-- 给属性集合配置 -->
    <property name="properties">
        <props>
            <prop key="pp1">abcd</prop>
            <prop key="pp2">hello</prop>
        </props>
    </property>
</bean>

public class Main {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("app1.xml");
        Department department = (Department) app.getBean("department");
        System.out.println(department.getName());

        System.out.println("-------取出strArray-------");
        for (String s : department.getStrArray()) {
            System.out.println(s);
        }

        System.out.println("-------取出empList-------");
        for (Employee e : department.getEmpList()) {
            System.out.println(e.toString());
        }

        System.out.println("-------取出empSet-------");
        for (Employee e : department.getEmpSet()) {
            System.out.println(e.toString());
        }

        System.out.println("-------取出empMap-迭代器-------");
        Map<String, Employee> empMap = department.getEmpMap();
        Iterator<String> iterator = empMap.keySet().iterator();

        while (iterator.hasNext()) {
            String key = iterator.next();
            Employee e = empMap.get(key);
            System.out.println("key=" + key + "  " + e.toString());
        }

        System.out.println("-------取出empMap-for-------");
        for (Map.Entry<String, Employee> entry : department.getEmpMap().entrySet()) {
            System.out.println("key=" + entry.getKey() + "  " + entry.getValue().toString());
        }

        System.out.println("-------取出properties-for-------");
        Properties properties = department.getProperties();
        for (Map.Entry<Object, Object> entry : properties.entrySet()) {
            System.out.println("key=" + entry.getKey() + " " + entry.getValue());
        }

        System.out.println("-------取出properties-Enumeration-------");
        Enumeration<Object> enumeration = properties.keys();
        while (enumeration.hasMoreElements()) {
            String key = (String) enumeration.nextElement();
            System.out.println(key + " " + properties.getProperty(key));
        }
    }
}

　　把集合注入部分提取出来

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       
       <!--1.引入名称空间 util-->
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd

       http://www.springframework.org/schema/util
       http://www.springframework.org/schema/util/spring-util-4.3.xsd">

    <!--2.提取公共片段-->
    <util:list id="partListStr">
        <value>易筋经</value>
        <value>九阴真经</value>
        <value>九阳神功</value>
    </util:list>

    <!--3.注入-->
    <bean id="depart" class="com.lx.spring.day1.Department">
        <property name="listStr" ref="partListStr"/>
    </bean>

</beans>

2、继承方式注入

// 父类
public class Person {
    private String name;
    private int age;
    // getter && setter
}

public class Student extends Person {
    private String degree;
   // getter && setter
}

application.xml
<bean id="person" class="com.lx.test6.Person">
    <property name="name" value="人"/>
    <property name="age" value="21"/>
</bean>

<bean id="student" parent="person" class="com.lx.test6.Student">
    <!-- 会覆盖从父类继承的属性 -->
    <property name="name" value="小明"/>
    <property name="degree" value="学士"/>
</bean>

public class Test {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
        Student student = app.getBean(Student.class);
        System.out.println(JSON.toJSONString(student));
    }
}

// {"age":21,"degree":"学士","name":"小明"}

3、构造器方式注入

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
   // getter && setter
}

application.xml
<bean id="student" class="com.lx.test6.Student">
    <!-- 通过构造函数来注入属性值 -->
    <constructor-arg index="0" type="java.lang.String" value="学生"/>
    <constructor-arg index="1" type="int" value="22"/>
</bean>

public class Test {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
        Student student = app.getBean(Student.class);
        System.out.println(JSON.toJSONString(student));
    }
}

// {"age":22,"name":"学生"}

　　这种方式，set注入的缺点是无法清晰表达哪些属性是必须的，哪些是可选的，构造注入的优势是通过构造强制依赖关系，不能实例化不完全的或无法使用的bean。

4、p名称空间方式注入（了解）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       
       <!-- 1.添加p名称空间 -->
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

    <!-- 2.通过p名称空间方式注入属性值 -->
    <bean id="t" class="com.lx.spring.day2.Teacher" p:name="张无忌" p:age="40"/>

</beans>

5、FactoryBean（工厂bean）

　　在配置文件定义bean类型可以和返回类型不一样。

public class MyBean implements FactoryBean<Teacher> {

    // 定义返回bean
    @Override
    public Teacher getObject() throws Exception {
        Teacher teacher = new Teacher();
        teacher.setAge(666);
        teacher.setName("武天老师");
        return teacher;
    }

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

    @Override
    public boolean isSingleton() {
        return false;
    }
}

<bean id="myBean" class="com.lx.spring.day4.MyBean"/>

// 测试类
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("app4.xml");
        Teacher teacher = (Teacher) context.getBean("myBean");
        System.out.println(JSON.toJSONString(teacher));
    }
}

// 结果
{"age":666,"name":"武天老师"}

三、分散配置（引入属性文件）

　　代码示例：引入属性文件的两种方式

// db1.properties
name=db1
drivername=oracle
url=jdbc:oracle:thin:@127.0.0.1:1521:
pwd=123456

// application.xml
// 方式一
<context:property-placeholder location="classpath:db1.properties,classpath:db2.properties"/>

// 方式二
<bean id="configurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
        <list>
            <value>classpath:db1.properties</value>
            <value>classpath:db2.properties</value>
        </list>
    </property>
</bean>

<!-- $ 占位符获取属性变量的值 -->
<bean id="dBUtil1" class="com.lx.test8.DBUtil">
    <property name="name" value="${name}"/>
    <property name="drivername" value="${drivername}"/>
    <property name="url" value="${url}"/>
    <property name="pwd" value="${pwd}"/>
</bean>