Spring1（开发工具安装及配置 初始Spring 解耦实现 SpringIOC SpringDI Spring常见面试题）

目录

[一 、开发工具安装及配置](#一 、开发工具安装及配置)

IDEA简介

安装

配置

常⽤快捷键

部署maven

1.配置环境​编辑

2.创建一个maven项目​编辑

选择maven​编辑​编辑

二、初始Spring

Spring历史由来

Spring体系结构

Spring生态系统

三、解耦实现

jdbc

三层思想​编辑

四、SpringIOC

实现：

五、SpringDI

set注入

[实现：set注入 javaBean对象](#实现：set注入 javaBean对象)

[实现：set注入 基本类型与String](#实现：set注入 基本类型与String)

[实现：set注入 复杂类型](#实现：set注入 复杂类型)

构造注入

[实现：构造注入 基本类型与String](#实现：构造注入 基本类型与String)

[实现：构造注入 javaBean对象](#实现：构造注入 javaBean对象)

六、Spring常见面试题

[01. Spring框架的基本理解](#01. Spring框架的基本理解)

[02. Spring框架由哪些模块组成？](#02. Spring框架由哪些模块组成？)

[03. Spring IOC的理解](#03. Spring IOC的理解)

[04. Spring IOC 容器的理解](#04. Spring IOC 容器的理解)

[05. Spring DI 的理解](#05. Spring DI 的理解)

---

一 、开发工具安装及配置

IDEA简介

IDEA 全称IntelliJ IDEA，是java语⾔开发的集成环境；IntelliJ在业界被公认为最好的java开发⼯具 之⼀，尤其在智能代码助⼿、代码⾃动提示、重构、J2EE⽀持、Ant、JUnit、CVS整合、代码审 查⽅⾯。 JetBrains官⽹ : https://www.jetbrains.com/ 了解：JetBrains公司开发的所有⼯具

安装

1.双击exe⽂件 2.选择安装的⽬录3.选择是否⽣成快捷⽅式和建⽴⽂件关联4.完成安装

配置

设置是否导⼊之前的配置

设置主题

设置需要的功能（定制idea）暂时不选设置插件

选择免费试⽤30天进⼊全局设置

或者进入之后选择 file-》settings

修改⽂件编码区分⼤⼩写代码提示取消设置类模板JDK环境配置

configure->structure for new projects

常⽤快捷键

F7	F8	F9
进方法	往下执行	跳过

快捷键	功能描述
Ctrl+Alt+L	一健格式化代码(和qq冲突，需要关闭qq的热键)
Ctrl+shift+R	全局搜索替换
Shift+Shift	强大的搜索功能(无论您想要搜啥都能找到)
Ctrl+N	按照类名搜索类
Alt+Insert	可以生成构造器/Getter/Setter等
Alt+Enter	导入包
Ctrl+Alt+T	可以把代码包在一个块内，例如：try/catch
Ctrl+R	替换文本
Ctrl+F	查找文本
Ctrl+O	重写方法
Shift+F6	重构-重命名
Ctrl+X	删除行
Ctrl+D	复制行
Ctrl+Y	删除行
Ctrl+/	单行注释
Ctrl+Shift+/	多行注释
Ctrl+H	显示类结构图(类的继承层次)
Ctrl+Alt+B	跳转到方法实现处
Alt+Left/Right	切换代码视图
Alt+Up/Down	在方法间快速移动定位
iter	生成array for代码块
itli	生成List的遍历
iter	生成增强for循环
psvm	main函数
sout	System.out.println()
Ctrl+J	查看更多

部署maven

1.配置环境

或者

进行以下更改

2.创建一个maven项目

选择maven

在poi.xml配置依赖

二、初始Spring

Spring****历史由来

企业级应用指的是 大规模、性能和安全要求高、业务复杂、灵活多变的大型 WEB 应用程序。

• **大规模：**用户量和 IP/PV访问量大、海量数据、功能模块多代码量大。
• **业务复杂：**涉及金融、期货、电信等特殊领域的业务逻辑复杂，对系统架构提出新要求。
• **性能和安全要求高：**响应毫秒数和安全级别均有很高的要求。
• **灵活多变：**经常性的业务变更，也对开发效率以及项目部署等工作有更高的要求。

重量级技术向轻量级开发过度

为了实现企业级应用开发各类需求，涌现出以EJB为代表的一系列技术。

Spring之父

Rod Johnson，SpringFramework创始人, interface21 CEO。
• 1996 年开始关注 Java 服务器端技术
• Servlet2.4 和 JDO2.0 专家组成员
• Expert One-to-One J2EE Design and Development(2002)
• 阐述了 J2EE 使用EJB 开发设计的优点及解决方案
• Expert One-to-One J2EE Development without EJB(2004)
• 阐述了 J2EE 开发不使用 EJB的解决方式（Spring 雏形 ）
• 2004年3月24日发布了Spring Framework 1.0 final
**技术主张：**技术应当回归实用为主，简化 Java 开发
**Spring的理论基础：**Spring 框架建立在本书中对于J2EE企业级应用的开发与设计的核心理念之上，追求简洁、轻量级的开发方式，让系统具备更好的健壮性和可扩展性。

Spring****体系结构

• **Spring Core：**Spring框架的最基础部分，提供DI（依赖注入）特性。
• **Spring Context：**Spring上下文，提供Bean容器的集合。
• **Spring AOP：**基于Spring Core的符合规范的切面编程的实现。
• **Spring JDBC：**提供了JDBC的抽象层，简化了JDBC编码。
• **Spring ORM：**对主流ORM框架（Hibernate、Toplink等）进行集成。
• **Spring Web：**为Spring在Web应用程序中的使用提供了支持。

Spring 官网 spring.io

Spring****生态系统

• **Spring Boot：**简化产品级的 Spring 应用和服务的创建，简化了配置文件，使用嵌入式web服务器，含有诸多开箱即用微服务功能。
• **Spring Data：**是一个数据访问及操作的工具包，封装了很多种数据及数据库的访问相关技术，包括：jdbc、Redis、MongoDB、Neo4j等。
• **Spring AMQP：**消息队列操作的工具包，主要是封装了RabbitMQ的操作。
• **Spring Cloud：**微服务工具包，用于创建基于云计算架构的原生微服务应用。
• **Spring Security：**是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。
• **Spring Mobile：**是Spring MVC的扩展，用来简化手机上的Web应用开发。

三、解耦实现

=======================spring==============================

spring两大核心思想：

• 一.springIOC(控制反转)springDI(依赖注入)
• 二.springAOP(面向切面)

springIOC：springIOC容器扮演项目的载体，管理整个Java项目，ioc容器可以是项目更符合高内聚，低耦合的变成思想，"解耦"
耦合：类与类有耦合，方法与方法有耦合

解耦：

• 1.尽量避免new对象，通过反射实例化
• 2.需要创建的对象不要写死，而是把类名保存在独立的properties文件中，按需加载

jdbc

/**
 * @author zkt
 * @Version 1.0
 * @since 2024/7/15
 */
public class Test01 {
    public static void main(String[] args) throws  Exception{
        /************************方式1（耦合度高）****************************/
//        DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());
//        Connection root = DriverManager.getConnection("jdbc:mysql://localhost:3306/myhomework04?serverTimezone=GMT", "root", "123456");
//        System.out.println(root);//com.mysql.cj.jdbc.ConnectionImpl@ba8d91c

        /************************方式2（耦合度中）****************************/
//        Class.forName("com.mysql.cj.jdbc.Driver");
//        Connection root = DriverManager.getConnection("jdbc:mysql://localhost:3306/myhomework04?serverTimezone=GMT", "root", "123456");
//        System.out.println(root);//com.mysql.cj.jdbc.ConnectionImpl@70b0b186

        /************************方式3（耦合度低）****************************/
        //1.创建工具
        Properties properties = new Properties();
        //2.加载资源文件
        InputStream stream = Test01.class.getClassLoader().getResourceAsStream("jdbc.properties");
        properties.load(stream);
        //3.通过key获取value
        String driver = properties.getProperty("msg1");
        String url = properties.getProperty("msg2");
        String user = properties.getProperty("msg3");
        String pwd = properties.getProperty("msg4");
        Class.forName(driver);
        Connection root = DriverManager.getConnection(url,user,pwd);
        System.out.println(root);//com.mysql.cj.jdbc.ConnectionImpl@ba8d91c

    }
}

---

三层思想

首先需要在main-》resources下新建一个properties配置文件

service=com.zkt.service.UserServiceImp
dao=com.zkt.dao.UserDaoImp

controller

public interface IUserController {
    public void save();
}

public class UserControllerImp implements IUserController {
    /******************高耦合**********************/
//    IUserService service =    new UserServiceImp();

    /****************高耦低**********************/
    IUserService service = (IUserService) BeansFactory.getBean("service");

    public void save() {
        System.out.println("====controller的新增====");
        service.save();
    }
}

dao

public interface IUserDao {
    public void save();
}

public class UserDaoImp implements IUserDao{
    public void save() {
        System.out.println("====dao的新增====");
    }
}

service

public interface IUserService {
    public void save();
}

public class UserServiceImp implements IUserService {
    /******************高耦合**********************/
//    IUserDao dao = new UserDaoImp();

    /****************高耦低**********************/
    IUserDao dao = (IUserDao) BeansFactory.getBean("dao");

    public void save() {
        System.out.println("====service的新增====");
        dao.save();
    }
}

factory

public class BeansFactory {
    public static Object getBean(String key){
        //按照需求创建对象
        try {
            //准备工作
            Properties properties = new Properties();
            InputStream stream = BeansFactory.class.getClassLoader().getResourceAsStream("beans.propreties");
            properties.load(stream);
            //获取vlaue创建对象
            String pathClass = properties.getProperty(key);
            return  Class.forName(pathClass).newInstance();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return  null;
    }


}

test

/**
 * @author zkt
 * @Version 1.0
 * @since 2024/7/15
 */
public class Test01 {
    public static void main(String[] args) {
        IUserController controller = new UserControllerImp();
        controller.save();
    }
}

四、SpringIOC

======================springIOC/DI=========================
spring环境搭建：

1.坐标

2.配置文件

springIOC:控制反转

• ● 关键字：IOC名词解释，作用是解耦，使用IOC容器管理项目组件之间的耦合关系
• **● IOC( Inversion of Control，中文释义：控制反转 )**是Spring框架的核心思想之一，主要用于解耦。IOC是指将创建对象的控制权转移给Spring框架进行管理。 由Spring框架根据配置文件或注解等方式，创建bean对象并管理各个bean对象之间的依赖关系。使对象之间形成松散耦合的关系，实现解耦；

○ 控制 ：指的是对象创建（实例化、管理）的权力

○ 反转 ：控制权交给外部环境（Spring框架、IoC容器）

springIOC使用步骤：

1.创建类

2.将需要spring管理的类，注入springIOC容器

        <bean id="唯一标识" class="类的完全限定名称"></bean>

3.以解耦方式获取javaBean实例对象

3.1加载spring主配置文件，获取spring核心对象

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

3.2获取javaBean

    Student  student = (Student) applicationContext.getBean("student");

实现：

在poi.xml配置

<dependencies>
        <!-- spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.12</version>
        </dependency>
    </dependencies>

新建类

controller

public interface IUserController {
    public void save();
}

public class UserControllerImp  implements IUserController{
    public void save() {
        System.out.println("====controller的新增====");
    }
}

dao

public interface IUserDao {
    public void save();
}

public class UserDaoImp implements IUserDao{
    public void save() {
        System.out.println("====dao的新增====");
    }
}

service

public interface IUserService {
    public void save();
}

public class UserServiceImp implements  IUserService{
    public void save() {
        System.out.println("====service的新增====");
    }
}

pojo

public class Student {
    private  String stuName;
    private  String stuHobby;
    private  int stuAge;
get、set 构造方法 tostring 省略

}

2.将需要spring管理的类，注入springIOC容器

main-》resources下 new -》xml->SpringConfig

beans.xml

 <!-- 注入studdent类 -->
    <bean id="student" class="com.zkt.pojo.Student"></bean>
    <!-- 注入date -->
    <bean id="date" class="java.util.Date"/>
    <!-- 注入dao -->
    <bean id="daoImp" class="com.zkt.dao.UserDaoImp"/>
    <!-- 注入service -->
    <bean id="serviceImp" class="com.zkt.service.UserServiceImp"/>
    <!-- 注入controller -->
    <bean id="controllerImp" class="com.zkt.controller.UserControllerImp"/>

3.以解耦方式获取javaBean实例对象

test

/**
 * @author zkt
 * @Version 1.0
 * @since 2024/7/15
 */
public class Test01 {
    public static void main(String[] args) {
        //1.加载spring主配置文件，获取spring核心对象
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        //2.获取javaBean
        Student student = (Student)applicationContext.getBean("student");
        Date date = (Date)applicationContext.getBean("date");
        System.out.println(date);
        System.out.println(student);
        System.out.println("=======================================");

        IUserDao dao = (IUserDao)applicationContext.getBean("daoImp");
        IUserService service = (IUserService)applicationContext.getBean("serviceImp");
        IUserController controller = (IUserController)applicationContext.getBean("controllerImp");

        controller.save();
        service.save();
        dao.save();

    }
}

Demo02 Demo03

BeansFactory ApplicationContext

getBean(key) getBean(id)

beans.properties beans.xml

key=value id=class

关键字:

接口

BeanFactory(父)：多例模式

ApplicationContext(子)：单例模式

实现类

ClassPathXmlApplicationContext:通过相对路径加载主配置文件

FileSystemXmlApplicationContext:通过绝对路径加载主配置文件

AnnotationConfigApplicationContext:加载配置"类"

五、SpringDI

======================springIOC/DI=========================
Spring DI 的理解

DI（Dependecy Inject，中文释义：依赖注入）
是对IOC概念的不同角度的描述，是指应用程序在运行时，每一个bean对象都依赖IOC容器注入当前bean对象所需要的另外一个bean对象。

（例如在MyBatis整合Spring时，SqlSessionFactoryBean 依赖IOC容器注入一个

DataSource数据源bean）；

springDI实现方式：

• 1.set注入
• 2.构造注入
• 3.注解注入

springDI支持的数据类型:

• 1.基本类型与String
• 2.javaBean对象
• 3.复杂类型**（构造注入不支持）**

di实现步骤（set）****：

• 1.思考
• 2.提供对应方法（set）

setXXXX()

• 3.配置

<property 属性名="属性值"></property>
        属性：
           name：属性名
           ref：注入的值的引用
           value：注入的值

di实现步骤（构造）

• 1.思考
• 2.提供对应方法（构造）
• 3.配置

 <constructor-arg 属性名="属性值"></constructor-arg>
         属性：
           name：属性名
           type: 参数类型
           index: 参数下标
           ref：注入的值的引用
           value：注入的值

总结IOC-DI：

原来要对象，自己造自己用

现在要对象，容器造，容器拼一起，自己用

spring胶水框架

set注入

**实现：**set注入 javaBean对象

在poi.xml配置

<dependencies>
        <!-- spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.12</version>
        </dependency>
    </dependencies>

新建类

将需要spring管理的类，注入springIOC容器

main-》resources下 new -》xml->SpringConfig

beans.xml

<!-- 注入dao -->
    <bean id="daoImp" class="com.zkt.dao.UserDaoImp"/>
    <!-- 注入service -->
    <bean id="serviceImp" class="com.zkt.service.UserServiceImp">
        <property name="dao" ref="daoImp"/>
    </bean>
    <!-- 注入controller -->
    <bean id="controllerImp" class="com.zkt.controller.UserControllerImp">
        <property name="service" ref="serviceImp"/>
    </bean>

controller

public interface IUserController {
    public void save();
}

public class UserControllerImp implements  IUserController{
    IUserService service;

    public void setService(IUserService service) {
        this.service = service;
    }
    public void save() {
        System.out.println("====controller的新增====");
        service.save();
    }
}

dao

public interface IUserDao {
    public void save();
}

public class UserDaoImp implements  IUserDao{
    public void save() {
        System.out.println("====dao的新增====");
    }
}

service

public interface IUserService {
    public void save();
}


public class UserServiceImp implements IUserService{
    IUserDao dao;

    public void setDao(IUserDao dao) {
        this.dao = dao;
    }

    public void save() {
        System.out.println("====service的新增====");
        dao.save();
    }
}

test

**
 * @author zkt
 * @Version 1.0
 * @since 2024/7/15
 */
public class Test01 {
    public static void main(String[] args) {
        //1.加载spring主配置文件，获取spring核心对象
        ApplicationContext applicationContext =  new ClassPathXmlApplicationContext("beans.xml");
        //2.获取javaBean
        IUserController controller = (IUserController) applicationContext.getBean("controllerImp");
        controller.save();
    }
}

**实现：**set注入 基本类型与String

配置同上

pojo

Student

public class Student {
    private  String stuName;
    private  String stuHobby;
    private  int stuAge;
     set tostring 省略

}

beans.xml

 <!-- =========================set注入基本类型与String============================== -->
    <bean id="student" class="com.zkt.pojo.Student">
        <property name="stuName" value="zkt"></property>
        <property name="stuAge" value="22"></property>
        <property name="stuHobby" value="足球"></property>
    </bean>

**实现：**set注入 复杂类型

配置同上

pojo

Teacher

public class Teacher {
    private List mylist;
    private Set myset;
    private  String[] myarray;
    private Map mymap;
    private Properties prop;

        set tostring 省略
}

beans.xml

<bean id="teacher" class="com.zkt.pojo.Teacher">
        <property name="mymap">
            <map>
                <entry key="zkt1" value="football"></entry>
                <entry key="zkt2" value="pingpang"></entry>
                <entry key="zkt3" value="basketball"></entry>
            </map>
        </property>
        <property name="prop">
            <props>
                <prop key="中国">北京</prop>
                <prop key="法国">巴黎</prop>
                <prop key="葡萄牙">里斯本</prop>
            </props>
        </property>
        <property name="myarray">
            <array>
                <value>小米</value>
                <value>华为</value>
                <value>苹果</value>
            </array>
        </property>
        <property name="mylist">
            <list>
                <value>石家包子</value>
                <value>老孙家泡馍</value>
                <value>马昆砂锅</value>
                <value>新亮烤肉</value>
            </list>
        </property>
        <property name="myset">
            <set>
                <value>cs2</value>
                <value>lol</value>
                <value>apex</value>
            </set>
        </property>
    </bean>

测试：

public class Test01 {
    public static void main(String[] args) {
        //1.加载spring主配置文件，获取spring核心对象
        ApplicationContext applicationContext =  new ClassPathXmlApplicationContext("beans.xml");
        //2.获取javaBean
//        IUserController controller = (IUserController) applicationContext.getBean("controllerImp");
//        controller.save();

        Student student = (Student)applicationContext.getBean("student");
        System.out.println(student);

        Teacher teacher = (Teacher)applicationContext.getBean("teacher");
        System.out.println(teacher);

    }
}

构造注入

**实现：**构造注入 基本类型与String

pojo

Student

public class Student {
    private  String stuName;
    private  String stuHobby;
    private  int stuAge;
     构造方法 无参 有参 tostring 省略

}

beans.xml

 <!-- =========================构造注入基本类型与String============================== -->
    <bean id="student2" class="com.zkt.pojo.Student">
        <constructor-arg name="stuName" value="zkt1"></constructor-arg>
        <constructor-arg name="stuHobby" value="football"></constructor-arg>
        <constructor-arg name="stuAge" value="22"></constructor-arg>
    </bean>
    <bean id="student3" class="com.zkt.pojo.Student">
        <constructor-arg index="0" value="zkt2"></constructor-arg>
        <constructor-arg index="1" value="basketball"></constructor-arg>
        <constructor-arg index="2" value="22"></constructor-arg>
    </bean>
    <bean id="student4" class="com.zkt.pojo.Student">
        <constructor-arg type="java.lang.String" value="zkt3"></constructor-arg>
        <constructor-arg type="java.lang.String" value="run"></constructor-arg>
        <constructor-arg type="int" value="24"></constructor-arg>
    </bean>

测试：

public class Test01 {
    public static void main(String[] args) {
        //1.加载spring主配置文件，获取spring核心对象
        ApplicationContext applicationContext =  new ClassPathXmlApplicationContext("beans.xml");
        Student  student2 = (Student) applicationContext.getBean("student2");
        Student  student3 = (Student) applicationContext.getBean("student3");
        Student  student4 = (Student) applicationContext.getBean("student4");
        System.out.println(student2);
        System.out.println(student3);
        System.out.println(student4);

    }
}

**实现：**构造注入 javaBean对象

pojo

Teacher

public class Teacher {
    private List mylist;
    private Set myset;
    private  String[] myarray;
    private Map mymap;
    private Properties prop;

    private Student student;

    public Teacher(Student student) {
        this.student = student;
    }

    public Teacher() {
    }

      tostring 省略
}

beans.xml

 <!-- =========================构造注入javaBean对象============================== -->
    <bean id="student5" class="com.zkt.pojo.Student"/>
    <bean id="teacher2" class="com.zkt.pojo.Teacher">
        <constructor-arg name="student" ref="student5"></constructor-arg>
    </bean>

测试

public class Test01 {
    public static void main(String[] args) {
        //1.加载spring主配置文件，获取spring核心对象
        ApplicationContext applicationContext =  new ClassPathXmlApplicationContext("beans.xml");
        Teacher teacher2 = (Teacher) applicationContext.getBean("teacher2");
        System.out.println(teacher2);

    }
}

六、Spring常见面试题

01. Spring框架的基本理解

• 关键词：核心思想IOC\AOP、作用（解耦、简化）、简单描述框架组成

• Spring框架是一款轻量级的开发框架，核心思想是IOC（控制反转）和AOP（面向切面编程），为Java应用程序开发提供组件管理服务，用于组件之间的解耦，以及简化第三方JavaEE中间件技术的使用（JMS、任务调度、缓存、ORM框架），是一个基础架构型的开发框架。

• Spring框架包括：IOC容器、Validation数据校验、AOP面向切面编程、Transactions事务管理、Spring JDBC、Spring MVC框架、以及各类第三方JavaEE中间件技术集成；

02. Spring框架由哪些模块组成？

• 关键词：官方文档描述，由7个模块组成

• 根据官方文档的描述，主要包括以下常用5个模块：

1. Core: 核心模块

   包括：IoC Container (ioc容器)，Events (事件通知机制)，Resources (资源加载机制)，i18n (国际化)，Validation (数据校验)，Data Binding (数据绑定)，Type Conversion (类型转换)，SpEL (Spring表达式)，AOP (面向切面编程)；

2. Testing: 测试模块

   包括：Mock Objects (测试模拟对象)，TestContext Framework (测试框架)，Spring MVC Test (用于测试Spring MVC)，WebTestClient (用于测试WebClient、Restful、WebFlux 等);

3. Data Access: 数据访问模块

   包括：Transactions (事务管理)，DAO Support (统一的数据访问对象 DAO 模式的封装)，JDBC (Spring对于JDBC的操作封装)，ORM (Spring 对于对象关系映射框架的封装，例如Hibernate 等框架)等;

4. Web Servlet: 基于Servlet的Web应用开发

   包括：Spring MVC (Spring基于MVC模式设计封装的Web框架)，WebSocket (Spring 集成 WebSocket，WebSocket 是一个服务器与客户端双向通信的技术)等;

5. Integration: 企业级系统集成模块（不同系统之间的交互集成）

   包括：Remoting (Spring 用于在分布式系统中进行远程服务调用的通讯框架)，JMS (Spring集成各类Java消息中间件、Java消息服务【Java Message Service】，例如ActiveMQ等)，Java Email (邮件发送)，Tasks Scheduling (任务调度);

03. Spring IOC的理解

• 关键词：IOC 名词解释，作用是解耦，使用 IOC 容器管理项目组件之间的耦合关系

• IOC (Inversion of Control, 中文释义: 控制反转) 是 Spring 框架的核心思想之一，主要用于了解耦。IOC 是指将创建对象的控制权转移给 Spring 框架进行管理。由 Spring 框架根据配置文件或注解等方式，创建 bean 对象并管理各个 bean 对象之间的依赖关系。使对象之间形成松散耦合的关系，实现解耦

  • 控制：指的是对对象创建（实例化、管理）的权力
  • 反转：控制权交给外部环境（Spring 框架、Ioc 容器）

04. Spring IOC 容器的理解

• 关键词：IOC 容器的作用、存储形式、初始化过程
• IOC通常被理解为 Ioc Container 容器，IOC 容器其实就是一个 Map，key 是每个bean 对象的ID，value 是 bean 对象本身。IOC 容器负责创建 bean 对象并管理 bean 的生命周期，并且根据配置好配置文件或注解，管理 Ioc 容器中的每个 bean，以及根据 bean 之间的依赖关系，完成 bean 之间的注入。
• IOC 容器属于 Spring Core 模块，用来创建和管理 Bean，默认使用单例的方式将 bean 存储在 DefaultListableBeanFactory 类的 beanDefinitionMap 中（一个ConcurrentHashMap 类型的Map集合）；
• IOC 容器使用 ConcurrentHashMap 集合存储了 BeanDefinition 对象，对该对象封装了 Spring 对一个 Bean 所有配置信息，包括：类名、属性、构造方法参数、依赖、是否延迟加载、是否是单例等配置信息；

05. Spring DI 的理解

• 关键词：名词解释
• DI (Dependency Inject, 中文释义: 依赖注入)是对 IOC 概念的不同角度的描述，是指应用程序在运行时，每一个 bean 对象都依赖于 Ioc 容器，Ioc 容器注入当前 bean 对象所需要的另外一个 bean 对象。（例如在 Mybatis 整合 Spring 时，SqlSessionFactoryBean 依赖 Ioc 容器注入一个 DaataSource 数据源 bean）；