Spring DI 笔记

于 2024-10-01 17:09:18 发布
阅读量1k 收藏 14
点赞数 21
分类专栏： javaEE 文章标签： 笔记 java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WHabc2002/article/details/142671561
版权

目录

1.什么是DI?

 2.依赖注入的三种⽅式

2.1属性注⼊ 

2.2构造⽅法注⼊

 2.3Setter 注⼊

 2.4三种注⼊优缺点分析

3.@Autowired存在问题 

1.什么是DI?

DI: 依赖注⼊
依赖注⼊是⼀个过程，是指IoC容器在创建Bean时, 去提供运⾏时所依赖的资源，⽽资源指的就是对象

简单来说, 就是把对象取出来放到某个类的属性中.

关于依赖注⼊, Spring也给我们提供了三种⽅式:

1.属性注⼊(Field Injection)

2.构造⽅法注⼊(Constructor Injection)

3.Setter 注⼊(Setter Injection)

都是使用@Autowired实现的。 

接下来，我们分别来看.

 2.依赖注入的三种⽅式

都是使用@Autowired实现的 

我们接下来会频繁使用到UserService类和UserController类以及获取 UserController 中的 sayHi⽅法。

1.UserService代码：

import org.springframework.stereotype.Service;

@Service
public class UserService {

    public void doService(){
        System.out.println("doService~~~~");
    }
}

 2.UserController类依照我们选择的注入⽅式决定。

3.获取 UserController 中的 sayHi⽅法：

​
import com.wh.ioc.Controller.UserController;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

//@ComponentScan(basePackages = "~~~~~")
@SpringBootApplication
public class SpringIocApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringIocApplication.class, args);

        UserController bean = context.getBean(UserController.class);
        bean.sayHi();
    }
}

​

2.1属性注⼊ 

UserController类的实现代码如下：

import com.wh.ioc.Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    public void sayHi(){
        userService.doService();
        System.out.println("UserController Hi");
    }
}

2.2构造⽅法注⼊

import com.wh.ioc.Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    private UserService userService;

    public UserController() {
    }
    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    public void sayHi(){
        userService.doService();
        System.out.println("UserController Hi");
    }
}

注意：

  如果类只有⼀个构造⽅法，那么 @Autowired 注解可以省略；如果类中有多个构造⽅法，
那么需要添加上 @Autowired 来明确指定到底使⽤哪个构造⽅法。

 补充：

关于构造函数规范：

1.当我们添加有参构造函数时，一定也要把无参构造函数也添加上。

2.依赖注入时，就算只有一个构造函数也要添加@Autowired注解

 2.3Setter 注⼊

注解一定不能少

import com.wh.ioc.Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    private UserService userService;


    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void sayHi(){
        userService.doService();
        System.out.println("UserController Hi");
    }
}

 2.4三种注⼊优缺点分析

1.属性注⼊

优点:

简洁，使⽤⽅便

缺点：

（1） 只能⽤于 IoC 容器 ，如果是⾮ IoC 容器不可⽤，并且只有在使⽤的时候才会出现 NPE（空指 针异常）
（2） 不能注⼊⼀个Final修饰的属性

 2.构造函数注⼊(Spring 4.X推荐)

 优点:

（1）注⼊的对象不会被修改

（2）可以注⼊final修饰的属性

（3）依赖对象在使⽤前⼀定会被完全初始化，因为依赖是在类的构造⽅法中执⾏的，⽽构造⽅法 是在类加载阶段就会执⾏的⽅法

（4）通⽤性好, 构造⽅法是JDK⽀持的, 所以更换任何框架,他都是适⽤的

缺点：

注⼊多个对象时, 代码会⽐较繁琐 

3.Setter注⼊(Spring 3.X推荐)  

优点:
⽅便在类实例之后, 重新对该对象进⾏配置或者注⼊

缺点:

1.不能注⼊⼀个Final修饰的属性

2.注⼊对象可能会被改变, 因为setter⽅法可能会被多次调⽤, 就有被修改的⻛险 

3.@Autowired存在问题 

我们接下来用打印学生信息的例子来说明

Student类：

import lombok.Data;

@Data
public class Student {
    private String name;
    private Integer id;

    public Student() {

    }

    public Student(String name) {
        this.name = name;
    }

    public Student(String name, Integer id) {
        this.name = name;
        this.id = id;
    }
}
BeanConfig类：

import com.wh.ioc.Model.Student;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class BeanConfig {

    @Bean
    public Student StudentInfo() {
        return new Student("wh",01);
    }
    @Bean
    public Student StudentInfo2() {
        return new Student("Bob",02);
    }
}

DomeController类：
import com.wh.ioc.Model.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class DomeController {
    @Autowired
    private Student student;
    public void say(){
        System.out.println(student);
    }
}

启动类：

import com.wh.ioc.Controller.DomeController;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

//@ComponentScan(basePackages = "~~~~~")
@SpringBootApplication
public class SpringIocApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringIocApplication.class, args);

        DomeController bean = context.getBean(DomeController.class);
        bean.say();
    }
}

运行：

报错的原因是，⾮唯⼀的 Bean 对象 

解释：

@Autowired是先按照类型去注入，匹配到多个对象时，再按照名称去注入。

如果我们明确注入对象的名称，则可以正确打印该学生信息。

DomeController类代码：

import com.wh.ioc.Model.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class DomeController {
    @Autowired
    private Student StudentInfo2;
    public void say(){
        System.out.println(StudentInfo2);
    }
}

结果：

 

那当我们没有明确注入对象的名称，又想得到正确结果我们可以怎么做？

有以下⼏种解决⽅案：
1.@Primary
2.@Qualifier
3.@Resource

1. @Primary

使⽤@Primary注解：当存在多个相同类型的Bean注⼊时，加上@Primary注解，来确定默认的实现。

直接加到Bean注⼊的方法上。

@Primary
@Bean
public Student StudentInfo() {
    return new Student("wh", 01);
}

2.@Qualifier

使⽤@Qualifier注解：指定当前要注⼊的bean对象。 在@Qualifier的value属性中，指定注⼊的bean 的名称。
@Qualifier注解不能单独使⽤，必须配合@Autowired使⽤ 
@Controller
public class DomeController {
    @Qualifier("StudentInfo2")
    @Autowired
    private Student student;
    public void say(){
        System.out.println(student);
    }
}

3.@Resource注解

本身就是依赖注入注解，是按照bean的名称进⾏注⼊。

@Controller
public class DomeController {
    @Resource(name = "StudentInfo")
    private Student student;
    public void say(){
        System.out.println(student);
    }
}

那@Autowird 与 @Resource的区别是？

 1.@Autowired 是spring框架提供的注解，⽽@Resource是JDK提供的注解

 2.@Autowired 默认是按照类型注⼊，⽽@Resource是按照名称注⼊. 相⽐于 @Autowired 来说， @Resource ⽀持更多的参数设置，例如 name 设置，根据名称获取 Bean

以上为我个人的小分享，如有问题，欢迎讨论！！！ 

都看到这了，不如关注一下，给个免费的赞 

 

WH牛
关注
专栏目录
【Spring框架】Spring中的DI介绍
Sampson_S的博客
06-18 5510
Spring中的DI介绍 DI（Dependency Injection），即“依赖注入”，组件之间依赖关系由容器在运行期决定，即容器动态的将某个依赖关系注入到组件当中。它是是 Spring 框架核心IOC技术的具体实现。 依赖注入是控制反转最常用的方式，通过控制反转可以减低计算机代码之间的耦合度。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。 DI理解的关键点“谁依赖谁，为什么需要依赖” 谁依赖谁：应用程序依赖IOC容器
Spring学习笔记+学习源码.zip
05-12
Spring框架是Java开发中的核心组件，它为应用程序提供了一个全面的基础设施，包括依赖注入（DI）、面向切面编程（AOP）以及数据访问等服务。SSM是Spring、SpringMVC和MyBatis的组合，是Java Web开发的常用框架栈。这...
Spring(DI)
xasasaa的博客
03-20 1261
DI（Dependency Injection）即依赖注入，对象之间的依赖由容器在运行期决定，即容器动态的将某个依赖注入到对象自重 基于XML配置注入依赖 有参构造函数注入依赖 bean类实现有参构造函数 public class Student { private Integer id; private String name; /** * 有参构造函数 */ public Student(Integer id, String name) {
Spring之DI
四八殇
01-18 282
Dependency Injection：依赖注入。 依赖注入 目的是解决JAVA对象间的紧耦合关系。 例如一个JAVA类，构造函数里new了另一个类，那么这两个类就是紧耦合的。紧耦合的弊端就是难以测试。（我不懂测试方法，所以这里不懂） 但是如果构造函数传入的是另一个类的引用，更抽象一些，传入的是一个接口引用，那这个类就可以和所有实现了该接口的JAVA类产生联系。 这样一种构造时
spring的DI
玩垃圾的人
12-05 719
前言 技术分析之依赖注入（DI） 1. IOC和DI的概念 * IOC -- Inverse of Control，控制反转，将对象的创建权反转给Spring！！ * DI -- Dependency Injection，依赖注入，在Spring框架负责创建Bean对象时，动态的将依赖对象注入到Bean组件中！！ 2. DI（依赖注入）
动力节点老杜Spring6，配套笔记PDF文件
最新发布
02-08
动力节点老杜Spring6配套笔记主要讲解了Spring框架的一些核心概念和最佳实践，特别是针对代码设计中的开闭原则（Open-Closed Principle, OCP）进行了深入探讨。在给出的代码示例中，我们可以看到一个简单的用户登录...
马士兵Spring课堂笔记(超级详细版).pdf
02-28
马士兵Spring课堂笔记（超级详细版） 本资源主要讲解了Spring框架的基础概念和应用，涵盖了面向接口编程、IOC/DI、AOP、Spring应用IOC/DI、Spring应用AOP、Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2整合、Spring...
Spring学习笔记.zip
03-18
Spring框架以其轻量级、依赖注入（DI）和面向切面编程（AOP）等特性而闻名，是Java EE开发中的主流选择。 **依赖注入（Dependency Injection，DI）** 依赖注入是Spring框架的核心特性之一，它允许开发者在运行时将...
韩顺平Spring笔记
04-30
Spring是Java企业级应用开发中的主流框架，它以其依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）为核心，极大地简化了复杂的应用程序设计。在笔记中，韩顺平老师可能详细...
Spring与IoC系列三：基于XML的依赖注入测试程序di.rar
07-25
基于XML的依赖注入测试程序，配合博客资源学习。是基于XML的依赖注入方法的测试程序！
Spring DI
gol_phing的博客
06-15 1088
spring中有三种依赖注入的方式： 1、构造器注入 2、setter方法注入 主要是通过反射，调用setter方法将值注入进去 3、属性注入(注解的方式)属性注入 需要增加命名空间， @Resource默认按名称装载，没有的时候按类型 名称就是字段名 @Autowired默认按类型装载
Spring中的DI(依赖注入)
m0_46853673的博客
12-25 411
Spring中DI介绍 DI-Dependency Injection：依赖注入 bean对象中需要依赖一些其他组件或者对象，依赖关系由容器在运行时决定 两种方式处理依赖注入： 基于配置形式 基于注解形式 基于配置形式注入依赖 有参构造函数注入依赖 public class User { private String name; private UserInfo userInfo; public User(String name,UserInfo userInfo) {
Spring入门（三）Spring的DI
jwang的博客
12-28 384
前言      本章学习Spring的DI的相关知识 方法 1.概念 DI，英文名称为dependency injection，中文名称为依赖注入。 它指的是一个类的属性是对象的时候，将该对象进行注入的过程 它实质上就是IOC，我们可以把它理解为一个特殊的IOC，因为我们之前注入的都是基本数据类型以及String 2.Spring IOC属性注入的两种方式 1）构造器注入 这个前...
Spring 之 DI 详解
岁月安然
05-30 2668
概念 DI(Dependency Injection)依赖注入：依赖注入是指在程序运行期间,由外部容器动态地将依赖对象注入到组件中如：一般，通过构造函数注入、Setter注入、注解注入。 Setter注入与注解注入类似，区别在于：Setter 注入是通过 Set 方法对属性进行赋值，而注解注入是通过反射为属性赋值。 时机 当 Spring IOC 容器完成了 Bean 定义资源的定位、载入、解析和注册以后，IOC 容器中已经管理类 BeanDefinition 的相关数据，但是此时 IOC 容器还没有对所管
spring框架 - DI
一只蚊子学Java
10-31 689
Spring框架 - DI  一、依赖注入（DI）的四种方式         1. set注入（常用）   必须存在setter方法, 声明变量   通过<property>标签注入, 可以注入对象也可以注入基本数据类型;   <!-- set注入 --> <bean id="userDao" class="com.lwx.dao.UserDao"&...
Spring DI详解
热门推荐
qq_42603060的博客
01-23 1万+
1.IOC（DI）-控制反转（依赖注入） 所谓的IOC称之为控制反转，简单来说就是将对象 的创建的权力及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不在需要关注对象的创建和生命周期的管理,而是在需要的时候由Spring框架提供，这个由Spring框架管理对象创建和生命周期的机制称之为控制反转。而在创建对象的过程中Spring可以依据配置对象的属性进行设置，这个过程称之为依...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值