【Spring框架三】——Spirng IOC和DI的实现

这篇具有很好参考价值的文章主要介绍了【Spring框架三】——Spirng IOC和DI的实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

系列文章目录

【Spring框架一】——Spring框架简介



前言

本篇博客主要总结的是以Spring 5为例,通过XML方式和注解的方式分别实现IOC和DI。并使用Spring5 进行基础运用。


一、IDEA新建Spring 项目

  1. 创建Maven项目:使用IDE创建一个maven项目
  2. 添加Spring依赖:在Maven配置文件pom.xml中添加Spring框架的依赖项
<dependencies>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.3.8</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.8</version>
  </dependency>
</dependencies>

  1. 这样Spring的基础环境已经搭建完毕
    项目的主体结构为三层结构,层与层之间通过接口进行隔离
    【Spring框架三】——Spirng IOC和DI的实现

二、使用XML文件的方式实现IOC和DI

实现依赖注入的方式常用的有构造函数注入setter方法注入

1.创建XML文件

在resources目录下创建applicationContext.xml文件,之后需要在xml文件中配置组件(指Spring容器中的管理的对象)和依赖关系

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
          http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context.xsd">




</beans>

2. 通过构造函数的方式进行注入

IXMLUserDaoImpl类

package com.wangwei.springioc.dao.daoImpl;

import com.wangwei.springioc.dao.IXMLUserDao;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : UserDaoImpl
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/9 9:04]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/9 9:04]
 * @updateRemark : [描述说明本次修改内容]
 */
public class IXMLUserDaoImpl implements IXMLUserDao {
    @Override
    public void addUser(String username, String password) {
        System.out.println("IUserDaoImpl.addUser()"+username+password);
    }
}

IXMLUserDao接口

package com.wangwei.springioc.dao;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : UserDao
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/9 9:04]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/9 9:04]
 * @updateRemark : [描述说明本次修改内容]
 */
public interface IXMLUserDao {
    void addUser(String username, String password);

}

XMLUserManagerImpl类

package com.wangwei.springioc.manager.managerImpl;

import com.wangwei.springioc.dao.IXMLUserDao;
import com.wangwei.springioc.manager.IXMLUserManager;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : UserManagerImpl
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/9 9:03]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/9 9:03]
 * @updateRemark : [描述说明本次修改内容]
 */
public class XMLUserManagerImpl implements IXMLUserManager {

       //构造函数注入
    private  IXMLUserDao ixmlUserDao;
    public XMLUserManagerImpl(IXMLUserDao ixmlUserDao) {
        this.ixmlUserDao=ixmlUserDao;
    }
    
    @Override
    public void addUser(String name, String password) {
        ixmlUserDao.addUser(name,password);
    }
}

IXMLUserManager接口

package com.wangwei.springioc.manager;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : IUserManager
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/9 9:02]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/9 9:02]
 * @updateRemark : [描述说明本次修改内容]
 */
public interface IXMLUserManager {
    void addUser(String name ,String password);
}

在xml文件中配置通过构造函数的方式进行注入
由于在XMLUserManagerImpl类中通过接口依赖到了IXMLUserDaoImpl类,所以需要在xml配置其依赖关系。

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
          http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context.xsd">


    <bean id="userDao" class="com.wangwei.springioc.dao.daoImpl.IXMLUserDaoImpl"/>

    <bean id="userManager" class="com.wangwei.springioc.manager.managerImpl.XMLUserManagerImpl">
        <!--构造函数注入-->
        <constructor-arg ref="userDao"/>
      
     </bean>
</beans>

XMLClient类进行调用

package com.wangwei.springioc.client;

import com.wangwei.springioc.manager.IXMLUserManager;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : Client
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/9 9:11]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/9 9:11]
 * @updateRemark : [描述说明本次修改内容]
 */
public class XMLClient {
    public static void main(String[] args) {
    //通过Spring的XML配置文件创建了一个IOC容器,并读取文件中的定义,创建相应的Bean对象并将它们放到IOC容器中
        BeanFactory factory=new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取名为userManager的Bean对象
        IXMLUserManager IXMLUserManager =(IXMLUserManager) factory.getBean("userManager");
        IXMLUserManager.addUser("wangwei","123");
    }

}

运行结果

【Spring框架三】——Spirng IOC和DI的实现

3.setter方法进行注入

  1. 需要在依赖方,创建对应的setter方法
    //setter方式注入
    private IXMLUserDao ixmlUserDao;
    public void setIxmlUserDao(IXMLUserDaoImpl ixmlUserDao) {
        this.ixmlUserDao=ixmlUserDao;
    }
  1. xml文件中进行配置
<bean id="userDao" class="com.wangwei.springioc.dao.daoImpl.IXMLUserDaoImpl"/>

    <bean id="userManager" class="com.wangwei.springioc.manager.managerImpl.XMLUserManagerImpl">
       
        <!--setter方法注入-->
        <property name="ixmlUserDao" ref="userDao"/>
       
     </bean>

三、使用注解的方式实现IOC和DI

Spring 5中的常用注解

@Component

@Component是Spring框架中最基本的注解之一,它的作用是将Java类定义为一个Bean,并在程序启动的时候告诉Spring这个类需要被Spring 管理。

@Service

@Service用于标记一个类为服务类(Service class),通常是指该类用于处理业务逻辑的类。并在程序启动的时候告诉Spring这个类需要被Spring 管理。

@Repository

用于将数据访问层 (DAO) 类标记为 Spring Bean,并为其提供 Spring 特定的异常转换。在程序启动的时候告诉Spring这个类需要被Spring 管理。

@Autowired

它可以自动地为我们进行依赖注入。当一个类中有一个属性需要依赖注入时,我们可以在这个属性上面使用@Autowired注解,而在程序启动的时候Spring框架会自动找到这个属性对应的Bean,并将其注入到类中。
@Autowired注解可以用在属性构造方法、和方法上。如果被注入的类有多个实现,可以使用@Qualifier注解来指定具体注入哪个实现。

@Bean

用于在配置类中定义一个Bean,@Bean 注解只有在 Spring 配置类中才会生效。
@Bean注解可以用在一个方法上,该方法可以创建一个对象并返回该对象的实例。这个对象会被Spring容器管理并可以被其他对象注入。
使用@Bean注解时,可以将其放置在一个类的任意方法上(通常是@Configuration注解的类中),方法返回的对象实例可以被Spring容器进行管理。在程序启动的时候告诉Spring这个类需要被Spring 管理。

@Configuration

用于标记类为配置类。在 Spring 中,配置类是一种特殊的类,用于配置应用程序上下文中的 bean。使用 @Configuration 注解的类可以包含 @Bean 注解,用于声明 bean 定义。这些 bean 可以是被 Spring 托管的任何类型。在程序启动的时候告诉Spring这个类需要被Spring 管理。

示例代码:

@Configuration
public class AppConfig {
    @Bean
    public PaymentService paymentService() {
        return new NewClassB();
    }
}

@ComponentScan

用于扫描和注册组件(包括 @Component、@Service、@Controller、@Repository 等注解修饰的类)
通过使用 @ComponentScan 注解,Spring 将会在指定的包或类中扫描组件(在 Spring 应用程序中,组件通常是指 Spring 管理的对象),然后将其实例化、初始化并将其添加到 Spring 的应用程序上下文中,以便在整个应用程序中可以使用这些组件。
@ComponentScan的常用属性:
basePackages:指定要扫描的包,可以指定多个包;
basePackageClasses:指定要扫描的类,可以指定多个类;
excludeFilters:指要排除的组件,可以使用正则表达式、类型过滤器等方式进行排除;
需要注意的是,使用 @ComponentScan 注解需要在 Spring 配置类上添加该注解,如:

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    // ...
}

使用注解方式实现构造函数注入

先创建各层的类
IAnnotateDao接口

package com.wangwei.springioc.dao;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : IAnnotateDao
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 8:58]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 8:58]
 * @updateRemark : [描述说明本次修改内容]
 */
public interface IAnnotateDao {
    void addUser(String username, String password);
}

AnnotateUserDaoImpl类

package com.wangwei.springioc.dao.daoImpl;

import com.wangwei.springioc.dao.IAnnotateDao;
import org.springframework.stereotype.Repository;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : AnnotateUserDaoImpl
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 8:59]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 8:59]
 * @updateRemark : [描述说明本次修改内容]
 */
@Repository
public class AnnotateUserDaoImpl implements IAnnotateDao {
    @Override
    public void addUser(String username, String password) {
        System.out.println("IUserDaoImpl.addUser()"+username+password);
    }
}

IAnnotateManager接口

package com.wangwei.springioc.manager;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : IAnnotateManager
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 9:03]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 9:03]
 * @updateRemark : [描述说明本次修改内容]
 */
public interface IAnnotateManager {
    void addUser(String name ,String password);
}

AnnotateManagerImpl类
成员变量被声明为 final,这是为了避免在类的其他地方意外地修改它的引用,保证其只能在构造函数中被初始化,并且在对象创建后不会再被更改。

package com.wangwei.springioc.manager.managerImpl;

import com.wangwei.springioc.dao.IAnnotateDao;
import com.wangwei.springioc.manager.IAnnotateManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : AnnotateManagerImpl
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 9:03]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 9:03]
 * @updateRemark : [描述说明本次修改内容]
 */
@Service
public class AnnotateManagerImpl implements IAnnotateManager {

    //构造函数注入
    private final IAnnotateDao iAnnotateDao;
    @Autowired
    public AnnotateManagerImpl(IAnnotateDao iAnnotateDao) {
        this.iAnnotateDao = iAnnotateDao;
    }


    @Override
    public void addUser(String name, String password) {
        iAnnotateDao.addUser(name,password);
    }


}

AnnotateClient类
程序启动类

package com.wangwei.springioc.client;

import com.wangwei.springioc.manager.IAnnotateManager;
import com.wangwei.springioc.manager.managerImpl.AnnotateManagerImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : AnnotateClient
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 8:56]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 8:56]
 * @updateRemark : [描述说明本次修改内容]
 */
//使用@Configuration注解来告诉Spring这是一个配置类,并将其放入到ioc容器中
@Configuration
//@ComponentScan注解来指定要扫描的包路径,@ComponentScan注解会告诉Spring去哪里查找组件,它会扫描指定的包及其子包,查找使用了特定注解的类,并将它们注册为Spring的bean。
@ComponentScan(basePackages = "com.wangwei.springioc")
public class AnnotateClient {
    public static void main(String[] args) {
            //我们使用AnnotationConfigApplicationContext来加载配置类,使用MyAppApplication.class作为配置类,即告诉Spring使用MyAppApplication这个类中的注解来构建应用程序上下文
            ApplicationContext context = new AnnotationConfigApplicationContext(AnnotateClient.class);
            //使用context对象来获取我们的bean并进行依赖注入和使用。
            IAnnotateManager iAnnotateManager = context.getBean(AnnotateManagerImpl.class);
            iAnnotateManager.addUser("wangwei","123");
    }
}

运行结果

【Spring框架三】——Spirng IOC和DI的实现

使用注解方式实现Setter方式注入

AnnotateManagerImpl类

package com.wangwei.springioc.manager.managerImpl;

import com.wangwei.springioc.dao.IAnnotateDao;
import com.wangwei.springioc.manager.IAnnotateManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : AnnotateManagerImpl
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 9:03]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 9:03]
 * @updateRemark : [描述说明本次修改内容]
 */
@Service
public class AnnotateManagerImpl implements IAnnotateManager {
	//Setter方式进行注入
    private  IAnnotateDao iAnnotateDao;
    @Autowired
    public void setiAnnotateDao(IAnnotateDao iAnnotateDao) {
        this.iAnnotateDao = iAnnotateDao;
    }

    @Override
    public void addUser(String name, String password) {
        iAnnotateDao.addUser(name,password);
    }


}

运行效果

【Spring框架三】——Spirng IOC和DI的实现

使用注解方式实现字段方式注入

package com.wangwei.springioc.manager.managerImpl;

import com.wangwei.springioc.dao.IAnnotateDao;
import com.wangwei.springioc.manager.IAnnotateManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : AnnotateManagerImpl
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 9:03]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 9:03]
 * @updateRemark : [描述说明本次修改内容]
 */
@Service
public class AnnotateManagerImpl implements IAnnotateManager {


    @Autowired
    private IAnnotateDao iAnnotateDao;

    @Override
    public void addUser(String name, String password) {
        iAnnotateDao.addUser(name,password);
    }


}

运行效果

【Spring框架三】——Spirng IOC和DI的实现

使用注解方式实现通过方法注入

AnnotateManagerImpl类

package com.wangwei.springioc.manager.managerImpl;

import com.wangwei.springioc.dao.IAnnotateDao;
import com.wangwei.springioc.manager.IAnnotateManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : AnnotateManagerImpl
 * @description : [描述说明该类的功能]
 * @createTime : [2023/5/10 9:03]
 * @updateUser : [WangWei]
 * @updateTime : [2023/5/10 9:03]
 * @updateRemark : [描述说明本次修改内容]
 */
@Service
public class AnnotateManagerImpl implements IAnnotateManager {

    private IAnnotateDao iAnnotateDao;
    @Autowired
    public void anotateIAnnotateDao(IAnnotateDao iAnnotateDao){
        this.iAnnotateDao=iAnnotateDao;
    }

    @Override
    public void addUser(String name, String password) {
        iAnnotateDao.addUser(name,password);
    }


}

运行结果

【Spring框架三】——Spirng IOC和DI的实现

每种注入方式的优缺点

构造函数注入的优缺点

优点:

  1. 对象的完整性:通过构造函数注入,可以保证在创建对象时所需要的所有依赖都被满足,从而确保对象的完整性。
  2. 对象不可变:通过构造函数注入,可以将依赖关系作为对象的不可变属性,防止意外修改对象依赖。

缺点:

  1. 冗长:需要编写额外的构造函数,增加代码量。
  2. 限制:在对象创建后无法更改依赖关系。

Setter方法注入的优缺点

优点:

  1. 灵活:可以在任何时候更改依赖关系,不受对象创建时依赖关系的限制。
  2. 可选性:某些依赖关系不是必需的,可以使用setter方法注入来提供可选依赖项。

缺点:

  1. 对象可变性:setter方法注入会使对象变得可变,因为依赖关系可以随时更改。
  2. 不够显式:相对于构造函数注入,setter方法注入可能导致依赖关系不够显式和清晰。

字段注入的优缺点

优点:

  1. 简单方便:字段注入是一种简单方便的依赖注入方式,无需编写额外的代码。
  2. 可选性:某些依赖关系不是必需的,可以使用字段注入来提供可选依赖项。

缺点:

  1. 对象可变性:字段注入会使对象变得可变,因为依赖关系可以随时更改。
  2. 不够显式:相对于构造函数注入,字段注入可能导致依赖关系不够显式和清晰。

方法注入的优缺点

优点:

  1. 灵活性:方法注入可以在任何时候更改依赖关系,不受对象创建时依赖关系的限制。

缺点:

  1. 冗长:需要编写额外的方法,增加代码量。

四、总结

  1. XML和注解实现的IOC和DI是两种不同的方式,它们都可以用于管理应用程序中的组件和依赖关系。
  2. 在实际开发中,通常使用注解来代替XML,这是因为注解更加方便、简洁和易于维护,而且可以让开发者更加专注于业务逻辑的实现。
  3. 相比之下,XML需要编写更多的代码,需要手动配置依赖关系,维护起来相对麻烦一些。不过,使用XML的好处是可以更加灵活地配置和管理应用程序,可以在不修改代码的情况下改变应用程序的行为。

总的来说,使用注解可以使开发更加高效,使用XML可以使配置更加灵活,具体使用哪种方式取决于项目的需求和开发者的偏好。文章来源地址https://www.toymoban.com/news/detail-445988.html

到了这里,关于【Spring框架三】——Spirng IOC和DI的实现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Spring教程11】Spring框架实战:IOC/DI注解开发管理第三方bean的全面深入详解

    欢迎大家回到《 Java教程之Spring30天快速入门》,本教程所有示例均基于Maven实现,如果您对Maven还很陌生,请移步本人的博文《 如何在windows11下安装Maven并配置以及 IDEA配置Maven环境》,本文的上一篇为《 纯注解开发模式下的依赖注入和读取properties配置文件》 前面定义bean的时

    2024年02月04日
    浏览(59)
  • 【Spring进阶系列丨第二篇】Spring中的两大核心技术IoC(控制反转)与DI(依赖注入)

    我们都知道Spring 框架主要的优势是在 简化开发 和 框架整合 上,至于如何实现就是我们要学习Spring 框架的主要内容,今天我们就来一起学习Spring中的两大核心技术IoC(控制反转)与DI(依赖注入)。 以经典的三层架构MVC作为案例,以前我们都是这么干的,看如下代码: 按照

    2024年02月05日
    浏览(66)
  • 【Spring教程十】Spring框架实战:全面深入详解IOC/DI之--纯注解开发模式下的依赖注入&&注解读取properties配置文件

    欢迎大家回到《 Java教程之Spring30天快速入门》,本教程所有示例均基于Maven实现,如果您对Maven还很陌生,请移步本人的博文《 如何在windows11下安装Maven并配置以及 IDEA配置Maven环境》,本文的上一篇为《 全面深入详解IOC/DI注解开发》 Spring为了使用注解简化开发,并没有提供

    2024年02月04日
    浏览(54)
  • Spring6-IoC(Inversion of Control)控制反转和DI(Dependency Injection)依赖注入,手动实现IOC

    Java 反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;这种动态获取信息以及动态调用对象方法的功能称为 Java 语言的 反射机制 。简单来说, 反射机制指的是程序在运行时能够获取自身

    2024年02月09日
    浏览(59)
  • Spring IoC容器、IoC与DI

    目录 Spring是什么? 理解容器  什么是IoC(Inversion of Control) 传统的new创建对象的方式中类与类的耦合程度很大。  IoC的优势:  Spring IoC容器最核心的功能  什么是DI (Dependency Injection) IoC和DI的区别  Spring是指Spring Framework(Spring框架),它是开源的框架,有着很庞大的社区,通过

    2023年04月21日
    浏览(95)
  • Spring IoC&DI

    前面我们大概知道了什么是 Spring,以及 Spring 家族中 Spring Boot 和 Spring MVC的开发,但是 Spring 到底是什么呢? 前面我为大家简单介绍了什么是 Spring 【Spring】什么是Spring,不过前面的介绍较为简单,要想知道Spring 的原理,这些知识不不足以帮助我们了解 Spring 的,所以这篇文

    2024年02月04日
    浏览(44)
  • 【学习】Spring IoC&DI

    🎥 个人主页:Dikz12 📕格言:吾愚多不敏,而愿加学 欢迎大家👍点赞✍评论⭐收藏 目录 Spring 是什么? 什么是 IoC容器? 传统开发模式  loC开发模式 IoC的优势  IoC 的使用 Bean的存储   方法注解  DI  属性注入  构造⽅法注⼊  Setter 注⼊ @Autowired存在的问题  解决方案:

    2024年04月15日
    浏览(48)
  • Spring IoC&DI(2)

    通过上面的案例, 我们已经知道了IoC和DI的基本操作, 接下来我们来系统地学习Spring IoC和DI的操作. 前面我们提到的IoC控制反转, 就是将对象的控制权交给Spring的IoC容器, 由IoC容器创建及管理对象.  ( 也就是Bean的存储 ). 我们之前只讲到了@Component注解来使得对象交给IoC容器管理

    2024年04月10日
    浏览(46)
  • Spring5系列学习文章分享---第一篇(概述+特点+IOC原理+IOC并操作之bean的XML管理操作)

    开篇: 欢迎来到 Spring 5 学习系列!在这个系列中,我们将深入研究 Spring 框架的最新版本,揭示其在现代Java开发中的精髓。无论你是初学者还是有经验的开发者,本系列都旨在为你提供深刻的理解和实用的知识,让你在构建强大、可维护和高效的应用程序方面更上一层楼。

    2024年01月22日
    浏览(69)
  • 什么是IoC?什么是Spring IoC?什么是DI?

    首先说明 IoC 是一种思想,IoC的全称是Inversion of Control,翻译成中文叫做 “控制反转” 用人话来说,IoC的思想就是将一个对象对另一个对象的控制权交出去(不必关心交给谁),从而让对象之间的依赖关系降低,降低代码之间耦合程度。 我们可以写一个简单的代码来举个例子

    2024年02月14日
    浏览(49)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包