0x01 什么是依赖注入

依赖注入,是IOC的一个功能,是个通常的概念,它有多种解释
这概念是说你不用创建对象,而只需要描述它如何被创建
你不在代码里直接组装你的组件和服务,而是在配置文件里描述哪些组件需要哪些服务之后一个容器(IOC容器)负责把他们组装起来

0x02 依赖注入的方式

能注入的数据-有三类:
1. 基本类型和String
2. 其他bean类型(在配置文件中或者注解配置过的bean)
3. 复杂类型/集合类型。
注入的方式-有三种:
1. 构造函数注入
2. Set方式注入
3. 注解注入

0x03 小例子-xml文件-构造函数注入

0x03.1 描述

顾名思义,就是使用类中的构造函数,给成员变量赋值
注: 赋值的操作不是我们自己做的,而是通过配置的方式,让Spring框架来为我们注入
优点: 
基于构造器注入,会固定依赖注入的顺序
不允许我们创建的Bean对象之间存在循环依赖关系,这样Spring能解决循环依赖的问题
缺点:
使用构造器注入的缺点是当我们构造器需要注入的对象比较多时
会显得我们的构造器,冗余,不美观,可读性差,也不易维护

标签有如下属性
属性	描述
type	用于指定要注入的数据的数据类型,该数据类型也是构造函数中某个或某些参数的类型
index	用于指定要注入的数据给构造函数中指定索引位置的参数赋值,索引的位置是从0开始
name	用于指定给构造函数中指定名称的参数赋值
value	用于提供基本类型和String类型的数据
ref	用于指定其他的bean类型数据,它指的就是在Spring的IOC核心容器中出现过的Bean对象

0x03.2 默认构造器方式

// 第一步
// 在./SpringDemo/src/main/java/com/test/依赖注入/构造函数注入/User.java
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/构造函数注入/
// 文件名: User.java
package com.test.依赖注入.构造函数注入;
public class User {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

// 第二步
// 在<beans>标签中,中配置userTest1的信息, 设定name的值为“张三”
// 这里提供一个配置好的applicationContext6.xml文件
// 目录: ./SpringDemo/src/main/resources/
// 文件名: applicationContext6.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
                           https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--默认构造器方式-->
    <bean id="userTest1" class="com.test.依赖注入.构造函数注入.User1">
        <property name="name" value="张三"/>
    </bean>
</beans>

// 第三步
// 创建一个测试类Test13进行测试
// 目录: ./SpringDemo/src/test/java/
// 文件名: Test13.java
import com.test.依赖注入.构造函数注入.User1;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test13 {
    public static void main(String[] args) {
        AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext6.xml");
        User1 obj = (User1) context.getBean("userTest1");
        System.out.println(obj.getName());
    }
}
// 运行结果
张三

0x03.3 有参构造创建对象

0x03.3.1 前置操作

// 在./SpringDemo/src/main/resources/创建个applicationContext6.xml
// 目录: ./SpringDemo/src/main/resources/
// 文件名: applicationContext6.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
                           https://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

// 在./SpringDemo/src/main/java/com/test/依赖注入/构造函数注入/创建个User2.java
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/构造函数注入/
// 文件名: User2.java
package com.test.依赖注入.构造函数注入;
public class User2 {
    private String name;
    private Integer age;
    public User2(String name) {
        this.name = name;
    }
    public User2(Integer age) {
        this.age = age;
    }
    public User2(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return this.name;
    }
    public Integer getAge() {
        return this.age;
    }
}

0x03.3.2 有参构造创建对象-下标赋值注入

// 第一步
// 目录: ./SpringDemo/src/main/resources/
// 文件名: applicationContext6.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
                           https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--有参构造创建对象-下标赋值,不建议使用-->
    <bean id="userTest2" class="com.test.依赖注入.构造函数注入.User2">
        <constructor-arg index="0" value="李四"/>
        <constructor-arg index="1" value="11"/>
    </bean>
</beans>

// 第二步
// 创建一个测试类Test14进行测试
// 目录: ./SpringDemo/src/test/java/
// 文件名: Test14.java
import com.test.依赖注入.构造函数注入.User2;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test14 {
    public static void main(String[] args) {
        AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext6.xml");
        User2 obj = (User2) context.getBean("userTest2");
        System.out.println(obj.getName());
        System.out.println(obj.getAge());
    }
}
// 运行结果
李四
11

0x03.3.3 有参构造创建对象-数据类型注入

// 第一步
// 目录: ./SpringDemo/src/main/resources/
// 文件名: applicationContext6.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
                           https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--有参构造创建对象-数据类型,不建议使用-->
    <bean id="userTest2-2" class="com.test.依赖注入.构造函数注入.User2">
        <constructor-arg type="java.lang.Integer" value="15"/>
        <constructor-arg type="java.lang.String" value="王五"/>
    </bean>
</beans>

// 第二步
// 创建一个测试类Test15进行测试
// 目录: ./SpringDemo/src/test/java/
// 文件名: Test15.java
import com.test.依赖注入.构造函数注入.User2;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test15 {
    public static void main(String[] args) {
        AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext6.xml");
        User2 obj = (User2) context.getBean("userTest2-2");
        System.out.println(obj.getName());
        System.out.println(obj.getAge());
    }
}
// 运行结果
王五
15

0x03.3.4 有参构造创建对象-参数名注入

// 第一步
// 目录: ./SpringDemo/src/main/resources/
// 文件名: applicationContext6.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
                           https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--有参构造创建对象-参数名注入,推荐使用-->
    <bean id="userTest2-3" class="com.test.依赖注入.构造函数注入.User2">
        <constructor-arg name="name" value="马六"/>
        <constructor-arg name="age" value="18"/>
    </bean>
</beans>

// 第二步
// 创建一个测试类Test16进行测试
// 目录: ./SpringDemo/src/test/java/
// 文件名: Test16.java
import com.test.依赖注入.构造函数注入.User2;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test16 {
    public static void main(String[] args) {
        AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext6.xml");
        User2 obj = (User2) context.getBean("userTest2-3");
        System.out.println(obj.getName());
        System.out.println(obj.getAge());
    }
}
// 运行结果
马六
18

0x03.3.5 有参构造创建对象-对象注入

// 第一步
// 创建个SpellChecker类,给其它类使用
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/构造函数注入/
// 文件名: SpellChecker.java
package com.test.依赖注入.构造函数注入;
public class SpellChecker {
    public SpellChecker() {
        System.out.println("SpellChecker内部-无参构造函数");
    }
    public void checkSpelling() {
        System.out.println("拼写检查");
    }
}

// 第二步
// 创建个TextEditor类,在构造方法中引用SpellChecker类
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/构造函数注入/
// 文件名: TextEditor.java
package com.test.依赖注入.构造函数注入;
public class TextEditor {
    private SpellChecker spellChecker;
    public TextEditor(SpellChecker spellChecker) {
        System.out.println("TextEditor内部-有参构造函数");
        this.spellChecker = spellChecker;
    }
    public void spellCheck() {
        this.spellChecker.checkSpelling();
    }
}

// 第三步
// 目录: ./SpringDemo/src/main/resources/
// 文件名: applicationContext6.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
                           https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--textEditor bean的定义-->
    <bean id="spellCheckerTest" class="com.test.依赖注入.构造函数注入.SpellChecker"/>
    <!--有参构造创建对象-对象注入,推荐使用-->
    <bean id="textEditorTest" class="com.test.依赖注入.构造函数注入.TextEditor">
        <constructor-arg ref="spellCheckerTest"/>
    </bean>
</beans>

// 第四步
// 创建一个测试类Test17进行测试
// 目录: ./SpringDemo/src/test/java/
// 文件名: Test17.java
import com.test.依赖注入.构造函数注入.TextEditor;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test17 {
    public static void main(String[] args) {
        AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext6.xml");
        TextEditor te = (TextEditor) context.getBean("textEditorTest");
        te.spellCheck();
    }
}
// 运行结果
SpellChecker内部-无参构造函数
TextEditor内部-有参构造函数
拼写检查

0x04 小例子-xml文件-Set方式注入

0x04.1 描述

顾名思义,就是在类中提供需要注入成员的set方法

标签有如下属性
属性	描述
name	用于指定注入时所调用的set方法名称
value	用于提供基本类型和String类型的数据
ref	用于指定其他的bean类型数据,它指的就是在Spring的IOC核心容器中出现过的Bean对象

0x04.2 普通模式

// 第一步
// 在./SpringDemo/src/main/java/com/test/依赖注入/Set方式注入/创建个User3.java
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/Set方式注入/
// 文件名: User3.java
package com.test.依赖注入.Set方式注入;
public class User3 {
    private String name;
    private Integer age;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Integer getAge() {
        return this.age;
    }
}

// 第二步
// 目录: ./SpringDemo/src/main/resources/
// 文件名: applicationContext7.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
                           https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userTest3" class="com.test.依赖注入.Set方式注入.User3">
        <property name="name" value="陈七"></property>
        <property name="age" value="23"></property>
    </bean>
</beans>

// 第三步
// 创建一个测试类Test18进行测试
// 目录: ./SpringDemo/src/test/java/
// 文件名: Test18.java
import com.test.依赖注入.Set方式注入.User3;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test18 {
    public static void main(String[] args) {
        AbstractApplicationContext context = new ClassPathXmlApplicationContext("applicationContext7.xml");
        User3 obj = (User3) context.getBean("userTest3");
        System.out.println(obj.getName());
        System.out.println(obj.getAge());
    }
}
// 运行结果
陈七
23

0x04.3 复杂类型的注入

顾名思义,就是给类中的集合成员传值,它用的也是set方法注入的方式,只不过变量的数据类型都是集合
注入的类型有: 
String
class对象
String[]
List<String>
Map<String, String>
Set<String>
Properties

// 第一步
// 在./SpringDemo/src/main/java/com/test/依赖注入/Set方式注入/创建个Person.java
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/Set方式注入/
// 文件名: Person.java
package com.test.依赖注入.Set方式注入;
public class Person {
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Integer getAge() {
        return this.age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + this.name + "', " +
                "age='" + this.age + "'" +
                "}";
    }
}

// 第二步
// 在./SpringDemo/src/main/java/com/test/依赖注入/Set方式注入/创建个Student.java
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/Set方式注入/
// 文件名: Student.java
package com.test.依赖注入.Set方式注入;
import java.util.*;
public class Student {
    private String name;
    private Person person;
    private String[] arr;
    private List<String> myList;
    private Map<String, String> myMap;
    private Set<String> mySet;
    private String wife;
    private Properties myPro;
    public void setName(String name) {
        this.name = name;
    }
    public void setPerson(Person person) {
        this.person = person;
    }
    public void setArr(String[] arr) {
        this.arr = arr;
    }
    public void setMyList(List<String> myList) {
        this.myList = myList;
    }
    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }
    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }
    public void setWife(String wife) {
        this.wife = wife;
    }
    public void setMyPro(Properties myPro) {
        this.myPro = myPro;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + this.name + "', " +
                "person=" + this.person.toString() + ", " +
                "arr=" + Arrays.toString(this.arr) + ", " +
                "myList=" + this.myList + ", " +
                "myMap=" + this.myMap + ", " +
                "mySet=" + this.mySet + ", " +
                "wife='" + this.wife + "', " +
                "myPro=" + this.myPro + "" +
                "}";
    }
}

// 第三步
// 目录: ./SpringDemo/src/main/resources/
// 文件名: applicationContext8.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
                           https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="personTest" class="com.test.依赖注入.Set方式注入.Person">
        <property name="name" value="马八"/>
        <property name="age" value="12"/>
    </bean>
    <bean id="studentTest" class="com.test.依赖注入.Set方式注入.Student">
        <!--普通值注入,value: 具体属性值-->
        <property name="name" value="何九"/>
        <!--Bean注入, ref: 对象-->
        <property name="person" ref="personTest"/>
        <!--数组注入-->
        <property name="arr">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>
        <!--List注入-->
        <property name="myList">
            <list>
                <value>111</value>
                <value>222</value>
                <value>333</value>
            </list>
        </property>
        <!--Map注入-->
        <property name="myMap">
            <map>
                <entry key="ddd" value="dddd"></entry>
                <entry key="fff" value="ffff"></entry>
                <entry key="ggg" value="gggg"></entry>
            </map>
        </property>
        <!--Set注入-->
        <property name="mySet">
            <set>
                <value>111</value>
                <value>222</value>
                <value>333</value>
            </set>
        </property>
        <!--null注入-->
        <property name="wife">
            <null/>
        </property>
        <!--Properties注入-->
        <property name="myPro">
            <props>
                <prop key="hhh">hhhh</prop>
                <prop key="iii">iiii</prop>
                <prop key="qqq">qqqq</prop>
            </props>
        </property>
    </bean>
</beans>

// 第四步
// 创建一个测试类Test19进行测试
// 目录: ./SpringDemo/src/test/java/
// 文件名: Test19.java
import com.test.依赖注入.Set方式注入.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test19 {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext8.xml");
        Student student = (Student) context.getBean("studentTest");
        System.out.println(student.toString());
    }
}
// 运行结果
Student{name='何九', person=Person{name='马八', age='12'}, arr=[AAA, BBB, CCC], myList=[111, 222, 333], myMap={ddd=dddd, fff=ffff, ggg=gggg}, mySet=[111, 222, 333], wife='null', myPro={qqq=qqqq, iii=iiii, hhh=hhhh}}

0x04.4 p与c命名空间注入

0x04.4.1 前置操作

注意: p命名和c命名空间不能直接使用, 需要导入xml约束
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

// 引入p命名和c命名空间
// 目录: ./SpringDemo/src/main/resources/
// 文件名: applicationContext9.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
                           https://www.springframework.org/schema/beans/spring-beans.xsd"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c">
</beans>

0x04.4.2 p命名空间注入

// 第一步
// 创建个B类,给其它类使用
// 在./SpringDemo/src/main/java/com/test/依赖注入/Set方式注入/创建个B.java
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/Set方式注入/
// 文件名: B.java
package com.test.依赖注入.Set方式注入;
public class B {
    private String name;
    private Integer age;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public void b() {
        System.out.println("B中b方法执行了, name=" + name + ",age=" + age);
    }
}

// 第二步
// 引用B类的b方法
// 在./SpringDemo/src/main/java/com/test/依赖注入/Set方式注入/创建个A.java
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/Set方式注入/
// 文件名: A.java
package com.test.依赖注入.Set方式注入;
public class A {
    private B b;
    private String name;
    public void setB(B b) {
        this.b = b;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void a() {
        b.b();
        System.out.println("A中a方法执行了, name=" + this.name);
    }
}

// 第三步
// 目录: ./SpringDemo/src/main/resources/
// 文件名: applicationContext9.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
                           https://www.springframework.org/schema/beans/spring-beans.xsd"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c">
    <!--p命名空间注入,可以直接注入属性的值: 类似property-->
    <bean id="a" class="com.test.依赖注入.Set方式注入.A" p:name="李四" p:b-ref="b"/>
    <bean id="b" class="com.test.依赖注入.Set方式注入.B">
        <property name="name" value="张三"/>
        <property name="age" value="22"/>
    </bean>
</beans>

// 第四步
// 创建一个测试类Test20进行测试
// 目录: ./SpringDemo/src/test/java/
// 文件名: Test20.java
import com.test.依赖注入.Set方式注入.A;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test20 {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext9.xml");
        A a = (A) context.getBean("a");
        a.a();
    }
}
// 运行结果
B中b方法执行了, name=张三,age=22
A中a方法执行了, name=李四

0x04.4.3 c命名空间注入

// 第一步
// 创建个类进行测试
// 在./SpringDemo/src/main/java/com/test/依赖注入/Set方式注入/创建个User4.java
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/Set方式注入/
// 文件名: User4.java
package com.test.依赖注入.Set方式注入;
public class User4 {
    private String name;
    private int age;
    public User4(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return this.name;
    }
    public int getAge() {
        return this.age;
    }
}

// 第二步
// 目录: ./SpringDemo/src/main/resources/
// 文件名: applicationContext9.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
                           https://www.springframework.org/schema/beans/spring-beans.xsd"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c">
    <!--c命名空间注入,通过构造器注入: 类似constructor-arg-->
    <bean id="user4-test-2" class="com.test.依赖注入.Set方式注入.User4" c:name="王二狗" c:age="18"/>
</beans>

// 第三步
// 创建一个测试类Test21进行测试
// 目录: ./SpringDemo/src/test/java/
// 文件名: Test21.java
import com.test.依赖注入.Set方式注入.User4;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test21 {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext9.xml");
        User4 obj = (User4) context.getBean("user4-test-2");
        System.out.println(obj.getName());
        System.out.println(obj.getAge());
    }
}
// 运行结果
王二狗
18

0x05 小例子-注解注入

0x05.1 前置操作

// 第四步
// 在Spring的配置文件applicationContext.xml头部,引入context命名空间
// 目录: ./SpringDemo/src/main/resources/
// 文件名: applicationContext10.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"
       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/context
                           http://www.springframework.org/schema/context/spring-context-4.2.xsd">
    <!--添加Spring自动扫描,范围是com.test.依赖注入.注解注入下所有包及其子包-->
    <context:component-scan base-package="com.test.依赖注入.注解注入"></context:component-scan>
</beans>

0x05.2 构造方法注入

// 第一步
// 在./SpringDemo/src/main/java/com/test/依赖注入/注解注入/创建个BTest.java
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/注解注入/
// 文件名: BTest.java
package com.test.依赖注入.注解注入;
public class BTest {
    private String name;
    private Integer age;
    public BTest(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    public void b() {
        System.out.println("BTest类中b()方法执行了,name=" + name + ",age=" + age);
    }
}

// 第二步
// 在./SpringDemo/src/main/java/com/test/依赖注入/注解注入/创建个ATest.java
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/注解注入/
// 文件名: ATest.java
package com.test.依赖注入.注解注入;
public class ATest {
    private BTest bTest;
    private String name;
    public ATest(BTest b, String name) {
        this.bTest = b;
        this.name = name;
    }
    public void a() {
        bTest.b();
        System.out.println("ATest中a()方法执行了, name=" + name);
    }
}

// 第三步
// 在./SpringDemo/src/main/java/com/test/依赖注入/注解注入/创建个BeanConfig.java
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/注解注入/
// 文件名: BeanConfig.java
package com.test.依赖注入.注解注入;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class BeanConfig {
    @Bean
    public BTest b() {
        return new BTest("张三", 16);
    }
    @Bean("aTest")
    public ATest a() {
        return new ATest(b(), "李四");
    }
}

// 第四步
// 创建一个测试类Test22进行测试
// 目录: ./SpringDemo/src/test/java/
// 文件名: Test22.java
import com.test.依赖注入.注解注入.ATest;
import com.test.依赖注入.注解注入.BTest;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test22 {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext10.xml");
        ATest obj1 = (ATest) context.getBean("aTest");
        obj1.a();
        System.out.println("-----------------");
        BTest obj2 = (BTest) context.getBean("b");
        obj2.b();
    }
}
// 运行结果
BTest类中b()方法执行了,name=张三,age=16
ATest中a()方法执行了, name=李四
-----------------
BTest类中b()方法执行了,name=张三,age=16

0x05.3 setter方法注入

// 第一步
// 在./SpringDemo/src/main/java/com/test/依赖注入/注解注入/创建个DTest.java
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/注解注入/
// 文件名: DTest.java
package com.test.依赖注入.注解注入;
public class DTest {
    private String name;
    private Integer age;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public void d() {
        System.out.println("DTest类中d()方法执行了,name=" + name + ",age=" + age);
    }
}

// 第二步
// 在./SpringDemo/src/main/java/com/test/依赖注入/注解注入/创建个CTest.java
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/注解注入/
// 文件名: CTest.java
package com.test.依赖注入.注解注入;
public class CTest {
    private DTest dTest;
    private String name;
    public void setDTest(DTest dTest) {
        this.dTest = dTest;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void c() {
        dTest.d();
        System.out.println("CTest类中c()方法执行了, name=" + name);
    }
}

// 第三步
// 在./SpringDemo/src/main/java/com/test/依赖注入/注解注入/创建个BeanConfig2.java
// 目录: ./SpringDemo/src/main/java/com/test/依赖注入/注解注入/
// 文件名: BeanConfig2.java
package com.test.依赖注入.注解注入;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class BeanConfig2 {
    @Bean
    public DTest dTest() {
        DTest dTest = new DTest();
        dTest.setName("王五");
        dTest.setAge(28);
        return dTest;
    }
    @Bean
    public CTest cTest() {
        CTest cTest = new CTest();
        //引入的是上面的dTest()方法
        cTest.setDTest(dTest());
        cTest.setName("陈六");
        return cTest;
    }
}

// 第四步
// 创建一个测试类Test23进行测试
// 目录: ./SpringDemo/src/test/java/
// 文件名: Test23.java
import com.test.依赖注入.注解注入.CTest;
import com.test.依赖注入.注解注入.DTest;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test23 {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext10.xml");
        CTest obj1 = (CTest) context.getBean("cTest");
        obj1.c();
        System.out.println("-----------------");
        DTest obj2 = (DTest) context.getBean("dTest");
        obj2.d();
    }
}
// 运行结果
DTest类中d()方法执行了,name=王五,age=28
CTest类中c()方法执行了, name=陈六
-----------------
DTest类中d()方法执行了,name=王五,age=28

Java 安全漫游记

5. Spring 依赖注入

0x01 什么是依赖注入

0x02 依赖注入的方式

0x03 小例子-xml文件-构造函数注入

0x03.1 描述

0x03.2 默认构造器方式

0x03.3 有参构造创建对象

0x03.3.1 前置操作

0x03.3.2 有参构造创建对象-下标赋值注入

0x03.3.3 有参构造创建对象-数据类型注入

0x03.3.4 有参构造创建对象-参数名注入

0x03.3.5 有参构造创建对象-对象注入

0x04 小例子-xml文件-Set方式注入

0x04.1 描述

0x04.2 普通模式

0x04.3 复杂类型的注入

0x04.4 p与c命名空间注入

0x04.4.1 前置操作

0x04.4.2 p命名空间注入

0x04.4.3 c命名空间注入

0x05 小例子-注解注入

0x05.1 前置操作

0x05.2 构造方法注入

0x05.3 setter方法注入