Spring 中简单存取 Bean 的相关注解

已于 2023-07-25 12:26:57 修改
阅读量1k 收藏 3
点赞数 2
分类专栏： JavaEE 文章标签： spring java java-ee
于 2023-07-24 12:40:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_71360748/article/details/131860171
版权

目录

前言

之前我们存储获取 Bean 的操作很繁琐，需要将 Bean 放入 xml 文件中，获取 Bean 还必须得获取上下文，就很麻烦。

其实这些都可以简化，在 Spring 中想要更简单的存储和读取对象，核⼼是使⽤注解。

想要将对象存储在 Spring 中，有两种注解类型可以实现：

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

获取对象的实现⽅法有以下 3 种：

  1. 属性注⼊
  2. 构造⽅法注⼊
  3. Setter 注⼊

存储 Bean 对象

五大类注解

五大类注解有：
@Controller（控制器）校验参数的合法性，相当于安检系统
@Service（服务）业务组装，相当于客服中心
@Repository（数据持久层）实际业务处理，就是实际办理的业务
@Component（组件）工具类层，基础工具
@Configuration（配置层）配置

首先，我们得配置一下 xml 文件：

在这里插入图片描述

注意：使用类注解存储 bean，和使用 xml 存储 bean 是可以混用的。

User 类：

//使用类注解
@Controller
public class User {
    public void sayHi(String name) {
        System.out.println("hello " + name);
    }
}

public class App {
    public static void main(String[] args) {
        //得到 spring 上下文
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //得到 bean 对象
        User user = (User) context.getBean("user");
        user.sayHi("张三");
    }
}

在这里插入图片描述

关于 getBean 后面应该填什么？
对于不同的类名有不同的写法，如果首字母大写，第二个字母小写，那么 bean 的名称就是类名首字母小写；如果不满足首字母大写第二字母小写，则使用原类名。

当然了，我们也可以在类注解后面设置 id，通过 id 来得到 bean 对象。

//id 可以随便取, 两种方式都可
//@Controller(value = "666")
@Controller("666")
public class User {
    public void sayHi(String name) {
        System.out.println("hello " + name);
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        User user = (User) context.getBean("666");
        user.sayHi("张三");
    }
}

来看看五大类注解间的关系：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
这些注解⾥⾯都有⼀个注解 @Component，说明它们本身就是属于 @Component 的“⼦类”。
所以它们在使用上都差不多，那为什么还要分出 5 大类呢？
直接一个 @Component 就可以 存储 bean 对象了，还要分这么多有什么用呢？

其实是让程序员看到类注解之后，就能直接了解当前类的⽤途，比如我们看到一辆车的车牌号就知道它的归属地是哪，这个也一样。

程序的⼯程分层，调⽤流程如下：
在这里插入图片描述

方法注解（@Bean）

类注解是添加到某个类上的，⽽⽅法注解是放到某个⽅法上的：

Student 类：

//普通类
public class Student {
    private String name;
    private int id;
    private int score;

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

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

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

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
}

class 类：

//注意: 方法注解要配合五大类注解一起使用
//     该类也存储在 IoC 容器中
@Controller
public class Class {

    //使用方法注解, 将方法的返回值存储到 IoC 容器中
    @Bean
    public Student student() {
        Student student = new Student();
        student.setId(6);
        student.setName("张三");
        student.setScore(150);
        return student;
    }
}

获取 bean 对象：

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //注意：@Bean 默认命名是方法名
        // 也就是添加方法注解的那个方法名
        Student student = context.getBean("student", Student.class);
        System.out.println(student.toString());
    }
}

在这里插入图片描述
@Bean 还有几种重命名方式：

    @Bean("aaa")

    @Bean(value = "sss")

    @Bean(name = "nnn")

点入 @Bean ：

在这里插入图片描述
发现 name 和 value 效果是一样的。

除了取单个名称外，还可以取多个名称：

    @Bean(value = {"sss","888"})

    @Bean(name = {"sss","888"})

    @Bean({"sss","888"})

注意：

  1. 如果重命名了，那么获取 bean 对象时，默认的方法获取 bean 对象的方式就不能用了。
  2. 添加了 @Bean 注解的方法无法传参（方法的调用是程序在控制），也就不能重载。
  3. 如果多个 Bean 使用相同的名称，那么程序执行不会报错，但是第一个 Bean 后的对象不会被放到容器中，也就是只有第一次创建 Bean 的时候会将对应的 Bean 名称关联起来，后续再有相同名称的 Bean 存储的时候，容器会自动忽略。

获取 Bean 对象 (@Autowired)

获取 bean 对象也叫做对象装配，是把对象取出来放到某个类中，有时候也叫对象注⼊。

属性注入

属性注⼊是使⽤ @Autowired 实现的：

普通类 User：

public class User {
    private int id;
    private String 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;
    }

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

添加类注解的 UserService：

@Service
public class UserService {
    public User getUser(int id, String name) {
        User user = new User();
        user.setId(id);
        user.setName(name);
        return user;
    }
}

添加类注解的 UserController：

@Controller
public class UserController {

	//使用属性注入，将IoC容器中的UserService类型的对象
	//注入变量 userService中
    @Autowired
    private UserService userService;

    public User getUser(int id, String name) {
        return userService.getUser(id,name);
    }
}

注意：下面我们不使用 @Autowired 来进行依赖注入，因为 main 函数是静态方法，@Autowired 又不能给局部变量注入，那就只能放在类里面方法外面了，再加上 static 修饰 才能在 main 里访问，但可惜的是静态类属于方法的一部分，static 成员是不能使用 @Autowired 来注入。

public class Test {
    public static void main(String[] args) {
    	//依赖查找
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");
        UserController userController = context.getBean("userController", UserController.class);
        //检验是否得到了 UserController 类型对象
        System.out.println(userController.getUser(3,"张三").toString());
    }
}

在这里插入图片描述

依赖查找 VS 依赖注入
依赖查找：依赖 Bean 的名称来获取 Bean 对象。
依赖注入：通过注解 @Autowired 根据对象类型进行依赖注入，首先根据 getType 从容器中获取对象，如果 IoC 容器中只有一个该类型对象，则直接注入到当前属性上；如果容器中有多个该类型对象，则会使用 getName （根据名称）进行匹配。（具体体现如下）

多个同类型 Bean 注入怎么办？

问题：如若有多个同类型的 Bean 对象存储进 IoC 容器中，那么我们该如何准确获取该类型对象？

问题场景：

Users 类：

@Service
public class Users {

	//通过方法注解，添加两个同类型 bean
    @Bean("user1")
    public User user1() {
        User user = new User();
        user.setName("李四");
        user.setId(22);
        return user;
    }

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

UserService 类：

@Service
public class UserService {

	//对 user 进行属性注入
    @Autowired
    User user;

    public void add() {
    	//拿到 user 后打印内容，判断是哪个 user
        System.out.println(user.toString());
    }
}

Test 类：

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

看结果：
在这里插入图片描述
它是说期望有一个 bean 进行匹配，但出现了两个：user1、user2

解决问题：

  1. 将属性的名字和 Bean 的名字对应上。

就比如我要得到的是 王五 这个对象，那我只需要将下面两点的名称对应上即可：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  1. @Autowired 配合 @Qualifier 使用

这个就是在注入时，声明要注入的 bean 名称
在这里插入图片描述

属性注入分析：
优点： 使用简单
缺点：

  1. 无法注入 final 修饰的变量
  2. 只适用于 IoC 容器
  3. 容易违背单一设计原则

Setter 注入

我们写类属性时，可以对这些属性生成相应的 get 和 set 方法，Setter 注入就是针对 set 方法，进行的注入：

User 类：

@Service
public class Users {

        @Bean("user")
        public User getUser() {
            User user = new User();
            user.setName("老王");
            user.setId(26);
            return user;
        }
}

UserService 类：

@Service
public class UserService {

    private User user;

	//对类属性 user 进行 Setter 注入
    @Autowired
    public void setUser(User user) {
        this.user = user;
    }

    public void add() {
        System.out.println(user.toString());
    }
}

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

在这里插入图片描述

注意：@Autowired 不能省略

Setter 注入分析：
优点：通常 Setter 只是注入一个属性，所以 Setter 更符合单一设计原则。
缺点：

  1. 无法注入一个 final 修饰的变量
  2. Setter 注入的对象可以被修改。（setter 是一个方法，既然是方法就可能被多次调用和修改）

构造方法注入（官方推荐）

构造⽅法注⼊是在类的构造⽅法中实现注⼊，如下代码所示：

只对 UserService 进行修改：

@Service
public class UserService {

    private User user;
	
	//构造方法注入
    @Autowired
    public UserService(User user) {
        this.user = user;
    }

    public void add() {
        System.out.println(user.toString());
    }
}

注意：如果只有一个构造方法，不写 @Autowired 也可以，但若是有多个构造方法，就得加上 @Autowired，表明是哪个构造方法需要注入。

构造方法注入分析：
优点：

  1. 可以注入一个 final 修饰的变量
  2. 注入的变量不会被修改，因为构造方法只加载一次
  3. 构造方法注入可以保证注入对象完全初始化
  4. 构造方法注入通用性更好

缺点：

  1. 写法比属性注入更复杂
  2. 使用构造方法注入，无法解决循环依赖的问题

其实 @Resource 的功能和 @Autowired 差不多，那它俩有啥区别呢？

@Autowired 与 @Resource 的区别：

  1. 出生不同：@Resource 来自 JDK，@Autowired 来自 Spring 框架
  2. 支持参数不同：@Resource 支持很多参数设置，@Autowired 只支持一个参数设置
  3. 使用上的区别：@Resource 不支持构造方法注入，@Autowired 支持构造方法注入
  4. idea 兼容性支持不同：使用 @Autowired 在 idea 专业版下可能会误报，@Resource 不存在误报问题（@Resource 相当于是亲儿子了）

关于第四点：因为@Autowired 来自 Spring 框架，@Resource 来自 JDK，所以执行顺序有差异，Spring 框架的执行是在 java 程序执行之后的，当我们使用 @Autowired 时，它不能检测到 IoC 容器中是否有这个类型的 Bean，所以就报错（运行起来不影响结果）；使用 @Resource 的话，执行顺序是靠前的，它知道这个 Bean 是否存在。

随风的浪
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring中文API帮助文档
06-05
Spring框架是Java开发中最常用的开源框架之一，它以其强大的依赖注入（Dependency Injection，简称DI）和面向切面编程（Aspect-Oriented Programming，简称AOP）能力而闻名。Spring中文API帮助文档是针对Spring框架...
Spring入门操作代码，bean
08-20
然后，Spring容器可以通过XML配置或注解方式创建并初始化这个bean，当需要新增客户时，从容器中获取Customer bean实例，填充数据并调用相应的服务方法来保存到数据库。 客户信息查询：查询操作通常涉及到Spring的...
Spring启动后获取所有拥有特定注解的Bean实例代码
08-28
主要介绍了Spring启动后获取所有拥有特定注解的Bean实例代码，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
Spring中如何获取Bean方法上的自定义注解
徐小陌的博客
06-09 3941
Spring中获取Bean方法上的自定义注解引发的一些思考
注解详解系列 - @Repository：数据访问层组件
最新发布
算命de博客
06-19 769
在今天的注解详解系列中，我们将探讨注解。是Spring框架中的一个专用注解，用于标记数据访问层（DAO）组件。使用该注解可以让Spring自动检测和管理这些数据访问组件，并提供一致的异常处理机制。注解用于声明一个Spring数据访问层组件，使其成为Spring IoC容器管理的一个bean。// 数据访问方法，例如 CRUD 操作 }// 数据访问方法，例如 CRUD 操作 }// 数据访问方法，例如 CRUD 操作 }Repository;// 数据访问方法，例如 CRUD 操作在这个示例中，
【JavaEE】Spring中存储和获取Bean（使用注解）
p_fly的博客
04-16 1371
上篇文章的存储Bean是在Spring的配置文件下通过bean标签来把Bean存储到Spring容器中，其中需要设置标签属性id 和 name，还是比较麻烦的，接下来介绍一种更为简单也最为常用的方法来存储Bean。但是通过方法名获取通常是不使用的，我们可以在@Bean注解后重写命名，通过新名字来获取，同时。5. 该注解是把方法的返回值存入到Spring中，如果方法没有返回值，就不能使用该注解。这是JDK提供的注入Bean的注解，和@AutoWired有以下的区别。上述工作完成后就可以通过注解存储Bean。
spring 普通类 获取容器里面的bean。也支持获取 注解
weixin_34186950的博客
12-14 291
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring中存取Bean的相关注解
yss233333的博客
03-12 437
在Spring中存取Bean
Spring~五种存储Bean对象的类注解、方法注解(@Bean)以及Bean对象的获取
qq_58284486的博客
11-21 2360
@Configuration是将其注册为配置类对象，在项目启动时需要准备一些配置信息，一般通过配置类来初始化，其他类注解都是注册为普通的Bean对象，主要是在软件分层后，在不同的分层使用。@Component注解是组件存储，除了明确含义的类注解作用外，其他的作用就可以使用@Component来进行注解，其默认也是单例的方式注册Bean对象。@Repository注解是仓库存储，数据访问层，一般是数据库的操作，其默认也是单例的方式注册Bean对象。此时就只能通过@Bean注解的方法名来获取Bean对象。
非注解Springmvc+spring+hibernate 入门实例
12-29
为了整合SpringMVC、Spring和Hibernate，你需要在Spring的配置文件中引入Hibernate的相关配置，如数据源、SessionFactory以及事务管理器。同时，你还需要配置一个Hibernate的本地SessionFactory Bean，以便Spring...
spring mvc+ibatis+spring注解
05-18
这些注解能够帮助Spring自动检测和管理bean，例如，@Controller注解用于标记控制器类，@Transactional用于开启事务管理。 "Spring事务"是Spring框架提供的事务管理机制，它支持编程式事务管理和声明式事务管理。在...
Spring在代码中获取bean的几种方式详解
08-25
主要介绍了Spring在代码中获取bean的几种方式详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring中自定义注解(annotation)与AOP中获取注解
09-24
spring中自定义注解(annotation)与AOP中获取注解.通过实例演示自定义注解。
7、spring redis 注解开发 单片机 集群 主从复制1
08-08
在Spring Redis注解开发中，我们通常利用Spring Data Redis库来简化与Redis数据库的交互。以下是对标题和描述中涉及的知识点的详细说明： 1. **Spring Data Redis**：Spring Data Redis是Spring框架的一个模块，它...
Spring(三): 使用注解来存储和读取Bean对象
m0_60631323的博客
12-21 1073
Spring(三): 使用注解来存储和读取Bean对象
Spring中存取Bean对象的相关注解
qq_62592809的博客
11-13 432
这是程序员在设计的时候考虑到搜索的效率而设计的,只有通过注解标识了哪些路径,Spring才认为被标记的路径中有可能有要存到容器中的Bean对象,Spring才会去搜索那些被标记的路径,不必全部路径都搜索一遍,这样就提高了效率,所以如果只标记方法注解,而没有类注解,Spring是不会来搜索这个类的,就更别提搜索它里面的方法了.但是Bean还有个问题,就是不能存储带参数的方法,因为在存储Bean对象的时候,我们没办法手动给它传参,所以无法存储进去,如果要传参可能得配合其他标签让他在存储的时候自动传参.
SpringAop获取自定义注解
不积跬步无以至千里
07-01 282
aop实现角色权限拦截
Spring中存取Bean的注解
weixin_62988630的博客
11-14 1178
就引入了一个问题，在实际开发过程中，Tire类的构造函数不能确定，可能有颜色要求，长度要求等，所以一旦减少或增加，就需要改变之前的所有类中的代码。IoC：在构造每个类时，都不创建所依赖的对象，改用传递的方式，则只在Tire类·中构造对应的函数，达到了解耦的效果，所以如果要减少或者增加属性时，只需要修改Tire类即可。要想实现IoC，就得在相应类中注入所需要下一个类的对象，而不在本类中new该对象。依赖对象是在构造方法中执行的，而构造方法是在对象创建之初执行的，因此被注入的对象在使用之前，会被完全初始化。
【Spring】使用注解的方式获取Bean对象（对象装配）
m0_73067372的博客
08-06 1517
一、了解对象装配 1、属性注入 1.1、属性注入的优缺点分析 2、setter注入 2.1、setter注入的优缺点分析 3、构造方法注入 3.1、构造方法注入的优缺点 二、@Resource注解 三、综合练习
不通过注解的形式，使用java spring 实现缓存的存取
05-31
可以通过注入Spring框架提供的CacheManager来实现缓存的存取，具体步骤如下： 1. 配置CacheManager 在Spring配置文件中配置CacheManager，如下所示： ```xml <bean id="cacheManager" class="org.springframework...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

随风的浪

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

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

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

打赏作者

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

抵扣说明：

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

余额充值