SpringIOC/DI详解

于 2024-07-19 15:45:26 发布
阅读量509 收藏 12
点赞数 9
分类专栏： Spring 文章标签： java 后端 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63688997/article/details/140530040
版权

Spring

SpringIOC

Spring的配置

    1.spring2.5前==xml
    2.spring2.5后==xml+annotation
    3.spring3.0后==JavaConfig+annotation配置类

下方为示例配置类

@Configuration
@ComponentScan(basePackages="com.apesource")
@PropertySource(value="stu.properties")
@Import(DataSourceConfig.class)
public class AnnotationConfig {
//    @Bean
//    public IUserDao getDao(){
//        return new UserDao();
//    }
//    @Bean
//    public IUserService getService(IUserDao userDao){
//        return new UserService(userDao);
//    }
//    @Bean
//    public IUserController getController(IUserService service){
//        return new UserController(service);
//    }
    @Bean(name="time")
    public Date getDate(){
        return new Date();
    }
}

Bean的实例化

  1. 默认通过无参构造
  2. 普通工厂实例化
  3. 静态工厂实例化

Bean的作用域

singleton :Spring 只会为该 bean 对象只会创建唯一实例,Spring中的bean默认都是单例；

prototype：每次获取 bean，Spring 会创建一个新的 bean 实例;

request：每一次Http请求，Spring会创建一个新的 bean 实例;

session：不同的 HTTP 会话，Spring会创建不同的bean 实例;

通过XML方式设置bean的作用域

<bean id="demoDaoBean" class="com.apesource.dao.DemoDA0Impl" scope="singleton"/>

通过注解方式设置bean的作用域

@Scope(ConfigurableBeanFactory.SCOPE PROTOTYPE)
public class DemoDAOImpl implements IDemoDAo{}

Spring DI

​    DI（Dependecy Inject，中文释义：依赖注入）是对IOC概念的不同角度的描述，是指应用程序在运行时，每一个bean对象都依赖IOC容器注入当前bean对象所需要的另外一个bean对象。（例如在MyBatis整合Spring时，SqlSessionFactoryBean 依赖IOC容器注入一个DataSource数据源bean）。

Spring DI 的实现方式

1. set注入
在<bean>标签中使用<property>标签注入
  1.1 首先创建实体类，并重写属性的set方法。

public class Student {
    private String stuName;
    private String hobby;
    private int age;

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

  1.2 在Spring配置文件中配置

    <bean id="student" class="com.pojo.Student">
		<property name="stuName" value="wwt">
    </bean>

2. 构造注入
在<bean>标签中使用<constructor-arg>标签注入
  2.1首先在实体类实现有参无参构造

public class Student {
    private String stuName;
    private String hobby;
    private int age;

    public Student(String stuName, String hobby, int age) {
        this.stuName = stuName;
        this.hobby = hobby;
        this.age = age;
    }

    public Student() {
    }

    public Student(String stuName, String hobby) {
        this.stuName = stuName;
        this.hobby = hobby;
    }

}

  2.2在Spring配置文件中配置

    <bean id="student" class="com.pojo.Student">
        <constructor-arg index="0" value="川普"></constructor-arg>
        <constructor-arg index="1" value="演讲"></constructor-arg>
    </bean>

3. 注解注入
  3.1举例

@Component
public class Student {
    @Value("wwt")
    private String stuName;
    @Value("game")
    private String hobby;
    @Value("$21")
    private int age;
}

支持的数据类型

  1. 基本类型与String

举例同上方Set注入

  1. javaBean对象
    （1）在配置文件中注入

   2.1.1 如下Techer类中student属性为另一实体类

public class Teacher {
    private Student student;

    public Teacher(Student student) {
        this.student = student;
    }
    
    public Teacher() {
    }
}

   2.1.2 先配置student实体类再配置teacher实体类
此处使用构造注入<constructor-arg>标签中的ref属性用来引入已经实例化的bean

    <bean id="student" class="com.pojo.Student">
        <constructor-arg name="stuName" value="wwt"></constructor-arg>
        <constructor-arg name="hobby" value="youxi"></constructor-arg>
    </bean>
    <bean id="teacher" class="com.pojo.Teacher">
        <constructor-arg name="student" ref="student"></constructor-arg>
    </bean>

   （2）使用注解注入
需要在注入和被注入类上添加注入Ioc容器类型注入如：@Component、@Service等等，在注入的类中声明被注入对象，在其上方添加@Autowired标签，该标签要与<context:component-scan base-package=“com”></context:component-scan>搭配使用，该注解用于扫描包路径。

@Component
public class UserService implements IUserService{
    @Autowired
    IUserDao userDao;

    @Override
    public void save() {
        System.out.println("service层的save方法");
        userDao.save();
    }
}
  1. 复杂类型
    3.1定义一个属性全为复杂类型的Teacher类
public class Teacher {
    private List tName;
    private Map tHobby;
    private String[] tId;
    private Properties tF;
    private Set tL;

    public void settL(Set tL) {
        this.tL = tL;
    }

    public void settName(List tName) {
        this.tName = tName;
    }

    public void settHobby(Map tHobby) {
        this.tHobby = tHobby;
    }

    public void settId(String[] tId) {
        this.tId = tId;
    }

    public void settF(Properties tF) {
        this.tF = tF;
    }


    public Teacher(List tName, Map tHobby, String[] tId, Properties tF, Set tL) {
        this.tName = tName;
        this.tHobby = tHobby;
        this.tId = tId;
        this.tF = tF;
        this.tL = tL;
    }

    public Teacher() {
    }
    @Override
    public String toString() {
        return "Teacher{" +
                "tName=" + tName +
                ", tHobby=" + tHobby +
                ", tId=" + Arrays.toString(tId) +
                ", tF=" + tF +
                ", tL=" + tL +
                '}';
    }
}

  3.2在spring配置文件中通过set注入

    <bean id="teacher" class="com.apesource.pojo.Teacher">
        <property name="tName">
            <list>
                <value>张三</value>
                <value>李四</value>
                <value>王二麻子</value>
            </list>
        </property>
        <property name="tHobby">
            <map>
                <entry key="user" value="root"></entry>
                <entry key="pwd" value="489123"></entry>
            </map>
        </property>
        <property name="tId">
            <array>
                <value>S0123</value>
                <value>S0124</value>
                <value>S0125</value>
                <value>S0126</value>
            </array>
        </property>
        <property name="tF">
            <props>
                <prop key="youxi">LoL</prop>
                <prop key="showyou">PS</prop>
                <prop key="duanyou">CS</prop>
            </props>
        </property>
        <property name="tL">
            <set>
                <value>wwt</value>
            </set>
        </property>
    </bean>
  • List类型：<list><value>值</value></list>
  • Map类型：<map><entry key=“a” value=b"></entry></map>
  • 数组类型：<array><value>值</value></array>
  • Set类型：<set><value>值</value></set>
  • Properties类型：<props><prop key=“a”>值</prop></props>

注解

1.注入类

    替换：<bean id=“” class=“”></bean>
    位置：类
    语法：@Component(value=“注入容器中的id，如果省略id为类名且首字母小写，value属性名称可以省略”)
    @Component
      eg：Class User{}
      <bean id=“user” class=“com.apesource.包.User”></bean>
                ||等价于||
    @Component
      Class User{}
<context:component-scan base-package=“”></context:component-scan>功能一致
含义：扫描所有被@Component注解所修饰的类，注入容器
    @Repository=====>注入数据访问层
    @Service========>注入业务层
    @Controller=====>注入控制层
  以上三个注解与@Component功能语法一致

2.注入基本数据，javaBean

​ @Value
    含义：注入基本数据
    替换：<property></property>
    修饰：成员变量或对应的set方法
    语法：@Value(“数据内容”)
          @Value(“${动态获取}”)

    加载指定资源文件：<context:property-placeholder location=“classpath:jdbc.properties”></context:property-placeholder>

​ @Autowired
    替换：DI实现javaBean注入
    语法：@Autowired(required = “true-默认、false、是否必须进行装配”)
    修饰：成员变量或对应的构造方法
    含义：按照通过构造方法进行“类型装配”，构造方法可以省略
     注意：
      1.默认是按照类型装配且同构造方法
      2.若容器中有一个类型可以与之匹配则装配成功,若没有一个类型可以匹配则报错NoSuchBeanDefinitionException
      3.若容器中有多个类型可以与之匹配，则自动切换为按照名称装配，若名称没有对应，则报错NoUniqueBeanDefinitionException

3.其他注解

​ @Primary
    含义：首选项，当类型冲突的情况下，此注解修饰的类被列为首选（备胎扶正）
    修饰：类
    注意：不能单独使用，必须与@Component…联合使用
​ @Qualifier(value=“名称”)
    含义：按照名称装配
    修饰：成员变量
    注意：不能单独使用，必须与@Autowired联合使用
​ @Resource(name=“名称”)
    含义：按照名称装配
    修饰：成员变量
    注意：单独使用
​ @Scope
    含义：配置类的作用域
    修饰：类
    注意：不能单独使用，必须与@Component…联合使用
      @Scope(“prototype”)
      @Scope(“singleton”)
      @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
      @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
    @PostConstruct:初始化，修饰方法 替换：init-method
    @PreDestroy:销毁,修饰方法 替换：destory-method

spring中的新注解

​ @Configuration
    作用：指定当前类是一个配置类，替代applicationContext.xml文件
    细节：当配置类作为AnnotationConfigApplicationContext对象创建的参数时，该注解可以不写。
​ @ComponentScan
    作用：用于通过注解指定spring在创建容器时要扫描的包
    替换：<context:component-scan base-package=“com.apesource”></context:component-scan>
​ @PropertySource
    作用：用于指定properties文件的位置
    属性：value：指定文件的名称和路径。
    替换：<context:property-placeholder location=“classpath:jdbc.properties”></context:property-placeholder>
​ @Bean
    作用：用于把当前方法的返回值作为bean对象存入spring的容器中
    属性：name:用于指定bean的id。当不写时，默认值是当前方法的名称
​ @Import
    作用：用于导入其他的配置类
    属性：value：用于指定其他配置类的字节码。
    例子:@Import(SystemSpringConfig.class)

猿究院---王某人
关注
  • 9
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring 6【什么是Spring 6、Spring框架介绍 、Spring IoC/DI 详解 】(一)-全面详解（学习总结---从入门到深化）
07-16 3359
Spring 6【什么是Spring 6、Spring框架介绍、Spring IoC/DI 详解】(一)-全面详解（学习总结---从入门到深化）
SpringIOC DI循环依赖实例详解
08-24
SpringIOC DI 循环依赖实例详解 SpringIOC 是一个基于依赖注入（Dependency Injection，简称 DI）的容器，用于管理 Bean 的生命周期。 DI 循环依赖是指在 Bean 初始化过程中出现的循环依赖问题，即一个 Bean 依赖于...
Spring IoC/DI详解
风泊月
03-12 410
1.1IOC是什么？       Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面...
spring IOC和DI详解
qq_36109477的博客
12-16 456
spring、IOC、DI、Java反射。
Spring框架 IOC/DI AOP 常用注解总结
weixin_47790139的博客
12-22 657
文章目录前言1.Spring1.1Spring介绍1.2传统项目开发的弊端1.2.1编辑Dog类1.2.2编辑Cat类1.2.3编辑测试类1.2.4测试问题总结:1.3面向接口变成1.3.1业务说明1.3.2封装Pet接口1.3.3编辑2个实现类1.3.4编辑User测试类1.3.5面向接口开发小结1.4Spring-IOC(Inversion of Control)1.4.1 面向接口编程弊端1.4.2 IOC调用原理图1.5 Spring-IOC 入门案例1.5.1 准备Dog类1.5.2 准备spri
Spring中IOC/DI详解
weixin_44761910的博客
10-18 123
参考： 控制反转与依赖注入概述——Spring IOC/DI（一） 依赖注入原理，作用，注入方式——Spring IOC/DI（二） 依赖注入的两种常用方式(构造器和Setter)与注入内容(装配数据)——Spring IOC/DI（三） 自动装配的几种方式——Spring IOC/DI（四） 基于注解的组件扫描——Spring IOC/DI（五） ...
Spring框架IoC/DI原理及实现
弱水三千、先干为敬
09-04 630
1、概念 IoC：指将对象的创建权，交给到Spring容器； DI ：指Spring创建对象的过程中，将对象依赖的属性通过配置的方式自动的设值给当前的对象 。 IoC/DI注解详解 完成IoC/DI，有两种方式，一种是使用xml配置文件，另一种是使用注解，我们先来介绍xml方式。 2、xml配置 2.1 使用setter注入（推荐） Setter注入:最常用的注入方法,需要在xml配置文件中进行手...
Spring IOC/DI 详解，小白怎么用Spring框架
小锤锤的博客
10-29 159
Spring框架是一个轻量式，非侵入式，可插拔的JAVA EE框架。 对于大型项目来说，省时省力，免去了大量敲写代码的繁琐；如果用Spring框架来做一个小实验，规劝各位还是去用基础java语言去完成，Spring的配置以及各种包的梳理，就远远超过你的实验量。Spring主要是面对于大型项目来准备的框架。 一：什么是Spring IOC？ Spring IOC（控制反转）：设计好的类交给系统...
Spring IOC/DI、AOP 源码详解
轻狂書生的博客
06-03 321
思维导图 思维导图链接 https://www.yuque.com/docs/share/13828bff-6abf-4a12-8970-d4842e8994e3?# 《Spring IOC/DI、AOP 源码详解》 思维导图内容 Spring IOC/DIAOP 核心概念 BeanDefinition BeanDefinition 中保存了我们的 Bean 信息，比如这个 Bean 指向的是哪个类、是否是单例的、是否懒加载、这个 Bean 依赖了哪些 Bean 等等。 BeanDef
Spring详解—— IOC 和 DI 区别
说故事的五公子
06-25 1563
我们只要提到Spring这个词，有简单了解过Spring的人基本上都会脱口而出IoC、DI和AOP这几个概念。但是对于初学者来说，一下子搞懂IoC和DI的概念还是挺麻烦的。比如之前我自己刚刚学习Spring的时候，只知道IoC能够帮我们创建对象，不再需要我们自己去创建了，并且那时IoC和DI傻傻分不清，对AOP的概念就更加不用说了。所以这次一定要好好理解。IoC（Inversion of Control）的意思是“控制反转”，它是Spring最核心的点，并且贯穿始终。IoC并不是一门技术，而是一种设计思想。
spring IOC /DI 详解
acoolper的专栏
03-16 678
有时候经常会提到spring的IOC(控制反转Inversion of Control)  DI(依赖注入 Dependency Injection)可能很少听到.这些都是spring提供给我们非常实用的东西 我们平时开发用的最多 但是概念以及认识上并没有那么细致全面.今天就百度了一下找到一些比较好的学习文章跟大家分享一下 概念性的解释参照百度百科http://baike.baidu.com/v
spring的IoC和DI详解
08-28
Spring的IoC和DI详解 Spring 框架中的控制反转（IoC）和依赖注入（DI）是两个紧密相关的概念，它们都是Spring框架的核心机制。IoC是指将对象的创建权由Spring管理，而不是由程序员手动创建对象。DI则是将对象依赖的...
Spring IOC原理详解
08-28
Spring IOC原理详解 Spring IOC（Inversion of Control，控制反转）是 Spring 框架的核心概念，它解决了对象之间的耦合问题，实现了松耦合编程。IOC 的思想是，Spring 容器来实现对象之间的创建、协调工作，而不是...
spring ioc di aop详解
11-01
在 Spring 中，IOC（Inversion of Control，控制反转）和 DI（Dependency Injection，依赖注入）是两个核心概念，而 AOP（Aspect Oriented Programming，面向切面编程）则是实现模块化和解耦的重要工具。现在，我们...
Spring IOC和aop的原理及实例详解
08-25
Spring IOC和AOP的原理及实例详解 在软件开发中，控制反转（IOC）和面向切面编程（AOP）是两种非常重要的设计模式。Spring框架正是基于这两种模式的思想设计的。下面我们将详细介绍Spring IOC和AOP的原理及实例详解...
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 823
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 897
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1021
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
最新发布
m0_69266818的博客
07-15 826
介绍了Redis命令和用java操作redis还有营业额状态接口的书写

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值