Loading [MathJax]/jax/output/CommonHTML/config.js
前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >【Spring】Spring IOC&DI:架构旋律中的“依赖交响”与“控制华章”

【Spring】Spring IOC&DI:架构旋律中的“依赖交响”与“控制华章”

作者头像
用户11288949
发布于 2025-01-17 05:57:21
发布于 2025-01-17 05:57:21
8200
代码可运行
举报
文章被收录于专栏:学习学习
运行总次数:0
代码可运行

📚️1.IOC&DI入门

1.1什么是Spring

通过前⾯的学习, 我们知道了Spring是⼀个开源框架, 他让我们的开发更加简单. 他⽀持⼴泛的应⽤场景, 有着活跃⽽庞⼤的社区, 这也是Spring能够⻓久不衰的原因.但是这个概念相对来说, 还是⽐较抽象.

我们⽤⼀句更具体的话来概括Spring, 那就是: Spring 是包含了众多⼯具⽅法的 IoC 容器

1.2什么是IOC

在前⾯讲到, 在类上⾯添加 @RestController 和@Controller 注解, 就是把这个对象交给Spring管理, Spring 框架启动时就会加载该类. 把对象交给Spring管理, 就是IoC思想

IOC:: Inversion of Control (控制反转), 也就是说 Spring 是⼀个"控制反转"的容器

控制反转:

当需要某个对象时, 传统开发模式中需要⾃⼰通过 new 创建对象, 现在不需要再进⾏创建, 把创建对象的任务交给容器, 程序中只需要依赖注⼊ (Dependency Injection,DI)就可以了

总结:

IOC就是一个创建任务对象的容器;

DI就是我们后面需要注入的依赖

1.3IOC的介绍
1.3.1传统的开发过程

假如我们在实现创建一个车子的时候,我们知道他是依赖于车身,轮胎,底盘...那么就有如下的依赖的情况:

那么我们在程序实现的时候就是如下所示的:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class Car {
    //车依赖于车身
    private Framwork framwork;
    public Car(int size) {
        framwork = new Framwork(size);
        System.out.println("Car init....");
    }
    public void run(){
        System.out.println("car run....");
    }
}

解释:

这就是车在制造的时候,依赖车身,所以就会创建一个车身的对象,那但是此时车身依赖由于底盘,就会在车身类进行对象的构造;

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class Framwork {
    private Bottem bottem;
    public Framwork(int size){
        bottem=new Bottem(size);
        System.out.println("framwork init....");
    }
}

解释:

此时我们就会发现,车身的制造依赖于底盘,那么就要创建底盘的对象,那么此时一直到最后一环指定就是轮胎;

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class Tire {
    private int size;
    public Tire(int size){
        this.size=size;
        System.out.println("tire init...");
    }
}

解释:

如果这里我们这里,最后一环的情况下,假如我们要规定颜色和轮胎的尺寸大小,此时就会发现一个问题;

以上程序的问题是:当最底层代码改动之后,整个调⽤链上的所有代码都需要修改.程序的耦合度⾮常⾼(修改⼀处代码, 影响其他处的代码修改)

1.3.2IOC程序开发

此时我们就可以使用IOC程序开发的思想进行改进,将整个对象进行统一管理,然后就可以大大降低耦合性;

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public static void main(String[] args) {
        Tire tire = new Tire(20);
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.run();
    }
static class Car {
    private Framework framework;
    public Car(Framework framework) {
        this.framework = framework;
        System.out.println("Car init....");
    }
    public void run() {
        System.out.println("Car run...");
    }
}

解释:

这里小编只展示了一小部分,其余的写法基本是一致的;代码经过以上调整,⽆论底层类如何变化,整个调⽤链是不⽤做任何改变的,这样就完成了代码之间的解耦,从⽽实现了更加灵活、通⽤的程序设计了

1.3.3IOC的优势

在传统的代码中对象创建顺序是:Car -> Framework -> Bottom -> Tire 改进之后解耦的代码的对象创建顺序是:Tire -> Bottom -> Framework -> Car

改进之后的控制权发⽣的反转,不再是使⽤⽅对象创建并控制依赖对象了,⽽是把依赖对象注⼊将当前对象中,依赖对象的控制权不再由当前类控制了

那么此时就可以看做是如下所示的情况:

此时优点就是如下:

1. 资源集中管理: IoC容器会帮我们管理⼀些资源(对象等), 我们需要使⽤时, 只需要从IoC容器中去取就可以了 2. 我们在创建实例的时候不需要了解其中的细节, 降低了使⽤资源双⽅的依赖程度, 也就是耦合度.

1.4DI的介绍

DI: Dependency Injection(依赖注⼊)

容器在运⾏期间, 动态的为应⽤程序提供运⾏时所依赖的资源,称之为依赖注⼊。程序运⾏时需要某个资源,此时容器就为其提供这个资源.

就是一个依赖的注入;

IoC 是⼀种思想,也是"⽬标", ⽽思想只是⼀种指导原则,最终还是要有可⾏的落地⽅案,⽽ DI 就属于具体的实现。所以也可以说, DI 是IoC的⼀种实现

📚️2.IOC&DI的使用

既然 Spring 是⼀个 IoC(控制反转)容器,作为容器, 那么它就具备两个最基础的功能: • 存 • 取 Spring 容器 管理的主要是对象, 这些对象, 我们称之为"Bean". 我们把这些对象交由Spring管理, 由 Spring来负责对象的创建和销毁. 我们程序只需要告诉Spring, 哪些需要存, 以及如何从Spring中取出对象

此时我们就会使用@component来进行管理Bean,使用@Autowired来进行依赖的注入,那么代码如下:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Component
public class BookDao {
    public List<BookInfo> mockData(){
        List<BookInfo> books=new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            BookInfo book = new BookInfo();
            book.setId(i);
            book.setBookName("书籍" + i);
            book.setAuthor("作者" + i);
            book.setCount(i * 5 + 3);
            book.setPrice(new BigDecimal(new Random().nextInt(100)));
            book.setPublish("出版社" + i);
            book.setStatus(1);
            books.add(book);
        }
        return books;
    }
}

我们将这个数据对象交给spring管理,就是加上注解@Component;

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Component //交给spring进行管理
public class BookService {
    @Autowired
    private BookDao bookDao;
    public List<BookInfo> getBookList(){

        List<BookInfo> books=bookDao.mockData();
        for (BookInfo book : books) {
            if (book.getStatus() == 1) {
                book.setStatusCN("可借阅");
            } else {
                book.setStatusCN("不可借阅");
            }
        }
        return books;
    }
}

这里就是将逻辑处理的对象交给spring管理,由于这里要使用数据,所以要引入依赖,这个依赖就可以将数据的对象传过来;

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@RequestMapping("/book")
@RestController
public class BookController {
    @Autowired
    private BookService bookService;
    @RequestMapping("/getList")
    public List<BookInfo> getList() {
        //获取数据
        //交给spring注入依赖

        List<BookInfo> books = bookService.getBookList();
        //处理⻚⾯展⽰
        return books;
    }
}

最后在controller表现层操作时,将引入逻辑处理层的对象,此时就可以spring管理的对象拿出来,就是依赖的引入;

📚️3.IOC详解

通过上⾯的案例, 我们已经知道了Spring IoC 和DI的基本操作, 接下来我们来系统的学习Spring IoC和DI的操作.前⾯我们提到IoC控制反转,就是将对象的控制权交给Spring的IOC容器,由IOC容器创建及管理对象。也就是bean的存储

3.1Bean的存储

在之前的⼊⻔案例中,要把某个对象交给IOC容器管理,需要在类上添加⼀个注解:@Component⽽Spring框架为了更好的服务web应⽤程序, 提供了更丰富的注解

1. 类注解:@Controller、@Service、@Repository、@Component、@Configuration. 2. ⽅法注解:@Bean.

那么下面小编来示范一下;

3.2类注解实现

这里小编就只使用controller进行操作,通过controller注解来进行存储Bean;

代码如下所示:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Controller
public class UserController {
   public void userController(){
        System.out.println("userController start...");
    }
}

此时我们就将这里的对象给spring进行管理了;

如何从Spring容器中获取对象:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@SpringBootApplication
public class SpringIocDemoApplication {
     public static void main(String[] args) {
     //获取Spring上下⽂对象
     ApplicationContext context = 
     SpringApplication.run(SpringIocDemoApplication.class, args);
     //从Spring上下⽂中获取对象
     UserController userController = context.getBean(UserController.class);
     //使⽤对象
     userController.sayHi();
     }
}

解释:

ApplicationContext 翻译过来就是: Spring 上下⽂因为对象都交给 Spring 管理了,所以获取对象要从 Spring 中获取,那么就得先得到 Spring 的上下⽂

这个上下⽂, 就是指当前的运⾏环境, 也可以看作是⼀个容器, 容器⾥存了很多内容, 这些内容是当前运⾏的环境

可以看到此时的对象就是拿到了的,即输出了usercontroller start这句话~~~

然后我们将这个controller进行删除试试:

此时就是出现异常了:就是这不到这个类型对象的存在,所以就抛出了异常;

3.3获取Bean的其他方式

上述就是通过类型来进行获取Bean的;

上述代码是根据类型来查找对象, 如果Spring容器中, 同⼀个类型存在多个bean的话, 怎么来获取呢?

ApplicationContext 也提供了其他获取bean的⽅式, ApplicationContext 获取bean对象的功能, 是⽗类BeanFactory提供的功能.

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public interface BeanFactory {
    String FACTORY_BEAN_PREFIX = "&";

    Object getBean(String name) throws BeansException;

    <T> T getBean(String name, Class<T> requiredType) throws BeansException;

    Object getBean(String name, Object... args) throws BeansException;

    <T> T getBean(Class<T> requiredType) throws BeansException;

    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

可以看到这里可以根据类型和名字进行对象的获取,那么Bean的名字是啥?

Spring bean是Spring框架在运⾏时管理的对象, Spring会给管理的对象起⼀个名字,给每个对象起⼀个名字, 根据Bean的名称(BeanId)就可以获取到对应的对象.

Bean的命名

官方的文档就是如下所示:

具体的内容就是:

命名约定使⽤Java标准约定作为实例字段名. 也就是说,bean名称以⼩写字⺟开头,然后使⽤驼峰式⼤⼩写 ;

类名: UserController, Bean的名称为: userController 类名: AccountManager, Bean的名称为: accountManager

当然也有特殊的情况,前面两个单词都是大写:

类名: UController, Bean的名称为: UController 类名: AManager, Bean的名称为: AManager

还有就是三个大写字母,的Bean的命名就是:

类名:UserControllerDI,Bean的名称;usercontrollerDI

此时我们使用三种获取Bean的方式进行获取Bean对象:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
  public static void main(String[] args) {
        ApplicationContext context= SpringApplication.run(SpringIocApplication.class, args);
        UserController bean = context.getBean(UserController.class);
        bean.userController();

        UserController bean1 = (UserController) context.getBean("userController");
        bean1.userController();

        UserController bean2 = context.getBean("userController",UserController.class);
        bean2.userController();
}

解释:

此时我们这里第一种获取Bean的方式就是通过类型进行获取,然后第二种就是通过bean的名称进行获取,第三种就是前面两种的合并的方式;

此时我们进入运行状态:

ApplicationContext与BeanFactory

继承关系和功能⽅⾯来说:Spring 容器有两个顶级的接⼝:BeanFactory 和ApplicationContext。其中 BeanFactory 提供了基础的访问容器的能⼒,⽽ApplicationContext 属于 BeanFactory 的⼦类,它除了继承了 BeanFactory 的所有功能之外,它还拥有独特的特性,还添加了对国际化⽀持、资源访问⽀持、以及事件传播等⽅⾯的⽀持 从性能⽅⾯来说:ApplicationContext 是⼀次性加载并初始化所有的 Bean 对象,⽽ BeanFactory 是需要那个才去加载那个,因此更加轻量. (空间换时间

这里小编就不再演示其他几个了,基本代码和思想都是一样的~~~

3.4多种注解含义

• @Controller:控制层, 接收请求, 对请求进⾏处理, 并进⾏响应. • @Servie:业务逻辑层, 处理具体的业务逻辑. • @Repository:数据访问层,也称为持久层. 负责数据访问操作 • @Configuration:配置层. 处理项⽬中的⼀些配置信息

类注解之间的关系查看 @Controller / @Service / @Repository / @Configuration 等注解的源码发 现:

这些注解⾥⾯都有⼀个注解 @Component ,说明它们本⾝就是属于 @Component 的"⼦类". @Component 是⼀个元注解,这些其他的注解就是@Component的衍生类;

3.5方法注解Bean

1.使⽤外部包⾥的类, 没办法添加类注解 2. ⼀个类, 需要多个对象, ⽐如多个数据源

3.5.1方法注解要配合注解类

代码如下所示:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Configuration
public class BeanConfig {
    @Bean
    public UserInfo userInfo(){
        return new UserInfo("zhangsan");
    }
}

那么此时就将这个对象进行了管理了;

那么我们就可以拿到这个对象:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
UserInfo bean = context.getBean("UserInfo.class");
        System.out.println(bean);
3.5.2存在多个对象

代码如下:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Configuration
public class BeanConfig {
    @Bean
    public UserInfo user1(){
        return new UserInfo("zhangsan");
    }
    //@Primary
    @Bean
    public UserInfo user2(){
        return new UserInfo("lisi");
    }
}

那么此时我们使用类型进行获取时候;

那么此时我们就要通过bean的名称来进行获取了;

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
User user1 = (User) context.getBean("user1");
 User user2 = (User) context.getBean("user2")

📚️4.DI详解

依赖注⼊是⼀个过程,是指IoC容器在创建Bean时, 去提供运⾏时所依赖的资源,⽽资源指的就是对象.在上⾯程序案例中,我们使⽤了 @Autowired 这个注解,完成了依赖注⼊的操作

1. 属性注⼊(Field Injection) 2. 构造⽅法注⼊(Constructor Injection) 3. Setter 注⼊(Setter Injection)

4.1属性的注入

代码如下:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Controller
public class UsercontrollerDI {
    @Autowired
    private  UserServiceDI userServicedi;
    //private final UserServiceDI userServiceDI=new UserServiceDI();
    public void start(){
        userServicedi.start();
    }

}

这里就是通过属性的注入的方式进行依赖的注入;

此时我们进行对象的获取和打印:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
   UsercontrollerDI bean3 = context.getBean(UsercontrollerDI.class);
        bean3.start();

去掉@Autowired , 再运⾏⼀下程序看看结果:

就是说明了这里由于没有注入依赖,那么就直接为空了(这个对象)

4.2构造方法注入

代码如下所示:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Controller
public class UserControllerDI2 {
    private UserServiceDI userServiceDI;
    public UserControllerDI2(){

    }
    @Autowired
    public UserControllerDI2(UserServiceDI userServiceDI){
        this.userServiceDI=userServiceDI;
    }

    public void start(){
        userServiceDI.start();
    }
}

解释:

这就是通过构造方法来进行操作的,当然这里有点问题就是当存在两个构造方法的时候,默认就是无参的构造方法;

只有一个构造方法的时候,默认是使用这一个 若存在两个构造方法,此时就要指定使用那个构造方法

4.3setter方式注入

这里就和get与set方式基本一致了:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Controller
public class UserSet {
    private UserServiceDI userServiceDI;

    @Autowired
    public void setUserServiceDI(UserServiceDI userServiceDI) {
        this.userServiceDI = userServiceDI;
    }
    public void start(){
        userServiceDI.start();
    }
}

这里小编就不在过多的解释了;

4.4几种方式的优缺

属性注入

◦ 优点: 简洁,使⽤⽅便; ◦ 缺点: ▪ 只能⽤于 IoC 容器,如果是⾮ IoC 容器不可⽤,并且只有在使⽤的时候才会出现 NPE(空指 针异常) ▪ 不能注⼊⼀个Final修饰的属性

构造函数注入

优点: ▪ 可以注⼊final修饰的属性 ▪ 注⼊的对象不会被修改 ▪ 依赖对象在使⽤前⼀定会被完全初始化,因为依赖是在类的构造⽅法中执⾏的,⽽构造⽅法 是在类加载阶段就会执⾏的⽅法. ▪ 通⽤性好, 构造⽅法是JDK⽀持的, 所以更换任何框架,他都是适⽤的 ◦ 缺点: ▪ 注⼊多个对象时, 代码会⽐较繁琐

setter方式注入

优点: ⽅便在类实例之后, 重新对该对象进⾏配置或者注⼊ ◦ 缺点: ▪ 不能注⼊⼀个Final修饰的属性 ▪ 注⼊对象可能会被改变, 因为setter⽅法可能会被多次调⽤, 就有被修改的⻛险

4.5@Autowired的缺点

当出现多个同种类型的对象的时候:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class BeanConfig {
    @Bean
    public UserInfo userInfo(){
        return new UserInfo("zhangsan");
    }
    //@Primary
    @Bean
    public UserInfo userInfo1(){
        return new UserInfo("lisi");
    }
}

此时我们进行注入,就会出现如下的情况:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Autowired
    private UserInfo user;
    public void start(){
        System.out.println(user);
    }

直接出错;

很明显就是分不清楚,那个是要注入的Bean;

那么就有下面几种方法;

4.5.1使用@Primary

代码如下:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Bean
    public UserInfo userInfo(){
        return new UserInfo("zhangsan");
    }
    @Primary
    @Bean
    public UserInfo userInfo1(){
        return new UserInfo("lisi");
    }

此时我们默认这个对象;

4.5.2使用@Qualifier

注意这里要和autowired进行搭配使用

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
    @Qualifier("userInfo1")
    @Autowired
    private UserInfo user;

这里就要指定那个;

4.5.3使用@Resource

这里和上面一样,只不过不用搭配@Autowired了;

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
  @Sesource("userInfo1")
    private UserInfo user;

•@Autowird 与 @Resource的区别 • @Autowired 是spring框架提供的注解,⽽@Resource是JDK提供的注解 • @Autowired 默认是按照类型注⼊,⽽@Resource是按照名称注⼊. 相⽐于 @Autowired 来说,@Resource ⽀持更多的参数设置,例如 name 设置,根据名称获取 Bean.

📚️5.总结

本期小编主要讲解了关于Spring IOC和DI的详细介绍,从入门讲解概念到实际的应用,都有涉及,当然其中还涉及比较重要的面试题哦~~~

🌅🌅🌅~~~~最后希望与诸君共勉,共同进步!!!

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2025-01-17,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
暂无评论
推荐阅读
编辑精选文章
换一批
《JavaEE进阶》----11.<SpringIOC&DI【Spring容器+IOC详解+DI介绍】>
1.资源集中管理:IOC容器会帮我们管理一些资源(对象等)。我们使用时,从IOC容器取就可以了。
用户11288958
2024/09/24
1390
《JavaEE进阶》----11.<SpringIOC&DI【Spring容器+IOC详解+DI介绍】>
【Spring】IoC和DI,控制反转,Bean对象的获取方式
通过前面的学习,我们了解到Spring是一个含有多种工具和方法的IoC容器,那么什么是容器,神什么是IoC容器呢?
三三是该溜子
2024/12/30
820
【Spring】IoC和DI,控制反转,Bean对象的获取方式
《JavaEE进阶》----12.<SpringIOC&DI【扫描路径+DI详解+经典面试题+总结】>
虽然我们没有告诉Spring扫描路径是什么,但是有一些注解已经告诉Spring扫描路径是什么了
用户11288958
2024/09/24
780
《JavaEE进阶》----12.<SpringIOC&DI【扫描路径+DI详解+经典面试题+总结】>
【JavaEE进阶】Spring 更简单的读取和存储对象
配置扫描路径是使用注解之前的前置工作,是非常重要的,是必须的操作项.只有被配置的包下的所有类,添加了注解才能被正确的识别并保存到 Spring 中.
xxxflower
2023/10/16
1990
【JavaEE进阶】Spring 更简单的读取和存储对象
【Spring】——Spring的创建与使用
构建⼀辆车(Car Class),然而车需要依赖车身(FrameWork Class),而车身需要依赖底盘(Bottom Class),而底盘需要依赖轮胎(Tire Class),最终程序的实现代码如下
终有救赎
2023/10/16
1970
【Spring】——Spring的创建与使用
Spring学习笔记(2)一DI依赖注入和Spring Bean配置、注解原理、动态注入
Spring容器是Spring框架的核心。容器将创建对象,它们连接在一起,配置它们,并从创建到销毁管理他们的整个生命周期。在Spring容器使用依赖注入(DI)来管理组成应用程序的组件。这些对象被称为Spring Beans。 IOC(Inversion of Control):传统的方法,当某个java对象A需要调用对象B时,是由调用者(对象A)通过new关键字来创建对象B的,而在Spring中,则是由spring完成创建的,所以“控制反转”了。Spring通过一种称作控制反转(IoC)的技术促进了低耦合。当应用了IoC,一个对象依赖的其它对象会通过被动的方式传递进来,而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI(JNDI是 Java 命名与目录接口Java Naming and Directory Interface))相反——不是对象从容器中查找依赖,而是容器在对象初始化时不等对象请求就主动将依赖传递给它。 DI(Dependency Injection)—IOC的另一种表述方式:即组件以一些预先定义好的方式(例如: setter方法)接受来自如容器的资源注入.相对于 IOC而言,这种表述更直接。
黄规速
2022/04/14
8610
Spring学习笔记(2)一DI依赖注入和Spring Bean配置、注解原理、动态注入
JAVAEE一>Spring IoC和DI详解
把对象交给Spring管理,需要添加一些注解这里共有两类注解可以使用: 1.类注解:@Controller,@Service,@Repository,@Component,@Configuration
用户11305962
2025/02/24
960
JAVAEE一>Spring IoC和DI详解
Spring-依赖注入IOC
IoC 不是什么技术,而是一种设计思想。在 Java 开发中,IoC 意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。如何理解 Ioc 呢?理解 Ioc 的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了”,那我们来深入分析一下:
SerMs
2022/05/05
4190
Spring学习(1)——IoC部分
Spring框架是一个开源的、松耦合的、分层的、可配置的一站式企业级 Java 开发框架,它的核心是IoC(控制反转)和AOP(面向切面编程)。在Spring中,构成应用程序主干并由 Spring IoC 容器管理的对象称为bean。bean 是由IoC容器实例化,组装和以其他方式管理的对象。
玛卡bug卡
2022/09/20
5400
Spring学习(1)——IoC部分
Spring IOC
实际开发中,我们如果在对象 A 内部去创建、修改或者注销另一个对象 B,这会导致对象之间非常复杂的依赖关系,不利于代码的维护更新。
Qwe7
2022/08/12
4560
【Spring】DI依赖注入的三种方式
上一篇文章介绍了@Bean注解的使用和扫描路径的配置,本文主要介绍如何将交给Spring管理的Bean对象怎样注入,也就是使用Bean对象
三三是该溜子
2025/01/13
2740
【Spring】DI依赖注入的三种方式
Spring之IOC容器
spring core提供了IOC,DI,Bean配置装载创建的核心实现 核心概念: Beans、BeanFactory、BeanDefinitions、ApplicationContext
冬天vs不冷
2025/01/21
2380
Spring之IOC容器
聊一聊 Spring 6 容器 IOC
IoC 是 Inversion of Control 的简写,译为“控制反转”,它不是一门技术,而是一种设计思想,是一个重要的面向对象编程法则,能够指导我们如何设计出松耦合、更优良的程序。
小熊学Java
2023/09/06
9900
聊一聊 Spring 6 容器 IOC
Spring核心之控制反转IOC
第一个值默认值,singleton,表示单实例对象 第二个值prototype,表示是多实例对象
用户9615083
2022/12/25
5340
Spring核心之控制反转IOC
【Spring】核心部分之IOC:通过列举代码例子,从底层刨析,深入源码,轻轻松松理解Spring的核心IOC,IOC有这一篇足以
第一步 把 service 和 dao 对象创建,在 service 和 dao 类添加创建对象注解
小尘要自信
2023/10/10
6460
【Spring】核心部分之IOC:通过列举代码例子,从底层刨析,深入源码,轻轻松松理解Spring的核心IOC,IOC有这一篇足以
Spring IoC容器与Bean管理
从本节开始,我将要学习作为java高级阶段最最最最重要的一个框架体系,名为Spring。Spring是整个Java生态中最重要的一环。因为我也是初学,所以我的概括也不一定全面和精炼。写这一章只是为自己以后复习。
害恶细君
2022/11/22
7370
Spring IoC容器与Bean管理
Spring-IOC
今天开始学习我自己总结的 Java-学习路线 中的《Spring-IOC》,小简从 0 开始学 Java 知识,并不定期更新所学笔记,期待一年后的蜕变吧
小简
2023/01/04
5230
Spring-IOC
第一章 Spring 的控制反转/依赖注入
spring:春天 IOC:将创建对象的权力交给 spring 核心容器去控制。工厂模式
张哥编程
2024/12/07
890
Spring IOC基于XML管理Bean(二)
注意:在使用 <context:property-placeholder> 元素加载外包配置文件功能前,首先需要在 XML 配置的一级标签 <beans> 中添加 context 相关的约束。
鱼找水需要时间
2023/06/11
4990
Spring IOC基于XML管理Bean(二)
JavaEE框架_Spring6容器IOC(4万字笔记带你拿捏SpringIOC容器)
IoC 是 Inversion of Control 的简写,译为“控制反转”,它不是一门技术,而是一种设计思想,是一个重要的面向对象编程法则,能够指导我们如何设计出松耦合、更优良的程序。
小小程序员
2023/03/12
6790
JavaEE框架_Spring6容器IOC(4万字笔记带你拿捏SpringIOC容器)
相关推荐
《JavaEE进阶》----11.<SpringIOC&DI【Spring容器+IOC详解+DI介绍】>
更多 >
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档
本文部分代码块支持一键运行,欢迎体验
本文部分代码块支持一键运行,欢迎体验