‍

对于 IOC 的理解：

在 Spring 框架中，IOC（Inversion of Control，控制反转）是一个重要的概念，它是框架实现松耦合的一种方式。在传统的程序设计中，应用程序会主动创建对象并管理对象之间的依赖关系。而在 IOC 的思想中，控制权的转移是由程序本身掌控的，应用程序不再直接管理对象和对象之间的依赖关系，而是交给了 Spring 容器来管理。在 Spring 中，组件的依赖关系通过配置文件或者注解来描述，Spring 容器负责实例化对象并维护对象之间的依赖关系，从而实现了对象之间的解耦。

‍

简单来说，IOC 就是将原本程序开发者需要手动创建、管理的对象的创建和依赖关系的设置交给了 Spring 容器，让 Spring 容器通过反射和配置来完成这些工作，从而简化了开发工作，提高了代码质量，也更容易维护和升级。

1. IOC 容器

1.1 IOC 思想

‍

IOC：Inversion of Control，翻译过来是反转控制。

① 获取资源的传统方式

‍

自己做饭：买菜、洗菜、择菜、改刀、炒菜，全过程参与，费时费力，必须清楚了解资源创建整个过程中的全部细节且熟练掌握。

‍

在应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源，在这样的

模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效率。

② 反转控制方式获取资源

‍

点外卖：下单、等、吃，省时省力，不必关心资源创建过程的所有细节。

‍

反转控制的思想完全颠覆了应用程序组件获取资源的传统方式：反转了资源的获取方向——改由容器主动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的，只需要提供接收资源的方式即可，极大的降低了学习成本，提高了开发的效率。这种行为也称为查找的被动形式。

③DI

‍

DI：Dependency Injection，翻译过来是依赖注入。

DI 是 IOC 的另一种表述方式：即组件以一些预先定义好的方式（例如：setter 方法）接受来自于容器

的资源注入。相对于 IOC 而言，这种表述更直接。

‍

所以结论是：IOC 就是一种反转控制的思想，而 DI 是对 IOC 的一种具体实现。

‍

1.2 IOC 容器在 Spring 中的实现

‍

Spring 的 IOC 容器就是 IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建 IOC 容器。Spring 提供了 IOC 容器的两种实现方式：

①BeanFactory

‍

这是 IOC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。

②ApplicationContext

‍

BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用

ApplicationContext 而不是底层的 BeanFactory。

③ApplicationContext 的主要实现类

‍

类型名	简介
ClassPathXmlApplicationContext	通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
FileSystemXmlApplicationContext	通过文件系统路径读取 XML 格式的配置文件创建 IOC 容器对象
ConfigurableApplicationContext	ApplicationContext 的子接口，包含一些扩展方法 refresh() 和 close() ，让 ApplicationContext 具有启动、关闭和刷新上下文的能力。
WebApplicationContext	专门为 Web 应用准备，基于 Web 环境创建 IOC 容器对象，并将对象引入存入 ServletContext 域中。

‍

2. 基于 XML 管理 bean

‍

每个 bean 都被称为组件

2.1 实验一：入门案例

① 创建 Maven Module

② 引入依赖

<dependencies>

	 <!-- Spring -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context</artifactId>

            <version>5.3.1</version>

        </dependency>

        <!-- junit测试 -->

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>4.12</version>

            <scope>test</scope>

        </dependency>

    </dependencies>

③ 创建类 HelloWorld

⑤ 在 Spring 的配置文件中配置 bean

⑥ 创建测试类测试

⑦ 思路

⑧ 注意

Spring 底层默认通过反射技术调用组件类的无参构造器来创建组件对象，这一点需要注意。如果在需要无参构造器时，没有无参构造器，则会抛出下面的异常：

org.springframework.beans.factory.BeanCreationException: Error creating bean with name

'helloworld' defined in class path resource [applicationContext.xml]: Instantiation of bean

failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed

to instantiate [com.atguigu.spring.bean.HelloWorld]: No default constructor found; nested

exception is java.lang.NoSuchMethodException: com.atguigu.spring.bean.HelloWorld.

<init>()

‍

2.2 实验二：获取 bean 的三种方式

‍

① 方式一：根据 id 获取

‍

由于 id 属性指定了 bean 的唯一标识，所以根据 bean 标签的 id 属性可以精确获取到一个组件对象。

上个实验中我们使用的就是这种方式。

‍

② 方式二：根据类型获取

‍

@Test

public void testHelloWorld(){

    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

    HelloWorld bean = ac.getBean(HelloWorld.class);

    bean.sayHello();

}

‍

③ 方式三：根据 id 和类型

‍

@Test

public void testHelloWorld(){

    ApplicationContext ac = newClassPathXmlApplicationContext("applicationContext.xml");

    HelloWorld bean = ac.getBean("helloworld", HelloWorld.class);

    bean.sayHello();

}

④ 注意

当根据类型获取 bean 时，要求 IOC 容器中指定类型的 bean 有且只能有一个

当 IOC 容器中一共配置了两个：

<bean id="helloworldOne" class="com.atguigu.spring.bean.HelloWorld"></bean>

<bean id="helloworldTwo" class="com.atguigu.spring.bean.HelloWorld"></bean>

‍

根据类型获取时会抛出异常：

‍

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean

of type 'com.atguigu.spring.bean.HelloWorld' available: expected single matching bean but

found 2: helloworldOne,helloworldTwo

‍

⑤ 扩展

‍

如果组件类实现了接口，根据接口类型可以获取 bean 吗？

可以，前提是 bean 唯一

‍

如果一个接口有多个实现类，这些实现类都配置了 bean，根据接口类型可以获取 bean 吗？

不行，因为 bean 不唯一

⑥ 结论

‍

根据类型来获取 bean 时，在满足 bean 唯一性的前提下，其实只是看：『对象 instanceof 指定的类型』的返回结果，只要返回的是 true 就可以认定为和类型匹配，能够获取到。

‍

2.3 实验三：依赖注入之 setter 注入

‍

依赖注入理解：给类中属性赋值的一个过程就叫做依赖注入

‍

属性：找到 JavaBean 中的 get 和 set 方法，把 get 或 set 去掉，剩余的字母拼凑在一起就称为属性

‍

① 创建学生类 Student

‍

public class Student {

    private Integer id;

    private String name;

    private Integer age;

    private String sex;

    public Student() {

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public Integer getAge() {

        return age;

    }

    public void setAge(Integer age) {

        this.age = age;

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex;

    }

    @Override

    public String toString() {

        return "Student{" +

            "id=" + id +

            ", name='" + name + '\'' +

            ", age=" + age +

            ", sex='" + sex + '\'' +

            '}';

    }

}

‍

② 配置 bean 时为属性赋值

‍

<bean id="studentOne" class="com.atguigu.spring.bean.Student">

    <!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 -->

    <!-- name属性：指定属性名（这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关）-->

    <!-- value属性：指定属性值 -->

    <property name="id" value="1001"></property>

    <property name="name" value="张三"></property>

    <property name="age" value="23"></property>

    <property name="sex" value="男"></property>

</bean>

‍

property 标签：通过组建类的 setXxx() 方法，给组建对象设置属性
name 属性：指定属性名（这个属性名是 getXxx()、setXxx()方法定义的，和成员变量无关）
value 属性：指定属性值

‍

③ 测试

‍

@Test

public void testDIBySet(){

    ApplicationContext ac = new ClassPathXmlApplicationContext("springdi.xml");

    Student studentOne = ac.getBean("studentOne", Student.class);

    System.out.println(studentOne);

}

‍

2.4 实验四：依赖注入之构造器注入

‍

① 在 Student 类中添加有参构造

‍

public Student(Integer id, String name, Integer age, String sex) {

    this.id = id;

    this.name = name;

    this.age = age;

    this.sex = sex;

}

② 配置 bean

‍

<bean id="studentTwo" class="com.atguigu.spring.bean.Student">

    <constructor-arg value="1002"></constructor-arg>

    <constructor-arg value="李四"></constructor-arg>

    <constructor-arg value="33"></constructor-arg>

    <constructor-arg value="女"></constructor-arg>

</bean>

注意：

constructor-arg 标签还有两个属性可以进一步描述构造器参数：

index 属性：指定参数所在位置的索引（从 0 开始）

name 属性：指定参数名

③ 测试

‍

@Test

public void testDIBySet(){

    ApplicationContext ac = new ClassPathXmlApplicationContext("springdi.xml");

    Student studentOne = ac.getBean("studentTwo", Student.class);

    System.out.println(studentOne);

}

‍

2.5 实验五：特殊值处理

‍

① 字面量赋值

‍

什么是字面量？

int a = 10;

声明一个变量 a，初始化为 10，此时 a 就不代表字母 a 了，而是作为一个变量的名字。当我们引用 a

的时候，我们实际上拿到的值是 10。

而如果 a 是带引号的：'a'，那么它现在不是一个变量，它就是代表 a 这个字母本身，这就是字面

量。所以字面量没有引申含义，就是我们看到的这个数据本身。

<!-- 使用value属性给bean的属性赋值时，Spring会把value属性的值看做字面量 -->

<property name="name" value="张三"/>

②null 值

‍

<property name="name">

    <null />

</property>

注意：
<property name="name" value="null"></property>
以上写法，为 name 所赋的值是字符串 null

③xml 实体

‍

<!-- 小于号在XML文档中用来定义标签的开始，不能随便使用 -->

<!-- 解决方案一：使用XML实体来代替 -->

<property name="expression" value="a &lt; b"/>

④CDATA 节

‍

<property name="expression">

    <!-- 解决方案二：使用CDATA节 -->

    <!-- CDATA中的C代表Character，是文本、字符的含义，CDATA就表示纯文本数据 -->

    <!-- XML解析器看到CDATA节就知道这里是纯文本，就不会当作XML标签或属性来解析 -->

    <!-- 所以CDATA节中写什么符号都随意 -->

    <value><![CDATA[a < b]]></value>

</property>

‍

2.6 实验六：为类类型属性赋值

‍

① 创建班级类 Clazz

‍

public class Clazz {

    private Integer clazzId;

    private String clazzName;

    public Integer getClazzId() {

        return clazzId;

    }

    public void setClazzId(Integer clazzId) {

        this.clazzId = clazzId;

    }

    public String getClazzName() {

        return clazzName;

    }

    public void setClazzName(String clazzName) {

        this.clazzName = clazzName;

    }

    @Override

    public String toString() {

        return "Clazz{" +

            "clazzId=" + clazzId +

            ", clazzName='" + clazzName + '\'' +

            '}';

    }

    public Clazz() {

    }

    public Clazz(Integer clazzId, String clazzName) {

        this.clazzId = clazzId;

        this.clazzName = clazzName;

    }

}

② 修改 Student 类

在 Student 类中添加以下代码：

private Clazz clazz;

public Clazz getClazz() {

    return clazz;

}

public void setClazz(Clazz clazz) {

    this.clazz = clazz;

}

③ 方式一：引用外部已声明的 bean

配置 Clazz 类型的 bean：

<bean id="clazzOne" class="com.atguigu.spring.bean.Clazz">

    <property name="clazzId" value="1111"></property>

    <property name="clazzName" value="财源滚滚班"></property>

</bean>

为 Student 中的 clazz 属性赋值：

<bean id="studentFour" class="com.atguigu.spring.bean.Student">

    <property name="id" value="1004"></property>

    <property name="name" value="赵六"></property>

    <property name="age" value="26"></property>

    <property name="sex" value="女"></property>

    <!-- ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值 -->

    <property name="clazz" ref="clazzOne"></property>

</bean>

错误演示：

<bean id="studentFour" class="com.atguigu.spring.bean.Student">

    <property name="id" value="1004"></property>

    <property name="name" value="赵六"></property>

    <property name="age" value="26"></property>

    <property name="sex" value="女"></property>

    <property name="clazz" value="clazzOne"></property>

</bean>

如果错把 ref 属性写成了 value 属性，会抛出异常： Caused by: java.lang.IllegalStateException:

Cannot convert value of type 'java.lang.String' to required type

'com.atguigu.spring.bean.Clazz' for property 'clazz': no matching editors or conversion

strategy found

意思是不能把 String 类型转换成我们要的 Clazz 类型，说明我们使用 value 属性时，Spring 只把这个

属性看做一个普通的字符串，不会认为这是一个 bean 的 id，更不会根据它去找到 bean 来赋值

④ 方式二：内部 bean

<bean id="studentFour" class="com.atguigu.spring.bean.Student">

    <property name="id" value="1004"></property>

    <property name="name" value="赵六"></property>

    <property name="age" value="26"></property>

    <property name="sex" value="女"></property>

    <property name="clazz">

        <!-- 在一个bean中再声明一个bean就是内部bean -->

        <!-- 内部bean只能用于给属性赋值，不能在外部通过IOC容器获取，因此可以省略id属性 -->

        <bean id="clazzInner" class="com.atguigu.spring.bean.Clazz">

            <property name="clazzId" value="2222"></property>

            <property name="clazzName" value="远大前程班"></property>

        </bean>

    </property>

</bean>

③ 方式三：级联属性赋值

<bean id="studentFour" class="com.atguigu.spring.bean.Student">

    <property name="id" value="1004"></property>

    <property name="name" value="赵六"></property>

    <property name="age" value="26"></property>

    <property name="sex" value="女"></property>

    <!-- 一定先引用某个bean为属性赋值，才可以使用级联方式更新属性 -->

    <property name="clazz" ref="clazzOne"></property>

    <property name="clazz.clazzId" value="3333"></property>

    <property name="clazz.clazzName" value="最强王者班"></property>

</bean>

2.7 实验七：为数组类型属性赋值

‍

① 修改 Student 类

‍

在 Student 类中添加以下代码：

‍

private String[] hobbies;

public String[] getHobbies() {

    return hobbies;

}

public void setHobbies(String[] hobbies) {

    this.hobbies = hobbies;

}

‍

② 配置 bean

‍

<bean id="studentFour" class="com.atguigu.spring.bean.Student">

    <property name="id" value="1004"></property>

    <property name="name" value="赵六"></property>

    <property name="age" value="26"></property>

    <property name="sex" value="女"></property>

    <!-- ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值 -->

    <property name="clazz" ref="clazzOne"></property>

    <property name="hobbies">

        <array>

            <value>抽烟</value>

            <value>喝酒</value>

            <value>烫头</value>

        </array>

    </property>

</bean>

‍

2.8 实验八：为集合类型属性赋值

‍

① 为 List 集合类型属性赋值

‍

在 Clazz 类中添加以下代码：

‍

private List<Student> students;

public List<Student> getStudents() {

    return students;

}

public void setStudents(List<Student> students) {

    this.students = students;

}

配置 bean：

<bean id="clazzTwo" class="com.atguigu.spring.bean.Clazz">

    <property name="clazzId" value="4444"></property>

    <property name="clazzName" value="Javaee0222"></property>

    <property name="students">

        <list>

            <ref bean="studentOne"></ref>

            <ref bean="studentTwo"></ref>

            <ref bean="studentThree"></ref>

        </list>

    </property>

</bean>

若为 Set 集合类型属性赋值，只需要将其中的 list 标签改为 set 标签即可

② 为 Map 集合类型属性赋值

创建教师类 Teacher：

public class Teacher {

    private Integer teacherId;

    private String teacherName;

    public Integer getTeacherId() {

        return teacherId;

    }

    public void setTeacherId(Integer teacherId) {

        this.teacherId = teacherId;

    }

    public String getTeacherName() {

        return teacherName;

    }

    public void setTeacherName(String teacherName) {

        this.teacherName = teacherName;

    }

    public Teacher(Integer teacherId, String teacherName) {

        this.teacherId = teacherId;

        this.teacherName = teacherName;

    }

    public Teacher() {

    }

    @Override

    public String toString() {

        return "Teacher{" +

            "teacherId=" + teacherId +

            ", teacherName='" + teacherName + '\'' +

            '}';

    }

}

在 Student 类中添加以下代码：

private Map<String, Teacher> teacherMap;

public Map<String, Teacher> getTeacherMap() {

    return teacherMap;

}

public void setTeacherMap(Map<String, Teacher> teacherMap) {

    this.teacherMap = teacherMap;

}

配置 bean：

<bean id="teacherOne" class="com.atguigu.spring.bean.Teacher">

    <property name="teacherId" value="10010"></property>

    <property name="teacherName" value="大宝"></property>

</bean>

<bean id="teacherTwo" class="com.atguigu.spring.bean.Teacher">

    <property name="teacherId" value="10086"></property>

    <property name="teacherName" value="二宝"></property>

</bean>

<bean id="studentFour" class="com.atguigu.spring.bean.Student">

    <property name="id" value="1004"></property>

    <property name="name" value="赵六"></property>

    <property name="age" value="26"></property>

    <property name="sex" value="女"></property>

    <!-- ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值 -->

    <property name="clazz" ref="clazzOne"></property>

    <property name="hobbies">

        <array>

            <value>抽烟</value>

            <value>喝酒</value>

            <value>烫头</value>

        </array>

    </property>

    <property name="teacherMap">

        <map>

            <entry>

                <key>

                    <value>10010</value>

                </key>

                <ref bean="teacherOne"></ref>

            </entry>

            <entry>

                <key>

                    <value>10086</value>

                </key>

                <ref bean="teacherTwo"></ref>

            </entry>

        </map>

    </property>

</bean>

‍

③ 引用集合类型的 bean

‍

<!--list集合类型的bean-->

<util:list id="students">

    <ref bean="studentOne"></ref>

    <ref bean="studentTwo"></ref>

    <ref bean="studentThree"></ref>

</util:list>

<!--map集合类型的bean-->

<util:map id="teacherMap">

    <entry>

        <key>

            <value>10010</value>

        </key>

        <ref bean="teacherOne"></ref>

    </entry>

    <entry>

        <key>

            <value>10086</value>

        </key>

        <ref bean="teacherTwo"></ref>

    </entry>

</util:map>

<bean id="clazzTwo" class="com.atguigu.spring.bean.Clazz">

    <property name="clazzId" value="4444"></property>

    <property name="clazzName" value="Javaee0222"></property>

    <property name="students" ref="students"></property>

</bean>

<bean id="studentFour" class="com.atguigu.spring.bean.Student">

    <property name="id" value="1004"></property>

    <property name="name" value="赵六"></property>

    <property name="age" value="26"></property>

    <property name="sex" value="女"></property>

    <!-- ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值 -->

    <property name="clazz" ref="clazzOne"></property>

    <property name="hobbies">

        <array>

            <value>抽烟</value>

            <value>喝酒</value>

            <value>烫头</value>

        </array>

    </property>

    <property name="teacherMap" ref="teacherMap"></property>

</bean>

‍

使用 util:list、util:map 标签必须引入相应的命名空间，可以通过 idea 的提示功能选择

‍

2.9 实验九：p 命名空间

‍

引入 p 命名空间后，可以通过以下方式为 bean 的各个属性赋值

‍

<bean id="studentSix" class="com.atguigu.spring.bean.Student"

      p:id="1006" p:name="小明" p:clazz-ref="clazzOne" p:teacherMap-ref="teacherMap"></bean>

‍

其中没有被赋值的属性默认值为 null

‍

示例如下：

‍

2. 10 实验十：引入外部属性文件

‍

① 加入依赖

‍

<!-- MySQL驱动 -->

<dependency>

    <groupId>mysql</groupId>

    <artifactId>mysql-connector-java</artifactId>

    <version>8.0.16</version>

</dependency>

<!-- 数据源 -->

<dependency>

    <groupId>com.alibaba</groupId>

    <artifactId>druid</artifactId>

    <version>1.0.31</version>

</dependency>

② 创建外部属性文件

‍

jdbc.user=root

jdbc.password=atguigu

jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC

jdbc.driver=com.mysql.cj.jdbc.Driver

‍

③ 引入属性文件

‍

<!-- 引入外部属性文件 -->

<context:property-placeholder location="classpath:jdbc.properties"/>

④ 配置 bean

‍

<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">

    <property name="url" value="${jdbc.url}"/>

    <property name="driverClassName" value="${jdbc.driver}"/>

    <property name="username" value="${jdbc.user}"/>

    <property name="password" value="${jdbc.password}"/>

</bean>

⑤ 测试

‍

@Test

public void testDataSource() throws SQLException {

    ApplicationContext ac = new ClassPathXmlApplicationContext("spring-datasource.xml");

    DataSource dataSource = ac.getBean(DataSource.class);

    Connection connection = dataSource.getConnection();

    System.out.println(connection);

}

‍

2.11 实验十一：bean 的作用域

‍

① 概念

‍

在 Spring 中可以通过配置 bean 标签的 scope 属性来指定 bean 的作用域范围，各取值含义参加下表：

‍

取值	含义	创建对象的时机
singleton（默认）	在 IOC 容器中，这个 bean 的对象始终为单实例	IOC 容器初始化时
prototype	这个 bean 在 IOC 容器中有多个实例	获取 bean 时

‍

如果是在 WebApplicationContext 环境下还会有另外两个作用域（但不常用）：

取值	含义
request	在一个请求范围内有效
session	在一个会话范围内有效

‍

② 创建类 User

‍

public class User {

private Integer id;

private String username;

private String password;

private Integer age;

    public User() {

    }

    public User(Integer id, String username, String password, Integer age) {

        this.id = id;

        this.username = username;

        this.password = password;

        this.age = age;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

    public Integer getAge() {

        return age;

    }

    public void setAge(Integer age) {

        this.age = age;

    }

    @Override

    public String toString() {

        return "User{" +

            "id=" + id +

            ", username='" + username + '\'' +

            ", password='" + password + '\'' +

            ", age=" + age +

            '}';

    }

}

③ 配置 bean

‍

<!-- scope属性：取值singleton（默认值），bean在IOC容器中只有一个实例，IOC容器初始化时创建

对象 -->

<!-- scope属性：取值prototype，bean在IOC容器中可以有多个实例，getBean()时创建对象 -->

<bean class="com.atguigu.bean.User" scope="prototype"></bean>

④ 测试

‍

@Test

public void testBeanScope(){

    ApplicationContext ac = new ClassPathXmlApplicationContext("spring-scope.xml");

    User user1 = ac.getBean(User.class);

    User user2 = ac.getBean(User.class);

    System.out.println(user1==user2);

}

‍

2.11 实验十二：bean 的生命周期

‍

① 具体的生命周期过程

‍

bean 对象创建（调用无参构造器）
给 bean 对象设置属性
bean 对象初始化之前操作（由 bean 的后置处理器负责）
bean 对象初始化（需在配置 bean 时指定初始化方法）
bean 对象初始化之后操作（由 bean 的后置处理器负责）
bean 对象就绪可以使用
bean 对象销毁（需在配置 bean 时指定销毁方法）
IOC 容器关闭

‍

② 修改类 User

‍

public class User {

    private Integer id;

    private String username;

    private String password;

    private Integer age;

    public User() {

        System.out.println("生命周期：1、创建对象");

    }

    public User(Integer id, String username, String password, Integer age) {

        this.id = id;

        this.username = username;

        this.password = password;

        this.age = age;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        System.out.println("生命周期：2、依赖注入");

        this.id = id;

    }

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

    public Integer getAge() {

        return age;

    }

    public void setAge(Integer age) {

        this.age = age;

    }

    public void initMethod(){

        System.out.println("生命周期：3、初始化");

    }

    public void destroyMethod(){

        System.out.println("生命周期：5、销毁");

    }

    @Override

    public String toString() {

        return "User{" +

            "id=" + id +

            ", username='" + username + '\'' +

            ", password='" + password + '\'' +

            ", age=" + age +

            '}';

    }

}

注意其中的 initMethod()和 destroyMethod()，可以通过配置 bean 指定为初始化和销毁的方法

③ 配置 bean

‍

<!-- 使用init-method属性指定初始化方法 -->

<!-- 使用destroy-method属性指定销毁方法 -->

<bean class="com.atguigu.bean.User" scope="prototype" init-method="initMethod"destroy-method="destroyMethod">

    <property name="id" value="1001"></property>

    <property name="username" value="admin"></property>

    <property name="password" value="123456"></property>

    <property name="age" value="23"></property>

</bean>

④ 测试

‍

@Test

public void testLife(){

    ClassPathXmlApplicationContext ac = newClassPathXmlApplicationContext("spring-lifecycle.xml");

    User bean = ac.getBean(User.class);

    System.out.println("生命周期：4、通过IOC容器获取bean并使用");

    ac.close();

}

⑤bean 的后置处理器

‍

bean 的后置处理器会在生命周期的初始化前后添加额外的操作，需要实现 BeanPostProcessor 接口，

且配置到 IOC 容器中，需要注意的是，bean 后置处理器不是单独针对某一个 bean 生效，而是针对 IOC 容器中所有 bean 都会执行

创建 bean 的后置处理器：

‍

package com.atguigu.spring.process;

import org.springframework.beans.BeansException;

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

public class MyBeanProcessor implements BeanPostProcessor {

    @Override

    public Object postProcessBeforeInitialization(Object bean, String beanName)

        throws BeansException {

        System.out.println("☆☆☆" + beanName + " = " + bean);

        return bean;

    }

    @Override

    public Object postProcessAfterInitialization(Object bean, String beanName)

        throws BeansException {

        System.out.println("★★★" + beanName + " = " + bean);

        return bean;

    }

}

‍

在 IOC 容器中配置后置处理器：



<bean id="myBeanProcessor"class="com.atguigu.spring.process.MyBeanProcessor"/>

‍

2.13 实验十三：FactoryBean

‍

① 简介

‍

FactoryBean 是 Spring 提供的一种整合第三方框架的常用机制。和普通的 bean 不同，配置一个

FactoryBean 类型的 bean，在获取 bean 的时候得到的并不是 class 属性中配置的这个类的对象，而是

getObject()方法的返回值。通过这种机制，Spring 可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来，只把最简洁的使用界面展示给我们。

将来我们整合 Mybatis 时，Spring 就是通过 FactoryBean 机制来帮我们创建 SqlSessionFactory 对象的。

‍

/*

* Copyright 2002-2020 the original author or authors.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* https://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package org.springframework.beans.factory;

import org.springframework.lang.Nullable;

/**

* Interface to be implemented by objects used within a {@link BeanFactory}

which

* are themselves factories for individual objects. If a bean implements this

* interface, it is used as a factory for an object to expose, not directly as a

* bean instance that will be exposed itself.

*

* <p><b>NB: A bean that implements this interface cannot be used as a normal

bean.</b>

* A FactoryBean is defined in a bean style, but the object exposed for bean

* references ({@link #getObject()}) is always the object that it creates.

*

* <p>FactoryBeans can support singletons and prototypes, and can either create

* objects lazily on demand or eagerly on startup. The {@link SmartFactoryBean}

* interface allows for exposing more fine-grained behavioral metadata.

*

* <p>This interface is heavily used within the framework itself, for example

for

* the AOP {@link org.springframework.aop.framework.ProxyFactoryBean} or the

* {@link org.springframework.jndi.JndiObjectFactoryBean}. It can be used for

* custom components as well; however, this is only common for infrastructure

code.

*

* <p><b>{@code FactoryBean} is a programmatic contract. Implementations are not

* supposed to rely on annotation-driven injection or other reflective

facilities.</b>

* {@link #getObjectType()} {@link #getObject()} invocations may arrive early in

the

* bootstrap process, even ahead of any post-processor setup. If you need access

to

* other beans, implement {@link BeanFactoryAware} and obtain them

programmatically.

*

* <p><b>The container is only responsible for managing the lifecycle of the

FactoryBean

* instance, not the lifecycle of the objects created by the FactoryBean.</b>

Therefore,

* a destroy method on an exposed bean object (such as {@link

java.io.Closeable#close()}

* will <i>not</i> be called automatically. Instead, a FactoryBean should

implement

* {@link DisposableBean} and delegate any such close call to the underlying

object.

*

* <p>Finally, FactoryBean objects participate in the containing BeanFactory's

* synchronization of bean creation. There is usually no need for internal

* synchronization other than for purposes of lazy initialization within the

* FactoryBean itself (or the like).

*

* @author Rod Johnson

* @author Juergen Hoeller

* @since 08.03.2003

* @param <T> the bean type

* @see org.springframework.beans.factory.BeanFactory

* @see org.springframework.aop.framework.ProxyFactoryBean

* @see org.springframework.jndi.JndiObjectFactoryBean

*/

public interface FactoryBean<T> {

    /**

* The name of an attribute that can be

* {@link org.springframework.core.AttributeAccessor#setAttribute set} on a

* {@link org.springframework.beans.factory.config.BeanDefinition} so that

* factory beans can signal their object type when it can't be deduced from

* the factory bean class.

* @since 5.2

*/

    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

    /**

* Return an instance (possibly shared or independent) of the object

* managed by this factory.

* <p>As with a {@link BeanFactory}, this allows support for both the

* Singleton and Prototype design pattern.

* <p>If this FactoryBean is not fully initialized yet at the time of

* the call (for example because it is involved in a circular reference),

* throw a corresponding {@link FactoryBeanNotInitializedException}.

* <p>As of Spring 2.0, FactoryBeans are allowed to return {@code null}

* objects. The factory will consider this as normal value to be used; it

* will not throw a FactoryBeanNotInitializedException in this case anymore.

* FactoryBean implementations are encouraged to throw

* FactoryBeanNotInitializedException themselves now, as appropriate.

* @return an instance of the bean (can be {@code null})

* @throws Exception in case of creation errors

* @see FactoryBeanNotInitializedException

*/

    @Nullable

    T getObject() throws Exception;

    /**

* Return the type of object that this FactoryBean creates,

* or {@code null} if not known in advance.

* <p>This allows one to check for specific types of beans without

* instantiating objects, for example on autowiring.

* <p>In the case of implementations that are creating a singleton object,

* this method should try to avoid singleton creation as far as possible;

* it should rather estimate the type in advance.

* For prototypes, returning a meaningful type here is advisable too.

* <p>This method can be called <i>before</i> this FactoryBean has

* been fully initialized. It must not rely on state created during

* initialization; of course, it can still use such state if available.

* <p><b>NOTE:</b> Autowiring will simply ignore FactoryBeans that return

* {@code null} here. Therefore it is highly recommended to implement

* this method properly, using the current state of the FactoryBean.

* @return the type of object that this FactoryBean creates,

* or {@code null} if not known at the time of the call

* @see ListableBeanFactory#getBeansOfType

*/

    @Nullable

    Class<?> getObjectType();

    /**

* Is the object managed by this factory a singleton? That is,

* will {@link #getObject()} always return the same object

* (a reference that can be cached)?

* <p><b>NOTE:</b> If a FactoryBean indicates to hold a singleton object,

* the object returned from {@code getObject()} might get cached

* by the owning BeanFactory. Hence, do not return {@code true}

* unless the FactoryBean always exposes the same reference.

* <p>The singleton status of the FactoryBean itself will generally

* be provided by the owning BeanFactory; usually, it has to be

* defined as singleton there.

* <p><b>NOTE:</b> This method returning {@code false} does not

* necessarily indicate that returned objects are independent instances.

* An implementation of the extended {@link SmartFactoryBean} interface

* may explicitly indicate independent instances through its

* {@link SmartFactoryBean#isPrototype()} method. Plain {@link FactoryBean}

* implementations which do not implement this extended interface are

* simply assumed to always return independent instances if the

* {@code isSingleton()} implementation returns {@code false}.

* <p>The default implementation returns {@code true}, since a

* {@code FactoryBean} typically manages a singleton instance.

* @return whether the exposed object is a singleton

* @see #getObject()

* @see SmartFactoryBean#isPrototype()

*/

    default boolean isSingleton() {

        return true;

    }

}

② 创建类 UserFactoryBean

‍

public class UserFactoryBean implements FactoryBean<User> {

    @Override

    public User getObject() throws Exception {

        return new User();

    }

    @Override

    public Class<?> getObjectType() {

        return User.class;

    }

}

③ 配置 bean

‍

<bean id="user" class="com.atguigu.bean.UserFactoryBean"></bean>

④ 测试

‍

@Test

public void testUserFactoryBean(){

    //获取IOC容器

    ApplicationContext ac = new ClassPathXmlApplicationContext("spring•factorybean.xml");

    User user = (User) ac.getBean("user");

    System.out.println(user);

}

‍

2.14 实验十四：基于 xml 的自动装配

在 Spring 中，自动装配是一种依赖注入(Dependency Injection)的方式，它可以自动地将组件中所需要的依赖自动地注入到该组件中，从而避免了手动管理这些依赖的麻烦。

当一些组件需要依赖其他组件时，我们可以使用自动装配来完成相关依赖的注入。Spring 会在应用加载时扫描组件并建立它们之间的依赖关系。在完成扫描和注入之后，Spring 会将所有的组件实例化并置于容器中。

在 Spring 中，自动装配被设计成一种灵活的机制。这意味着开发人员可以通过注解、XML 文件或 Java 代码来指定装配的方式，在满足依赖注入规则的前提下，也可以根据需要添加自己的注入逻辑。

自动装配可以大大降低开发者的开发难度和维护负担，提高应用的可扩展和重用性。同时，它也能够避免很多因手动管理依赖带来的错误和不便。

‍

自动装配：

根据指定的策略，在 IOC 容器中匹配某一个 bean，自动为指定的 bean 中所依赖的类类型或接口类

型属性赋值

① 场景模拟

‍

创建类 UserController

‍

public class UserController {

    private UserService userService;

    public void setUserService(UserService userService) {

        this.userService = userService;

    }

    public void saveUser(){

        userService.saveUser();

    }

}

‍

创建接口 UserService

‍

public interface UserService {

    void saveUser();

}

‍

创建类 UserServiceImpl 实现接口 UserService

‍

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {

        this.userDao = userDao;

    }

    @Override

    public void saveUser() {

        userDao.saveUser();

    }

}

创建接口 UserDao

public interface UserDao {

    void saveUser();

}

创建类 UserDaoImpl 实现接口 UserDao

‍

public class UserDaoImpl implements UserDao {

    @Override

    public void saveUser() {

        System.out.println("保存成功");

    }

}

② 配置 bean

‍

使用 bean 标签的 autowire 属性设置自动装配效果

自动装配方式：byType

byType：根据类型匹配 IOC 容器中的某个兼容类型的 bean，为属性自动赋值

若在 IOC 中，没有任何一个兼容类型的 bean 能够为属性赋值，则该属性不装配，即值为默认值

null

若在 IOC 中，有多个兼容类型的 bean 能够为属性赋值，则抛出异常

NoUniqueBeanDefinitionException

<bean id="userController"class="com.atguigu.autowire.xml.controller.UserController" autowire="byType">

</bean>

<bean id="userService"class="com.atguigu.autowire.xml.service.impl.UserServiceImpl" autowire="byType">

</bean>

<bean id="userDao" class="com.atguigu.autowire.xml.dao.impl.UserDaoImpl"></bean>

‍

自动装配方式：byName

byName：将自动装配的属性的属性名，作为 bean 的 id 在 IOC 容器中匹配相对应的 bean 进行赋值

‍

<bean id="userController"class="com.atguigu.autowire.xml.controller.UserController" autowire="byName">

</bean>

<bean id="userService"class="com.atguigu.autowire.xml.service.impl.UserServiceImpl" autowire="byName">

</bean>

<bean id="userServiceImpl"class="com.atguigu.autowire.xml.service.impl.UserServiceImpl" autowire="byName">

</bean>

<bean id="userDao" class="com.atguigu.autowire.xml.dao.impl.UserDaoImpl">

</bean>

<bean id="userDaoImpl" class="com.atguigu.autowire.xml.dao.impl.UserDaoImpl">

</bean>

③ 测试

‍

@Test

public void testAutoWireByXML(){

    ApplicationContext ac = new ClassPathXmlApplicationContext("autowire-xml.xml");

    UserController userController = ac.getBean(UserController.class);

    userController.saveUser();

}

‍

3. 基于注解管理 bean

‍

3.1 实验一：标记与扫描

① 注解

‍

和 XML 配置文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记，具体的功能是框架检测到注解标记的位置，然后针对这个位置按照注解标记的功能来执行具体操作。

本质上：所有一切的操作都是 Java 代码来完成的，XML 和注解只是告诉框架中的 Java 代码如何执行。

‍

② 扫描

‍

Spring 为了知道程序员在哪些地方标记了什么注解，就需要通过扫描的方式，来进行检测。然后根据注解进行后续操作。

‍

③ 新建 Maven Module

‍

<dependencies>

    <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->

    <dependency>

        <groupId>org.springframework</groupId>

        <artifactId>spring-context</artifactId>

        <version>5.3.1</version>

    </dependency>

    <!-- junit测试 -->

    <dependency>

        <groupId>junit</groupId>

        <artifactId>junit</artifactId>

        <version>4.12</version>

        <scope>test</scope>

    </dependency>

</dependencies>

④ 创建 Spring 配置文件

‍

⑤ 标识组件的常用注解

‍

@Component：将类标识为普通组件 

@Controller：将类标识为控制层组件 

@Service：将类标识为业务层组件 

@Repository：将类标识为持久层组件

‍

其中，也是一个组件

‍

问：以上四个注解有什么关系和区别？

‍

通过查看源码我们得知，@Controller、@Service、@Repository 这三个注解只是在@Component 注解的基础上起了三个新的名字。

对于 Spring 使用 IOC 容器管理这些组件来说没有区别。所以@Controller、@Service、@Repository 这三个注解只是给开发人员看的，让我们能够便于分辨组件的作用。

‍

注意：虽然它们本质上一样，但是为了代码的可读性，为了程序结构严谨我们肯定不能随便胡乱标记。

‍

⑥ 创建组件

创建控制层组件

@Controller

public class UserController {

}

创建接口 UserService

public interface UserService {

}

创建业务层组件 UserServiceImpl

@Service

public class UserServiceImpl implements UserService {

}

创建接口 UserDao

public interface UserDao {

}

创建持久层组件 UserDaoImpl

@Repository

public class UserDaoImpl implements UserDao {

}

⑦ 扫描组件

‍

情况一：最基本的扫描方式

<context:component-scan base-package="com.atguigu">

</context:component-scan>

‍

情况二：指定要排除的组件

<context:component-scan base-package="com.atguigu">

    <!-- context:exclude-filter标签：指定排除规则 -->

    <!--

        type：设置排除或包含的依据

        type="annotation"，根据注解排除，expression中设置要排除的注解的全类名

        type="assignable"，根据类型排除，expression中设置要排除的类型的全类名

    -->

    <context:exclude-filter type="annotation"expression="org.springframework.stereotype.Controller"/>

    <!--<context:exclude-filter type="assignable"expression="com.atguigu.controller.UserController"/>-->

</context:component-scan>

‍

情况三：仅扫描指定组件

<context:component-scan base-package="com.atguigu" use-default-filters="false">

    <!-- context:include-filter标签：指定在原有扫描规则的基础上追加的规则 -->

    <!-- use-default-filters属性：取值false表示关闭默认扫描规则 -->

    <!-- 此时必须设置use-default-filters="false"，因为默认规则即扫描指定包下所有类 -->

    <!--

        type：设置排除或包含的依据

        type="annotation"，根据注解排除，expression中设置要排除的注解的全类名

        type="assignable"，根据类型排除，expression中设置要排除的类型的全类名

     -->

    <context:include-filter type="annotation"expression="org.springframework.stereotype.Controller"/>

    <!--<context:include-filter type="assignable"expression="com.atguigu.controller.UserController"/>-->

</context:component-scan>

⑧ 测试

‍

@Test

public void testAutowireByAnnotation(){

    ApplicationContext ac = new

        ClassPathXmlApplicationContext("applicationContext.xml");

    UserController userController = ac.getBean(UserController.class);

    System.out.println(userController);

    UserService userService = ac.getBean(UserService.class);

    System.out.println(userService);

    UserDao userDao = ac.getBean(UserDao.class);

    System.out.println(userDao);

}

⑨ 组件所对应的 bean 的 id

‍

在我们使用 XML 方式管理 bean 的时候，每个 bean 都有一个唯一标识，便于在其他地方引用。现在使用

注解后，每个组件仍然应该有一个唯一标识。

默认情况

类名首字母小写就是 bean 的 id。例如：UserController 类对应的 bean 的 id 就是 userController。

自定义 bean 的 id

可通过标识组件的注解的 value 属性设置自定义的 bean 的 id

@Service("userService")//默认为 userServiceImpl public class UserServiceImpl implements

UserService {}

‍

3.2 实验二：基于注解的自动装配

‍

① 场景模拟

‍

参考基于 xml 的自动装配

在 UserController 中声明 UserService 对象

在 UserServiceImpl 中声明 UserDao 对象

②@Autowired 注解

在成员变量上直接标记@Autowired 注解即可完成自动装配，不需要提供 setXxx()方法。以后我们在项

目中的正式用法就是这样。

@Controller

public class UserController {

    @Autowired

    private UserService userService;

    public void saveUser(){

        userService.saveUser();

    }

}

public interface UserService {

    void saveUser();

}

@Service

public class UserServiceImpl implements UserService {

    @Autowired

    private UserDao userDao;

    @Override

    public void saveUser() {

        userDao.saveUser();

    }

}

public interface UserDao {

    void saveUser();

}

@Repository

public class UserDaoImpl implements UserDao {

    @Override

    public void saveUser() {

        System.out.println("保存成功");

    }

}

③@Autowired 注解其他细节

@Autowired 注解可以标记在构造器和 set 方法上

@Controller

public class UserController {

    private UserService userService;

    @Autowired

    public UserController(UserService userService){

        this.userService = userService;

    }

    public void saveUser(){

        userService.saveUser();

    }

}

@Controller

public class UserController {

    private UserService userService;

    @Autowired

    public void setUserService(UserService userService){

        this.userService = userService;

    }

    public void saveUser(){

        userService.saveUser();

    }

}

④@Autowired 工作流程

‍

首先根据所需要的组件类型到 IOC 容器中查找
- 能够找到唯一的 bean：直接执行装配
- 如果完全找不到匹配这个类型的 bean：装配失败
- 和所需类型匹配的 bean 不止一个
  - 没有@Qualifier 注解：根据@Autowired 标记位置成员变量的变量名作为 bean 的 id 进行匹配
  - 能够找到：执行装配
  - 找不到：装配失败
  - 使用@Qualifier 注解：根据@Qualifier 注解中指定的名称作为 bean 的 id 进行匹配
  - 能够找到：执行装配
  - 找不到：装配失败

@Controller

public class UserController {

    @Autowired

    @Qualifier("userServiceImpl")

    private UserService userService;

    public void saveUser(){

        userService.saveUser();

    }

}

@Autowired 中有属性 required，默认值为 true，因此在自动装配无法找到相应的 bean 时，会装

配失败

可以将属性 required 的值设置为 true，则表示能装就装，装不上就不装，此时自动装配的属性为

默认值

但是实际开发时，基本上所有需要装配组件的地方都是必须装配的，用不上这个属性。

2. IOC的更多相关文章

学习AOP之透过Spring的Ioc理解Advisor
花了几天时间来学习Spring,突然明白一个问题,就是看书不能让人理解Spring,一方面要结合使用场景,另一方面要阅读源代码,这种方式理解起来事半功倍.那看书有什么用呢?主要还是扩展视野,毕竟书是别 ...
【调侃】IOC前世今生
前些天,参与了公司内部小组的一次技术交流,主要是针对<IOC与AOP>,本着学而时习之的态度及积极分享的精神,我就结合一个小故事来初浅地剖析一下我眼中的“IOC前世今生”,以方便初学者能更 ...
深入理解DIP、IoC、DI以及IoC容器
摘要面向对象设计(OOD)有助于我们开发出高性能.易扩展以及易复用的程序.其中,OOD有一个重要的思想那就是依赖倒置原则(DIP),并由此引申出IoC.DI以及Ioc容器等概念.通过本文我们将一起学 ...
自己实现简单Spring Ioc
IoC则是一种软件设计模式,简单来说Spring通过工厂+反射来实现IoC. 原理简单说明: 其实就是通过解析xml文件,通过反射创建出我们所需要的bean,再将这些bean挨个放到集合中,然后对外 ...
使用Microsoft的IoC框架：Unity来对.NET应用进行解耦
1.IoC/DI简介 IoC 即 Inversion of Control,DI 即 Dependency Injection,前一个中文含义为控制反转,后一个译为依赖注入,可以理解成一种编程模式,详 ...
DIP原则、IoC以及DI
一.DIP原则高层模块不应该依赖于底层模块,二者都应该依赖于抽象. 抽象不应该依赖于细节,细节应该依赖于抽象. 该原则理解起来稍微有点抽象,我们可以将该原则通俗的理解为:"依赖于抽象&qu ...
【初探Spring】------Spring IOC（三）：初始化过程---Resource定位
我们知道Spring的IoC起到了一个容器的作用,其中装得都是各种各样的Bean.同时在我们刚刚开始学习Spring的时候都是通过xml文件来定义Bean,Spring会某种方式加载这些xml文件,然 ...
【初探Spring】------Spring IOC（二）：初始化过程---简介
首先我们先来看看如下一段代码 ClassPathResource resource = new ClassPathResource("bean.xml"); DefaultList ...
【初探Spring】------Spring IOC（一）
IOC:Inversion of Control(控制反转).IOC它所体现的并不是一种技术,而是一种思想,一种将设计好的对象交给容器来管理的思想.IOC的核心思想就体现在控制.反转这两个词上面,要理 ...
.NET里简易实现IoC
.NET里简易实现IoC 前言在前面的篇幅中对依赖倒置原则和IoC框架的使用只是做了个简单的介绍,并没有很详细的去演示,可能有的朋友还是区分不了依赖倒置.依赖注入.控制反转这几个名词,或许知道的也只 ...

随机推荐

Chrome浏览器插件：CrxMouse（鼠标手势控制浏览器）
CrxMouse是一款谷歌浏览器插件,它可以通过手势来控制您的浏览器,在您的日常网络浏览中提高效率和速度. 插件介绍 CrxMouse是一个非常流行的谷歌浏览器插件,它允许您通过鼠标手势来控制您的浏览 ...
python实现桌面截图功能
PIL中的ImageGrab模块 import time import numpy as np from PIL import ImageGrab img = ImageGrab.grab(bbox= ...
[Linux]常用命令之【hostname】
1: 个人的片面理解: hostname是主机名(的"昵称"),而非域名.一般设置hostname,来标识当前机器的主要用途.以区别与其它机器 2: hostname的严格定义: ...
[灾备]独立磁盘阵列(RAID)技术
本文是对3个月前临时出差前往客户现场,安装交付我司大数据产品时使用的一项硬件级的灾备技术的简要复盘. 1 独立磁盘阵列--RAID:概述 1.1 定义 RAID := Redundant Arrays ...
LeetCode 双周赛 101，DP/中心位贪心/裴蜀定理/Dijkstra/最小环
本文已收录到 AndroidFamily,技术和职场问题,请关注公众号 [彭旭锐] 提问. 大家好,我是小彭. 这周比较忙,上周末的双周赛题解现在才更新,虽迟但到哈.上周末这场是 LeetCode 第 ...
Vue启用报错 RangeError: Invalid typed array length: -4095
近期开发的前端项目项目启用失败,记录下修复过程 RangeError: Invalid typed array length: -4095 错误原因:node版本问题,安装10.x.x 即可重新安装 ...
Java设计模式 —— 外观模式
13 外观模式 13.1 外观模式概述 Facade Pattern: 为子系统的接口提供一组统一的入口.外观模式定义了一个高层接口,这个接口使得子系统的更加容易使用. 在外观模式中,一个子系统的外部 ...
pinia的使用
1. pinia和vuex的区别 pinia没有mutations,只有:state. getters. actions pinia分模块不需要modules(之前vuex分模块需要modules) ...
vue将页面(dom元素)转换成图片，并保存到本地
1 npm install html2canvas --save <template> <div class="QRCode-box"> <img i ...
Python-BeautifulReport的简单使用
一.简介 BeautifulReport.report report ( filename -> 测试报告名称, 如果不指定默认文件名为report.html description -> ...

2. IOC

1. IOC 容器

1.1 IOC 思想

① 获取资源的传统方式

② 反转控制方式获取资源

③DI

1.2 IOC 容器在 Spring 中的实现

①BeanFactory

②ApplicationContext

③ApplicationContext 的主要实现类

2. 基于 XML 管理 bean

2.1 实验一 ： 入门案例

① 创建 Maven Module

② 引入依赖

③ 创建类 HelloWorld

⑤ 在 Spring 的配置文件中配置 bean

⑥ 创建测试类测试

⑦ 思路

⑧ 注意

2.2 实验二 ： 获取 bean 的三种方式

① 方式一：根据 id 获取

② 方式二：根据类型获取

③ 方式三：根据 id 和类型

④ 注意

⑤ 扩展

⑥ 结论

2.3 实验三：依赖注入之 setter 注入

① 创建学生类 Student

② 配置 bean 时为属性赋值

③ 测试

2.4 实验四 ： 依赖注入之构造器注入

① 在 Student 类中添加有参构造

② 配置 bean

③ 测试

2.5 实验五 ： 特殊值处理

① 字面量赋值

②null 值

③xml 实体

④CDATA 节

2.6 实验六 ： 为类类型属性赋值

① 创建班级类 Clazz

② 修改 Student 类

③ 方式一：引用外部已声明的 bean

④ 方式二：内部 bean

③ 方式三：级联属性赋值

2.7 实验七：为数组类型属性赋值

① 修改 Student 类

② 配置 bean

2.8 实验八：为集合类型属性赋值

① 为 List 集合类型属性赋值

② 为 Map 集合类型属性赋值

③ 引用集合类型的 bean

2.9 实验九：p 命名空间

2. 10 实验十：引入外部属性文件

① 加入依赖

② 创建外部属性文件

③ 引入属性文件

④ 配置 bean

⑤ 测试

2.11 实验十一：bean 的作用域

① 概念

② 创建类 User

③ 配置 bean

④ 测试

2.11 实验十二：bean 的生命周期

① 具体的生命周期过程

② 修改类 User

③ 配置 bean

④ 测试

⑤bean 的后置处理器

2.13 实验十三：FactoryBean

① 简介

② 创建类 UserFactoryBean

③ 配置 bean

④ 测试

2.14 实验十四：基于 xml 的自动装配

① 场景模拟

② 配置 bean

③ 测试

3. 基于注解管理 bean

2.1 实验一：入门案例

2.2 实验二：获取 bean 的三种方式

2.4 实验四：依赖注入之构造器注入

2.5 实验五：特殊值处理

2.6 实验六：为类类型属性赋值