当前位置： 首页 > article >正文

Spring基础之——控制反转（IOC）、依赖注入（DI）与切面编程（AOP）概念详解（适合小白，初学者必看）

article 2024/11/16 11:23:36

前言

        本篇博客讲详细介绍Spring框架中的两个最核心且最基础的概念：控制反转（IOC）和面向切面编程（AOP）。以及如何通过IDEA来构建一个Spring项目，通过实战和理论结合的方式来让大家真的学会Spring这个最流行的Java框架。

一、认识Spring（是什么）

1. Spring框架的概述

        Spring是一个开放源代码的设计层面框架，它解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

        它是为了解决企业应用开发的复杂性而创建的。

Spring的核心是控制反转（IOC）和面向切面（AOP）：

  • IOC:控制反转，将创建对象的过程交给spring进行管理.
  • AOP:面向切面，在不修改源代码的情况之下进行代码功能的增强.

2. Spring框架的优点

  • 方便解耦，简化开发，Spring就像一个大工厂，将所有对象的创建和依赖关系维护，交给Spring管理，这也是IOC的作用。
  • AOP编程的支持，Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。
  • 声明式事务的支持，只需要通过配置就可以完成对事务的管理，而无需手动编程。
  • 方便程序的测试，Spring支持Junit4，可以通过注解方便的测试Spring程序。
  • 方便集成各种优秀框架，Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts2、Hibernate、MyBatis等）的直接支持。
  • 降低JavaEE API的使用难度，Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail等），都提供了封装，使这些API应用难度大大降低。

二、Spring项目的创建

如今IDEA比较主流，下面我来演示如何使用IDEA来创建一个Spring项目。

1. 首先我们创建一个Maven工程

不知道如何创建Maven工程的小伙伴，请参考我的这篇博客：

Maven学习—如何在IDEA中配置Maven？又如何创建Maven工程？(详细攻略)_idea创建maven项目-CSDN博客

2. 引入Spring相关的依赖坐标

Spring框架基础依赖:

<dependencies>
<!--    Spring框架基础依赖    -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>

        <!-- 日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        
        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

AOP面相切面编程的依赖: 

<!--  AOP面相切面编程的依赖 -->

        <!--AOP联盟-->
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <!--Spring Aspects-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <!--aspectj-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.3</version>
        </dependency>
3. 创建Spring核心的配置文件 

在resources目录下创建applicationContext.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

</beans>

以上内容，就是一个最基础的Spring项目的创建方法。

三、Spring IOC容器

1. 什么是IOC

IOC （Inverse of Control），控制反转，将对象的创建权力交给给Spring框架去管理，实现控制权的反转。

2. IOC实现的底层原理

IOC的实现，依赖于以下3种技术

  • ① dom4j解析xml文档；
  • ② Java对象的一种创建方式：工厂模式；
  • ③ 采用Java中反射技术来创建对象

想要了解对底层原理深入了解的小伙伴，可以去Spring官网下载Spring底层源码。

Spring官方网站  Spring | HomeLevel up your Java code and explore what Spring can do for you.icon-default.png?t=O83Ahttps://spring.io/

ioc底层有用到反射，面试时如果可以扯一扯Java基础反射相关的东西； 

3、IOC的具体使用

常规情况下，类A中使用类C示意图：

当有了IoC/DI的容器后，A类不再主动去创建C了，
而是被动等待，等待IoC/DI的容器获取一个C的实例，然后反向的注入到A类中，如下图所示：

                                               有IoC/DI容器后程序结构示意图

      

  1. 控制反转（IOC）：是从容器的角度出发，既：容器控制应用程序，由容器反向的向应用程序注入其所需要的外部资源。

  2. 依赖注入（DI）：是从应用程序的角度在描述，既：应用程序依赖容器创建并注入它所需要的外部资源；

         根据上面的讲述，应该能看出来，DI和IOC是对同一件事情的不同描述，从某个方面讲，他们就是同一概念，只是描述的角度不同。

        当然对于我们初学者，我们首先去掌握spring IOC的使用方法即可；下面我来用基础代码为大家演示：Spring的控制反转和依赖注入两大设计理念的含义：

代码演示：

（1）通过IOC来创建Java类

①首先我先定义几个普通的Java类:

Teacher类：

 User类：

 通常情况下，我们若想要去创建这两个类的对象的话，会像下面这样：

  • 使用最普通New的方式
  • 使用反射的方式创建对象
    public void createObjTest01() throws ClassNotFoundException {

        //1.使用最普通new的方式
        User user = new User();

        //2.使用反射的方式创建对象(需要在方法上抛出“找不到类”的异常)
        Class clazz = Class.forName("com.yzx.pojo.User");

    }

 ②但如果我们使用了Spring，我们创建对象的方式将发生改变，演示如下：

首先，在Spring的xml配置文件中进行bean注入：

<?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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="user" class="com.yzx.pojo.User"></bean>
    <bean id="Teacher" class="com.yzx.pojo.Teacher"></bean>

</beans>
  •  id  后面是你自定义该类的别名；
  • class 后面是你要托管给Spring管理的类的全路径；

然后，我们在test目录下创建一个测试类，来验证Spring是否已经可以管理这两个类。

 测试类中的测试方法内容如下：

@Test
    public void createObjTest02() throws ClassNotFoundException {
        //1.首先加Spring的载配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.然后通过ApplicationContext的对象来获取所需对象
        User user = (User)ac.getBean("user");
        Teacher teacher = (Teacher)ac.getBean("teacher");

        usr.test();
        teacher.test();
    }

   运行结果：

 

（2）通过IOC向类注入属性值

首先我们在Spring配置文件中为对象注入属性值

方法一：使用<property>标签来实现对属性的注入，

1.使用<property>标签来实现对属性的注入，使用该标签进行属性注入时，要求pojo类中必须配有setter方法，因此，该方法通常叫做使用setter方法注入

2.标签属性：
name:类中的属性名称
value:向属性注入的值
ref：对象映射

代码如下：

<bean id = "usr" class="com.yzx.pojo.User">

        <!--  ①配置基本类型的属性值   -->
        <property name="id" value="1"/>
        <property name="username" value="admin"/>
        <property name="password" value="123"/>
        <!--  ②配置数组类型的属性值   -->
        <property name="strs">
            <array>
                <value>admin</value>
                <value>张三</value>
                <value>李四</value>
            </array>
        </property>
        <!--  ③配置List集合类型的属性值   -->
        <property name="list">
            <list>
                <value>熊大</value>
                <value>熊二</value>
            </list>
        </property>
        <!--  ④配置map集合类型的属性值   -->
        <property name="map">
            <map>
                <entry key="aaa" value="小白"/>
                <entry key="bbb" value="小黑"/>
            </map>
        </property>
    </bean>

方法二：使用<property>标签来实现对属性的注入，

1.使用<constructor-arg>标签来实现对属性的注入，使用该标签进行属性注入时，要求pojo类中必须配有构造器，因此，该方法通常也叫做利用类的构造器注入。

2.标签属性：
name:类中的属性名称
value:向属性注入的值
ref：对象映射
<bean id="teacher" class="com.yzx.pojo.Teacher">
        <!--  ①配置基本类型的属性值   -->
        <constructor-arg name="id" value="1"/>
        <constructor-arg name="tname" value="李老师"/>
        <!--  ②配置数组类型的属性值   -->
        <constructor-arg name="nums">
            <array>
                <value>1</value>
                <value>2</value>
                <value>3</value>
                <value>4</value>
            </array>
        </constructor-arg>
        <!--  ③配置List集合类型的属性值   -->
        <constructor-arg name="list">
            <list>
                <value>"你好"</value>
                <value>"spring"</value>
            </list>
        </constructor-arg>
        <!--  ④配置map集合类型的属性值   -->
        <constructor-arg name="map">
            <map>
                <entry key="张三" value="12"/>
                <entry key="李四" value="15"/>
            </map>
        </constructor-arg>
    </bean>

测试代码：

@Test
    public void createObjTest02() throws ClassNotFoundException {
        //1.首先加Spring的载配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.然后通过ApplicationContext的对象来获取所需对象
        User user = (User)ac.getBean("usr");

        Teacher teacher = (Teacher)ac.getBean("teacher");

        System.out.println(user.toString());
        System.out.println(teacher.toString());
    }

运行结果：

小结：

通过上述演示，相信大家对Spring框架中IOC和DI的概念有了基础的认识；

        其实IoC/DI对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本具有最大的主动权，需要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC/DI容器来创建并注入应用程序所需要的资源了。
        这样一个改变其实是编程思想的一个大进步，如此就可以有效的分离了对象和它所需要的外部资源，使得代码的耦合度降低，有利于代码复用，更重要的是使得程序的整个体系结构变得非常灵活。

四、Spring AOP面向切面编程

由于篇幅有限，AOP的具体内容请看小编下面的这篇博客

本文参考文献：

控制反转（IOC）和依赖注入（DI）的区别（详细 通俗易懂解释）_控制反转和依赖注入的理解(通俗易懂)-CSDN博客


http://www.kler.cn/a/395760.html

相关文章：

  • TVBox 网络接口
  • layui的table组件中，对某一列的文字设置颜色为浅蓝怎么设置
  • sqlsever 分布式存储查询
  • stream学习
  • MySQL（5）【数据类型 —— 字符串类型】
  • SpringBoot（十八）SpringBoot集成Minio
  • 问：数据库的六种锁机制实践总结？
  • C语言，用最小二乘法实现一个回归模型
  • （附项目源码）Java开发语言，211 springboot 在线问诊系统的设计与实现，计算机毕设程序开发+文案（LW+PPT）
  • 谷歌Gemini发布iOS版App，live语音聊天免费用！
  • 基于微信小程序的乡村研学游平台设计与实现，LW+源码+讲解
  • 科锐国际，蓝禾，汤臣倍健，三七互娱，GE医疗，得物，顺丰，快手，途游游戏25秋招内推
  • 14天Java基础学习——第6天：面向对象编程（类与对象）
  • 实验1-1 顺序表的基本操作
  • ceph的集群管理
  • 计算机的错误计算（一百五十五）
  • HTML5实现俄罗斯方块小游戏
  • jenkins用户在执行scp的时候如何做免密登录
  • 【RabbitMQ】08-延迟消息
  • POD-Transformer多变量回归预测（Matlab）
  • 使用Git工具在GitHub的仓库中上传文件夹(超详细）
  • Python爬虫----python爬虫基础
  • Liunx-Ubuntu22.04.1系统下配置Anaconda+pycharm+pytorch-gpu环境配置
  • OpenAI官方发布：利用ChatGPT提升写作的12条指南
  • 低资源集群中的大语言模型分布式推理技术:Reduce、LayerNorm和Broadcast的作用
  • 基于yolov8、yolov5的鸟类分类系统（含UI界面、训练好的模型、Python代码、数据集）