Spring使用注解进行对象装配(DI)

已于 2023-07-26 14:26:26 修改
阅读量2k 收藏 78
点赞数 84
分类专栏： JavaEE 文章标签： spring java 对象装配 Autowired Resource 后端
于 2023-07-26 11:33:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/trong_/article/details/131868659
版权

文章目录


通过五大类注解可以更便捷的将对象存储到 Spring 中，同样也可以使用注解将已经储存的对象取出来，直接赋值到注解所在类的一个属性中，这一个过程也叫做对象的装配或者叫对象的注入，即 DI。

一. 什么是对象装配

获取 Bean 对象也叫做对象装配，就是把对象取出来放到某个类中，有时候也叫对象注入。
对象装配（对象注入）的实现方法以下 3 种：

  1. 属性注入 ，就是将对象注入到某个类的一个属性当中。
  2. 构造方法注入 ，就是通过构造方法来将对象注入到类中。
  3. Setter 注入 ，通过 SetXXX 系列方法将对象注入到类中。

常见有关对象注入的注解有两个，一个是@Autowired，另外一个是@Resource

🍂它们两者的区别如下：

  1. 出身不同：@Autowired 是由Spring提供的，而 @Resource 是JDK提供的。
  2. 查找顺序不同：从容器中获取对象时 @Autowired 先根据类型再根据名称查询，而 @Resource 先根据名称再根据类型查询。
  3. 使⽤时设置的参数不同：@Resource 支持更多的参数设置（有 7 个），如name、type等，而@Autowired只支持设置required一个参数，用来设置注入 Bean 的时候该 Bean 是否必须存在（true/false）。 imgimg
  4. 依赖注入支持不同：@Autowired 支持属性注入，构造方法注入和 Setter 注入，而 @Resource 只支持属性注入和 Settter 注入，但是不支持构造方法注入。
  5. 对 IDEA 的兼容性支持不同：使用 @Autowired 在 IDEA 旗舰版下可能会有误报（设置required即可）；而 @Resource 不存在误报的问题。

二. 三种注入方式

1. 属性注入

属性注入只需要在需要注入对象的属性上加上 @Autowired 或者 @Resource 注解就可以了，这里以 @Autowired 为例。

首先来看第一种情况，待注入的同类对象只有一个，此时我们直接使用 @Autowired 注解就好，不必设置参数，例如我们在UserController类里面注入UserService对象。

下面UserService的结构，先使用 @Service 将 Bean 存放到 Spring 中：

package com.tr.demo.service;

import org.springframework.stereotype.Service;

@Service
public class UserService {
    public void sayHi() {
        System.out.println("Hello, UserService~");
    }
}

属性注入：

package com.tr.demo.controller;

import com.tr.demo.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.sayHi();
    }
}

此时我们就可以在启动类中，使用上下文对象来获取到UserController对象，通过执行UserController对象的sayHi方法来进而调用到注入的UserService对象中的sayHi方法了，此时的UserService对象就不是我们自己new出来的了。

import com.tr.demo.controller.UserController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        UserController usercontroller =  context.getBean("userController", UserController.class);

        usercontroller.sayHi();
    }
}

运行结果：
img
上面说的是同类对象只有一个的情况，而如果存在多个同类对象，我们就得通过参数来告知容器我们要注入哪一个对象，不告知就会报错。

比如我们将多个User对象添加到容器中，如下：

package com.tr.demo.model;
// User 结构
public class User {
    private int id;
    private String name;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.tr.demo.model;

import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
public class UserBeans {
    // 使用方法注解添加多个 User 对象到容器中
    @Bean("user1")
    public User user1(){
        User user = new User();
        user.setId(1);
        user.setName("张三");
        return user;
    }

    @Bean("user2")
    public User user2(){
        User user = new User();
        user.setId(2);
        user.setName("李四");
        return user;
    }

    @Bean("user3")
    public User user3(){
        User user = new User();
        user.setId(3);
        user.setName("王五");
        return user;
    }
}

而在UserController2类中需要注入User对象，此时我们运行程序就会报错：

package com.tr.demo.controller;

import com.tr.demo.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController2 {
    @Autowired
    private User user;

    public void sayHi() {
        System.out.println("Hello, " + user);
    }
}

我们试着以同样的方法来调用sayHi方法：

img
运行结果：

@Autowired 依赖注入流程首先是先根据类型从容器中获取对象，如果只能获取到一个，那么就直接将此对象注入到当前属性上；如果能获取到多个对象，此时会使用 BeanName 进行匹配，而我们添加到 Spring 中的对象是没有一个叫user的，所以程序就报错了。
img

此时就需要我们来告知容器我们需要哪一个具体的 Bean，要获得目标对象主要有下面三种方法：

  • 1️⃣方法1：将属性的变量名设置为你需要的那个BeanName就可以了，后面的构造方法与 Setter 注入同理，将形参名设置成与BeanName相同即可。imgimg
  • 2️⃣方法2：@Autowired 注解与 @Qualifier 注解配合使用，设置 @Qualifier 的value参数为BeanName即可，要注意 @Qualifier 注解不能修饰方法，只能修饰变量。
    imgimg
  • 3️⃣方法3：将 @Autowired 注解替换成 @Resource 注解的，并将它name参数值设置为BeanName即可。 imgimg

2. 构造方法注入

在构造方法加上 @Autowired 注解就可，要注意 @Resource 注解是不支持构造方法注入的，我们就直接演示如何获取取多个同类对象中的其中一个了，还是用上面添加到容器中的多个 User 对象。

方法1：将构造方法形参名设置为user1

package com.tr.demo.controller;

import com.tr.demo.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController3 {
    private User user;
    @Autowired
    public UserController3(User user1) {
        this.user = user1;
    }

    public void sayHi() {
        System.out.println("Hello, " + user);
    }
}

启动类就不贴代码了，一样的，运行结果如下：
img

方法2：@Autowired 搭配 @Qualifier

package com.tr.demo.controller;

import com.tr.demo.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;

@Controller
public class UserController4 {
    private User user;
    @Autowired
    public UserController4(@Qualifier(value = "user2") User user) {
        this.user = user;
    }

    public void sayHi() {
        System.out.println("Hello, " + user);
    }
}

运行结果：
img
对了，如果一个类中只有一个构造方法，@Autowired 是可以省略的，演示一下：

package com.tr.demo.controller;

import com.tr.demo.model.User;
import org.springframework.stereotype.Controller;

@Controller
public class UserController5 {
    private User user;

    public UserController5(User user3) {
        this.user = user3;
    }

    public void sayHi() {
        System.out.println("Hello, " + user);
    }
}

此时仍然是可以成功注入对象。
img
如果有多个构造方法，要注意此时是不能省略 @Autowired 的，会导致会注入对象失败。

package com.tr.demo.controller;

import com.tr.demo.model.User;
import org.springframework.stereotype.Controller;

@Controller
public class UserController6 {
    private User user;

    public UserController6(User user1) {
        this.user = user1;
    }
    
    public UserController6() {
        System.out.println("调用无参构造");
    }

    public void sayHi() {
        System.out.println("Hello, " + user);
    }
}

此时可以看到注入对象失败了，输出的结果是null。

img
当然此时加上 @Autowired 注解就能正常注入了，就不做展示了。

3. Setter注入

Setter 注入就是在 setXXX 系列方法上加上 @Resource 或者 @Autowired 进行注入，和构造方法注入大同小异，简单演示一下。

package com.tr.demo.controller;

import com.tr.demo.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;

@Controller
public class UserController7 {
    private User user;

    @Autowired
    public void setUser(@Qualifier(value = "user2") User user) {
        this.user = user;
    }

    public void sayHi() {
        System.out.println("Hello, " + user);
    }
}

启动类和运行结果：

img

这里这里第一行输入的是因为启动程序会将上面写的UserController6也添加到容器中，UserController6的无参构造方法是我们自定义的。

三. 三种注入方式的优缺点

在早期的 Spring 版本中，官方推荐使用的 Setter 注入，最开始说的原因就是不符合单一设计原则吧，而现在比较新的 Spring 版本（Sring 4.x 之后）中，官方最使用推荐的又是构造方法注入了，说法是因为它的通用性最好。

🎯属性注入

优点：

  1. 使用起来简单方便

缺点：

  1. 无法注入到一个final修饰的变量，因为 final 修饰的变量只有两种赋值方式，一是直接赋值，二是通过构造方法进行赋值，而属性注入这两种方式都不能满足。img
  2. 通用性问题，属性注入只能在 IoC 容器中使用，在非 IoC 容器中是不可⽤的。
  3. 更容易违背单一设计原则，简单理解就是注入方式越简单，滥用的概率越大，就比如在数据持久层有一个针对用户操作的类，本来这个类就只是注入用户相关操作的依赖就行了，但由于属性注入使用起来成本不高，程序猿就多注了一些依赖去完成了一些和用户操作无关的内容，这就违背了单一设计原则了。

🎯Setter 注入

优点：

  1. 通常情况下，setXXX 系列的方法中只会设置一个属性，就更符合单一设计原则。

缺点:

  1. 同样的，也不能注入到一个 final 修饰的变量中。img
  2. 注入的对象是可能被修改的，因为 setXXX 系列的方法随时都有可能被调用导致注入的 Bean 就被修改了。

🎯构造方法注入

优点：

  1. 可以注入到一个被 final 修饰的变量。img
  2. 注入对象不会被修改，因为构造方法只会在对象创建时执行一次，不存在注入对象被随时修改的情况。
  3. 可以保证注入对象的完全初始化，因为构造方法是在对象创建之前执行的。
  4. 通用性最好，因为不管你怎么写 Java 代码，创建实例对象时都要执行构造方法吧。

缺点：

  1. 相较于属性注入，写法更加复杂，如果有多个注⼊会显得⽐较臃肿，但出现这种情况你应该考虑⼀下当前类是否符合程序的单⼀职责的设计模式了。
  2. 使用构造注入，无法解决循环依赖的问题。

四. 综合练习

在 Spring 项⽬中，通过 main ⽅法获取到 Controller 类，调⽤ Controller ⾥⾯通过注⼊的⽅式调⽤ Service 类，Service 再通过注⼊的⽅式获取到 Repository 类，Repository 类⾥⾯有⼀个⽅法构建⼀ 个 User 对象，返回给 main ⽅法。Repository ⽆需连接数据库，使⽤伪代码即可。

首先要清楚的是在 main 方法中是不能使用依赖注入的，因为类的静态部分是在 Spring 注入之前的加载的，仔细想一下，在类加载时就要使用一个还没注入的对象这是不现实的。

所以我们要在 main 中执行的是将扫描路径中的类添加到 Spring 中，对象的注入要在 mian 方法所在类的外部去实现。

img

package com.tr.demo.model;

public class User {
    private int id;
    private String name;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.tr.demo.repository;

import com.tr.demo.model.User;
import org.springframework.stereotype.Repository;

@Repository
public class UserRepository {

    public User getUser(){
        // 伪代码
        User user = new User();
        user.setId(1);
        user.setName("张三");
        return user;
    }

}

package com.tr.demo.service;

import com.tr.demo.model.User;
import com.tr.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public User getUser(){
        return userRepository.getUser();
    }

}

package com.tr.demo.contoller;

import com.tr.demo.model.User;
import com.tr.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

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

    public User getUser(){
        return userService.getUser();
    }

}

package com.tr.demo;

import com.tr.demo.contoller.UserController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 启动类
 */
public class App {

    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        UserController userController =
                context.getBean("userController", UserController.class);
        System.out.println(userController.getUser());
    }
}

运行结果：

img

韵秋梧桐
关注
  • 84
    点赞
  • 踩
  • 78
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 80
    评论
专栏目录
【Spring基础系列1】基于注解装配Bean
飞楼踏梦
08-05 897
​本文主要讲解Spring通过注解装配Bean的常用方式，包括@Component、@Repository、@Service、@Controller、@Autowired、@Resource和@Qualifier。 前言 目前学习java也有一段时间，比较不适应的就是java的各种注解，因为它里面包含了太多的东西，然后使用的姿势也各不相同，今天就简单做个总结和记录，扫一次盲后，后续使用就畅通无阻。 什么是注解 传统的Spring做法是使用.xml文件来对bean进行注入或者是配置aop、事物...
Spring的DI注解配置.zip
08-09
本资料包"Spring的DI注解配置.zip"专注于讲解如何使用注解来实现Spring的DI配置。 一、依赖注入简介 依赖注入是面向对象设计中的一个原则，它提倡组件之间通过接口而非硬编码的实例化来建立关联。在Spring框架中，...
spring（三）基于注解的自动装配
weixin_48702258的博客
10-01 433
基于注解的自动装配 1.spring配置文件 使用注解实现自动装配，我们必须在配置文件中导入context依赖，并且开启注解的支持。下面是基于注解的配置文件 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xm
Spring基于注解的DI
caijigskg的博客
04-04 247
对于DI使用注解，将不再需要在Spring配置文件中声明bean实例。Spring中使用注解，需要在原有Spring运行环境基础上再做一些改变，需要在Spring配置文件中配置组件扫描器，用于在指定的基本包中扫描注解。 基于注解的di：通过注解完成java对象创建，属性赋值。 使用步骤： 1.加入maven的依赖spring-context,在加入spring-context的同时，间接加入spring-aop依赖。 2.在类中加入spring的注解(多个不同功能的注解) 3.在spring的配置
【深入Spring】Spring中基于注解的DI
SmallCatBaby的博客
02-13 146
一.环境搭建 1.在项目中添加Spring AOP相关的JAR文件以及xsd约束文件（导入aop包、添加context约束头信息） 2.由于是基于注解的DI，所以无需再Spring配置文件中进行节点配置，只需配置包扫描器即可！ <!--配置包扫描器--> <context:component-scan base-package="com....
spring注解DI入门程序
learninger12的博客
05-07 414
基于注解的DI入门程序 对于使用注解的DI，我们还需要引入aop jar包 在spring上，提供了两种注解的方式： 1.作用到类上的注解：创建对象 @Component：泛化的概念 @Controller：作用在控制层（Controller）的标识，表示当前的类是控制层 @Service:作用在业务逻辑层（Service）类上的标识，表示当前的类是业务逻辑层 @Respository：作用在持久层（DAO）类上的标识，表示当前的类是持久层 2.作用到成员变量上的注解：给成员变量赋值 @V
使用Spring进行装配
05-31
本篇文章将深入探讨如何使用Spring进行装配，以便在实际项目中构建松散耦合、可维护性强的应用。 首先，理解Spring装配的核心概念是至关重要的。Spring装配是指通过配置文件或注解来定义对象及其依赖关系的过程。这...
spring使用注解依赖jar
03-15
首先，Spring框架的核心特性之一就是依赖注入（Dependency Injection，简称DI），它允许开发者将对象之间的依赖关系从代码中解耦，提高了代码的可测试性和可维护性。在Spring中，注解是实现依赖注入的主要方式，如`@...
Spring——DI和通过注解实现IOC和DI
12-21
总结来说，Spring的DI和IOC通过XML配置或注解实现了对象的创建和依赖关系的管理，降低了代码的耦合度，提高了代码的可读性和可维护性。通过不同的注入方法，如set注入和构造方法注入，以及注解的使用，可以灵活地...
spring 自动装配和aop的使用
08-27
6. **引用类型注入**：`@Autowired`注解用于自动装配匹配的bean，如果有多个候选对象，可以使用`@Qualifier`注解指定具体要注入的bean。 7. **初始化和销毁方法**：`@PostConstruct`和`@PreDestroy`注解分别标识...
Spring DI(依赖注入)注解篇
程序员小奎的博客
01-24 710
1 课程内容介绍 我之前写的的一篇博客Spring核心功能IOC之DI(依赖注入)主要介绍了如何通过配置xml的方式来实现依赖注入，今天我们来介绍如何通过注解方式完成我们的依赖注入操作。 2 注入基本类型 创建用户类为其添加name和age的成员属性并为其提供get set方法 在User上声明@Component标签将其声明为Spirng的bean 通过@Value标签为name和age注入具...
spring注解自动装配实现
m0_46533814的博客
09-04 158
spring注解实现自动装配 1.搭建环境及具体实现步骤 1.xml配置文件通用 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframewor
【Spring】一文带你吃透基于注解的DI技术
热门推荐
YOU__FEI的博客
10-26 2万+
基于注解的DI:使用spring提供的注解，完成java对象创建，属性赋值。注解使用的核心步骤:1.在源代码加入注解，例如@Component。2.在spring的配置文件，加入组件扫描器的标签。@Component注解创建对象 @Component: 表示创建对象，对象放到容器中。 作用：属性：value ，表示对象名称，也就是bean的id属性值。位置：在类的上面，表示创建此类的对象。component-scan:翻译过来是组件扫描器，组件是java对象.......
Spring（IOC、DI）和常见注解
最新发布
kaitezhimao的博客
12-21 83
例如@Insert(value={“aa”}) 等效于 @Insert(“aa”)@Controller、@Service、@Repository是@Component的子注解，和@Component作用一样。指定要扫描的包，扫描指定包下的spring相关注解，和context:component-scan作用相同，但是context:component-scan必须要指定包。false：有合适的注入，没合适的就不注入了。DI是ioc的一部分，注册到IOC容器中的对象，他们之间的依赖关系由DI处理。
java 注解 对象_Java基础-学习使用Annotation注解对象
weixin_34237125的博客
02-21 249
Java基础-学习使用Annotation注解对象注解(也被称为元数据)为我们在代码中添加信息提供了一种形式化的方法,使我们可以在稍后某个时刻非常方便地使用这些数据1-1:基本语法Java SE5内置三种标准注解@Override:表示当前的方法定义将覆盖超类中的方法.如果你不小心拼写错误,或者方法签名对不上被覆盖的方法,编译器就会发出错误提示@Deprecated:如果程序员使用了注解为它的元素...
对象注解属性的最佳实践
DTCloud
07-06 586
本 文 意 在 汇 聚 对 象 的 注 解 字 典 用 法 的 最 佳 实 践。 如 果 Python 代 码 会 去 查 看 Python 对 象 的__annotations__ 属性，建议遵循以下准则。 本文分为四个部分：在 Python 3.10 以上版本中访问对象注解的最佳实践、在 Python 3.9 以上版本中访问对象注解的最佳实践、适用于任何 Python 版本的其他`__annotations__ 最佳实践、__annotations__ 的特别之处。 ......
Spring(五）基于注解的自动装配
超级程序诞生的博客
06-25 1069
注解：和XML配置文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记，具体的功能是框架检测到注解标记的位置，然后针对这个位置按照注解标记的功能来执行具体操作。本质上：所以一切的操作都是java代码来完成的，XML和注解只是告诉框架中的代码如何执行。扫描：Spring为了知道程序员在哪些地方标记了什么注解，就需要通过扫描的方式，来进行检测，然后根据注解进行后续操作。
Spring：自动装配 Bean 的两种方式、使用注解开发
taiyang3285的博客
05-18 1799
详细介绍了自动装配 Bean 的两种方式，以及使用注解开发来代替 xml 配置文件
Spring之DI
coderidea
08-26 1749
Spring是一个开源框架，Spring是为了解决企业级应用开发的复杂性而创建的，使用Spring可以让简单的JavaBean实现只有EJB才能完成的简单性。简单来说Spring最根本的使命：简化Java开发。Spring的目标是致力于全方位的简化Java开发。那么Spring是如何简化Java开发的呢？ 1. 基于POJO的轻量级和最小侵入性编程 2.通过依赖注入（DI）和面向接口实现松耦合......
springDI注解
07-27
Spring DI（Dependency Injection）是Spring框架中的一种依赖注入机制，通过使用注解来实现对象之间的依赖关系的管理。 在Spring中，有几个常用的注解用于实现DI： 1. @Autowired：用于自动装配依赖。通过该注解，...
评论 80
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

韵秋梧桐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值