【springboot】3.1ioc容器简介

最新推荐文章于 2024-04-26 17:40:25 发布
最新推荐文章于 2024-04-26 17:40:25 发布
阅读量278 收藏 1
点赞数 1
文章标签： spring boot ioc java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44420980/article/details/108708774
版权

inversion of control
初学Java可能使用new创建对象。但spring通过描述来创建对象。
spring boot不建议使用xml，而是通过注解描述生成对象。

spring中每一个需要管理的对象称为bean，spring管理这些bean的容器，称为ioc容器。
ioc容器需要具备2个基本功能：
1.通过描述发布和获取bean
2.通过描述完成bean直接的依赖关系

在spring中，所有的ioc容器都要实现顶级容器接口BeanFactory
接口中有多个getBean方法，意味着允许我们按照类型或者名称获取bean
isSingleton判断bean是否为单例
ioc容器中默认bean都为单例，即getBean返回同一个对象

与之相反的是isPrototype方法，如果返回true。那么getBean会创建一个新的Bean返回。
beanFactory拥有子接口ApplicationContext

简单体验一下applicationContext
在这里插入图片描述

package com.springboot.chapter3.pojo;

/**
 * @author KNOE
 * @date 2020-09-21 12:15
 */
public class User {
    private Long id;
    private String userName;
    private String note;
    // alt+insert

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }
}


package com.springboot.chapter3.config;

import com.springboot.chapter3.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author KNOE
 * @date 2020-09-21 12:20
 */
@Configuration
public class AppConfig {
    @Bean(name = "user")
    public User initUser() {
        User user = new User();
        user.setId(1L);
        user.setUserName("user_name_1");
        user.setNote("note_1");
        return user;
    }
}

@Configuration表示这个一个配置文件，spring会根据他来生成ioc容器装配bean
@Bean表示讲该方法返回的pojo装配到ioc容器中。其属性name定义bean的名称，
如果不写，方法名就是bean的名称

package com.springboot.chapter3.config;

import com.springboot.chapter3.pojo.User;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;


/**
 * @author KNOE
 * @date 2020-09-21 12:23
 */
public class IoCTest {
    private static Logger log = LogManager.getLogger(IoCTest.class);
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx
                = new AnnotationConfigApplicationContext(AppConfig.class);
        User user = ctx.getBean(User.class);
        log.info(user.getId());
    }
}

将配置文件appConfig传递给一个构造方法。于是可以用getBean方法获取pojo

注意log4j2.13的全新写法
就像这样参考

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

private static Logger logger = LogManager.getLogger(myClass.class);

在这里插入图片描述
可以看到bean的属性能够输出出来

通过component装配bean

把user改成这样

package com.springboot.chapter3.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * @author KNOE
 * @date 2020-09-21 12:15
 */
@Component("user")
public class User {
    @Value("1")
    private Long id;
    @Value("user_name_1")
    private String userName;
    @Value("note_1")
    private String note;
    // alt+insert

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }
}

component表面要被ioc容器扫描装配。如果不配置name
会自动把类名小写作为bean名称
@Value指定具体的值，注入对应属性

改造appConfig

package com.springboot.chapter3.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @author KNOE
 * @date 2020-09-21 12:20
 */
@Configuration
@ComponentScan("com.springboot.chapter3.*")
public class AppConfig {
}

@ComponentScan会让类扫描，这样就能删掉创建对象方法
但是默认只能扫描本包和子包
需要特别定义扫描的包

@ComponentScan(value = "com.springboot.chapter3.*",
    excludeFilters = {@ComponentScan.Filter(classes = {myClass.class})})

还可以这样写，排除不想注入的类

自定义第三方bean

但是这不代表bean没用了。经常需要引入第三方的包，希望把其中的类也放到ioc容器中。这时@Bean注解就有用了。因为componentScan顶多扫描项目里的类，第三方的类都不在项目文件里，也没法扫描，也加不了@Componenttree

package com.springboot.chapter3.pojo;

import org.springframework.stereotype.Service;

/**
 * @author KNOE
 * @date 2020-09-21 16:11
 */
@Service
public class UserService {
    public void print(User user) {
        System.out.println("user = " + user.getId());
    }
}

新写一个service类

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>springboot</groupId>
    <artifactId>chapter3</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>chapter3</name>
    <description>Chapter3 project for Spring Boot</description>

    <properties>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

在xml里加入sql的依赖

通过bean引入第三方bean，同时排除service类
使用dbpc生成数据源

package com.springboot.chapter3.config;

import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Service;

import javax.sql.DataSource;
import java.util.Properties;

/**
 * @author KNOE
 * @date 2020-09-21 12:20
 */
@Configuration
@ComponentScan(value = "com.springboot.chapter3.*",
    excludeFilters = {@ComponentScan.Filter(classes = {Service.class})})
public class AppConfig {
    @Bean(name = "dataSource")
    public DataSource getDataSource() {
        Properties props = new Properties();
        props.setProperty("driver", "com.driver.jdbc.Driver");
        props.setProperty("url", "jdbc:mysql://localhost:3306/testdb");
        props.setProperty("username", "root");
        props.setProperty("password", "123456");
        DataSource dataSource = null;
        try{
            dataSource = BasicDataSourceFactory.createDataSource(props);
        }catch (Exception e) {
            e.printStackTrace();
        }
        return dataSource;
    }
}

测试一下

package com.springboot.chapter3.config;

import com.springboot.chapter3.pojo.User;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import javax.sql.DataSource;


/**
 * @author KNOE
 * @date 2020-09-21 12:23
 */
public class IoCTest {
    private static Logger log = LogManager.getLogger(IoCTest.class);
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx
                = new AnnotationConfigApplicationContext(AppConfig.class);
        User user = ctx.getBean(User.class);
        log.info(user.getId());
        DataSource dataSource = ctx.getBean(DataSource.class);
        log.info(dataSource.getClass());
    }
}

没有任何问题
在这里插入图片描述

Koneeeeeee
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot 实现定时任务
wenxuankeji的博客
04-16 1212
Spring Boot 实现定时任务
关于SpringBoot获取IOC容器中注入的Bean(推荐)
08-27
本文通过实例代码给大家详解了springboot获取ioc容器中注入的bean问题，非常不错，具有一定的参考借鉴价值，需要的朋友参考下吧
【SpringBoot学习笔记（三）】之IoC容器，BeanFactory接口，ApplicationContext接口
开发小鸽
11-18 486
本文章由公号【开发小鸽】发布！欢迎关注！！！ 老规矩–妹妹镇楼： 一. Spring IoC        Ioc容器是Spring的核心，可以说Spring是一种基于IOC容器编程的框架。它通过描述来生成或者获取对象，之前是通过XML来描述，这里使用全注解的方式来描述。一个系统可以生成各种对象，这些对象都需要管理，并且它们之间存在着依赖关系，通过描述就能够管理它们之间的关系。 二. IOC容器       &nbsp
探究 Spring Boot 的核心：IOC 和 AOP
喜欢猪猪
02-22 477
Spring Boot 作为一种简化 Spring 应用开发的工具，继承了 Spring 框架的核心概念，其中最重要的是控制反转（IOC）和面向切面编程（AOP）。它们是 Spring 框架的基础，同时也深深植根于 Spring Boot 中。本文将讨论 IOC 和 AOP 的概念以及它们在 Spring Boot 中的应用。
初识Spring - 什么是IoC容器？
weixin_64874291的博客
07-11 499
容器就是用来容纳物品的一个装置。在之前的文章中也有提到，向Java集合框架中的List，Map，这就是存储数据的一个容器，还有Tomcat就Web容器。IoC（Inversion of Control）我们需要把它翻译成 ”控制权的反转“ 的一个容器，我们可以用一个场景来解释什么是控制权的反转：有一个A对象和B对象，此时如果要使用B对象，要依赖B对象才可以使用，所以此时就需要在A对象中 new 一个B对象，也就是说 A对象控制着B对象的生命周期，用到了就去创建它，不用了就把它销毁耦合。
SpringBoot（7）认识Ioc容器和Servlet容器
weixin_43831002的博客
07-30 431
loC(InversionofControl)容器，是面向对象编程中的一种设计原则，意为控制反转(也被称为'控制反向”或"控制倒置”)。它将程序中创建对象的控制权交给Spring框架来管理，以便降低计算机代码之间的耦合度。控制反转的实质是获得依赖对象的过程被反转了。这个过程由自身管理变为由loC容器主动注入。这正是loC实现的方式之一依赖注入(dependencyinjection,DI),由loC容器在运行期间动态地将某种依赖关系注入对象之中。...
Spring Boot原理分析（二）：IoC
TracyCoder的博客
07-09 1398
IoC（Inversion of Control）容器是一个软件组件，用于管理和组织应用程序中的对象和依赖关系。它实现了控制反转（Inversion of Control）的概念，即将对象的创建和依赖关系的管理交给容器来完成，而不是由开发人员手动管理。通过使用IoC容器，开发者可以将关注点从对象的创建和依赖管理中解脱出来，更专注于业务逻辑的实现。同时，IoC容器也提供了更灵活的配置方式，可以根据不同的环境和需求进行配置，使系统更易于扩展和维护。
spring boot IoC容器简介
qq_20453349的博客
02-19 1055
1，Spring IoC容器是一个管理Bean的容器，在Spring的定义中，它要求所有的IoC容器都需要实现接口BeanFactory，BeanFactory是一个顶级容器接口。 2，由于BeanFactory的功能还不够强大，因此Spring在BeanFactory的基础上，还设计了一个更为高级的接口ApplicationContext。它是BeanFactory的子接口之一，在Spring的体系中BeanFactory和ApplicationContext是最为重要的接口设计，在现实中我们使用的大部
Spring —— IoC 容器详解
Morty的技术乐园
10-08 1632
引言 本篇博客总结自官网的《The IoC Container》，其中会有一些自己的语言描述和理解，大部分会摘抄官网的解释说明。 主要介绍什么是 IoC 容器，什么是 Bean，依赖，Bean Definition，Bean Factory 等概念知识，帮助扫除 spring framework 框架知识盲区。 一、什么是 Spring IoC 容器？什么是 Bean？ IoC 也可以理解为依赖注入（dependency injection）（参考《控制反转 IOC 与依赖注入 DI》），它是一个只
Spring Boot：深度解析 IoC 容器
2301_76607156的博客
04-28 579
Spring IoC 容器是整个框架中最核心、最关键的一部分内容，也是许多面试考察中的重要内容。今天我将从 Spring 接口源码入手，与大家一块学习下容器相关的内容。今天的内容包括三部分，第一部分是 Spring 中 BeanFactory 接口及其子类（接口）的梳理；第二部分是对 ApplicationContext 接口及其子类实现的梳理；最后一部分从应用的角度介绍容器的使用、配置、定制化等内容。
Springboot入门之IOC
LulalaBoke的博客
02-27 324
Springboot入门之IOC。
一文了解SpringBoot中的IOC
AndroidOrCsharp
08-24 722
SpringBoot中Ioc详解和使用
IOC容器初始化过程
01-27
IOC容器的初始化分为三个过程实现：第一个过程是Resource资源定位。这个Resouce指的是BeanDefinition的资源定位。这个过程就是容器找数据的过程，就像水桶装水需要先找到水一样。 第二个过程是BeanDefinition的载入...
详解Spring IOC 容器启动流程分析
08-25
主要介绍了Spring IOC 容器启动流程分析,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
Spring为IOC容器注入Bean的五种方式详解
08-25
主要介绍了Spring为IOC容器注入Bean的五种方式详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring创建IOC容器的方式解析
08-25
主要介绍了Spring创建IOC容器的方式解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring Boot 中Mybatis使用Like的使用方式和注意点
程序人生
04-19 732
使用Springboot简单配置一下Mybatis，然后进行说明。Springboot集成Mybatis这里就不做介绍了，这里我们主要介绍一下在mybatis配置文件中怎么使用模糊查询。
spring的CacheManager
weixin_42594143的博客
04-26 207
上述代码中，我们通过@Cacheable注解将getUserById方法标记为需要缓存的方法，并指定缓存名称为"myCache"。当该方法被调用时，如果缓存中已经存在对应的结果，则直接返回缓存中的数据，否则执行方法体并将结果存入缓存中。需要注意的是，@Cacheable注解默认使用方法的参数作为缓存的key，因此在使用时需要保证参数的唯一性。在使用缓存的地方，可以通过@Cacheable注解来标记需要缓存的方法，并指定缓存名称。上述代码中，我们使用了用户对象的id属性作为缓存key，以保证缓存的唯一性。
vue与Spring boot数据交互例子【简单版】
最新发布
m0_64289188的博客
04-26 460
官网解释：Vue 是一套用于构建用户界面的渐进式框架。与其它大型框架不同的是，Vue 被设计为可以自底向上逐层应用。Vue 的核心库只关注视图层，不仅易于上手，还便于与第三方库或既有项目整合。另一方面，当与现代化的工具链以及各种支持类库结合使用时，Vue 也完全能够为复杂的单页应用提供驱动。
springboot的ioc
09-19
Spring Boot是一个基于Spring框架的开源框架，它简化了新Spring应用的搭建和开发过程。在Spring Boot中，IOC（Inversion of Control...通过在类上添加注解，Spring Boot会自动扫描并创建Bean，并将其注入到IOC容器中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值