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

冯诺依曼转世2024-07-20 0:08

目录

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

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

java 复制代码 
/**
 * @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

java 复制代码 
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

java 复制代码 
public interface IUserDao {
    public void save();
}

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

service

java 复制代码 
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

java 复制代码 
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

java 复制代码 
/**
 * @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容器

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

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

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

java 复制代码 
            ApplicationContext applicationContext =  new ClassPathXmlApplicationContext("beans.xml");

3.2获取javaBean

java 复制代码 
    Student  student = (Student) applicationContext.getBean("student");

实现：

在poi.xml配置

XML 复制代码 
<dependencies>
        <!-- spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.12</version>
        </dependency>
    </dependencies>

新建类

controller

java 复制代码 
public interface IUserController {
    public void save();
}

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

dao

java 复制代码 
public interface IUserDao {
    public void save();
}

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

service

java 复制代码 
public interface IUserService {
    public void save();
}

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

pojo

java 复制代码 
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

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

java 复制代码 
/**
 * @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.配置
XML 复制代码 
<property 属性名="属性值"></property>
        属性：
           name：属性名
           ref：注入的值的引用
           value：注入的值

di实现步骤（构造）

  • 1.思考
  • 2.提供对应方法（构造）
  • 3.配置
XML 复制代码 
 <constructor-arg 属性名="属性值"></constructor-arg>
         属性：
           name：属性名
           type: 参数类型
           index: 参数下标
           ref：注入的值的引用
           value：注入的值

总结IOC-DI：

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

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

spring胶水框架

set注入

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

在poi.xml配置

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

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

java 复制代码 
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

java 复制代码 
public interface IUserDao {
    public void save();
}

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

service

java 复制代码 
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

java 复制代码 
**
 * @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

java 复制代码 
public class Student {
    private  String stuName;
    private  String stuHobby;
    private  int stuAge;
     set tostring 省略

}

beans.xml

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

java 复制代码 
public class Teacher {
    private List mylist;
    private Set myset;
    private  String[] myarray;
    private Map mymap;
    private Properties prop;

        set tostring 省略
}

beans.xml

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>

测试：

java 复制代码 
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

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

}

beans.xml

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>

测试：

java 复制代码 
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

java 复制代码 
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

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>

测试

java 复制代码 
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）；
相关推荐
跟着珅聪学java37 分钟前
spring boot +Elment UI 上传文件教程
java·spring boot·后端·ui·elementui·vue
我命由我1234542 分钟前
Spring Boot 自定义日志打印（日志级别、logback-spring.xml 文件、自定义日志打印解读）
java·开发语言·jvm·spring boot·spring·java-ee·logback
lilye6643 分钟前
程序化广告行业（55/89）：DMP与DSP对接及数据统计原理剖析
java·服务器·前端
徐小黑ACG2 小时前
GO语言 使用protobuf
开发语言·后端·golang·protobuf
·薯条大王4 小时前
MySQL联合查询
数据库·mysql
战族狼魂4 小时前
CSGO 皮肤交易平台后端 (Spring Boot) 代码结构与示例
java·spring boot·后端
xyliiiiiL5 小时前
ZGC初步了解
java·jvm·算法
杉之6 小时前
常见前端GET请求以及对应的Spring后端接收接口写法
java·前端·后端·spring·vue
morris1316 小时前
【redis】redis实现分布式锁
数据库·redis·缓存·分布式锁
hycccccch6 小时前
Canal+RabbitMQ实现MySQL数据增量同步
java·数据库·后端·rabbitmq
热门推荐
01我决定放弃搞 Java 了02DeepSeek各版本说明与优缺点分析03如何在WPS和Word/Excel中直接使用DeepSeek功能04RAG 实践- Ollama+RagFlow 部署本地知识库05本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07如何本地部署AI智能体平台，带你手搓一个AI Agent08苍穹外卖面试总结09DeepSeek RAGFlow构建本地知识库系统10【芯片封测学习专栏 -- D2D 和 C2C 之间的区别】