@Autowired和@Resource注解之间的关系区别，Bean的作用域和生命周期，Spring的执行流程

置顶 已于 2024-03-03 13:37:02 修改
阅读量3k 收藏 15
点赞数 3
文章标签： spring java mybatis
于 2023-04-30 18:41:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_69417428/article/details/130447772
版权

目录

一. @Autowired 和 @Resource 注解

二. Bean的作用域 

1. singleton(单例模式)

2. prototype(原型模式)(多例模式)

3. 请求作用域：request

4. 会话作用域：session

三. Spring 的执行流程

四. Bean 的生命周期 

 1. 实例化

 2. 设置属性 

3. Bean 初始化  

   3.1 执行各种各种 Aware 通知； 

   3.2 执行初始化前置方法；

   3.3 执行初始化方法；

   3.4 执行初始化后置方法； 

4. 使用 Bean 对象

5. 销毁 Bean 对象 

6. 代码演示 

一. @Autowired 和 @Resource 注解

在前面的文章中，我们介绍了通过 @Autowired 注解的方式来获取到Spring容器中的Bean对象，实际上，还有另一个注解：@Resource，它的功能也是差不多的，也可以从 Spring容器中获取到Bean对象，但也是存在一定的差别的。 

  1. @Resource 来自于 jdk，而 @Autowired 来自于 Spring；
  2. 使⽤时设置的参数不同：相⽐于 @Autowired 来说，@Resource ⽀持更多的参数设置，例如
    name 设置，根据名称获取 Bean；
  3. @Autowired 可⽤于 Setter 注⼊、构造函数注⼊和属性注⼊，⽽ @Resource 只能⽤于 Setter 注⼊和属性注⼊，不能⽤于构造函数注⼊；
  4. @Autowired在获取Bean对象的时候，先根据类型查找，之后再根据名称查找；而@Resource先根据名称查找，之后再根据类型查找；

问题分析：当在 Spring 中存放多个同一类型 Bean 对象的时候，使用 @Autowired 去获取 Bean对象会出错。

@Component
public class UserBeans {
    @Bean
    public User user1(){
        User user = new User();
        user.setAge(20);
        user.setId(1);
        user.setName("张三");
        return user;
    }

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

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

    public void sayHi(){
        System.out.println("do UserController2");
        System.out.println(user.getName());
    }
}


public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
    UserController2 userController2 = context.getBean("userController2",UserController2.class);
        userController2.sayHi();
    }
}

此时执行是会报错的，因为 @Autowired 注解先通过类型去查找，得到了 user1 和 user2 两个 Bean对象，但是根据 user 名称来去查找的话，是没有找到对应的 Bean 对象的，因此会报错。(查找 Bean 对象的默认名称为 添加 @Autowired 注解的对应属性名称，也就是上述第二段代码的private User user) 

 解决办法1：修改 @Autowired 注解的对应属性名称

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

    public void sayHi(){
        System.out.println("do UserController2");
        System.out.println(user1.getName());
    }
}

此时运行代码就会获取到对应的 Bean对象，也就是存储的 user1 对象。

解决办法2：配合使⽤ @Qualifier 注解定义名称

@Qualifier(value = "Bean对象的名称") 

@Controller
public class UserController2 {
    @Autowired
    @Qualifier(value="user1")
    private User user;

    public void sayHi(){
        System.out.println("do UserController2");
        System.out.println(user.getName());
    }
}

也可以得到预期的结果。 

 

解决办法3：使⽤ @Resource(name="Bean对象名称") 定义

@Controller
public class UserController2 {
    
    @Resource(name="user1")
    private User user;

    public void sayHi(){
        System.out.println("do UserController2");
        System.out.println(user.getName());
    }
}

 同样是可以得到预期结果的。

二. Bean的作用域 

限定程序中变量的可⽤范围叫做作用域，或者说在源代码中定义变量的某个区域就叫做作用域。而 Bean 的作⽤域是指 Bean 在 Spring 整个框架中的某种行为模式。

1. singleton(单例模式)

singleton 表示的是单例作用域，类似于之前讲过的单例模式。这也是默认情况下的行为模式。在该作用域下的 Bean 在 IoC容器中只存在一个实例，获取到的 Bean 以及对 Bean 进行修改，都是针对同一个 Bean 对象。

代码演示： 

1. 往 Spring 容器中注入一个 User 对象 

@Component
public class UserBeans {
    @Bean
    public User user(){
        User user = new User();
        user.setId(1);
        user.setName("张三");
        return user;
    }
}

2.  通过@Autowired获取到Bean对象，并对其进行修改

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

    public void printUser(){
        System.out.println(user);
        // 修改 User
        User myUser = user;     // 给引用对象赋值，其实就是共享对象！！！这两个变量指向了同一个地址
        myUser.setName("李四");
        System.out.println("myUser -> " + myUser);
        System.out.println("User -> " + user);  
    }
}

3. 再新建一个类，通过 @Autowired 获取到Bean对象 


@Controller
public class UserController2 {

    @Resource
    private User user;

    public void printUser2(){
        System.out.println("user -> " + user);  
        // Bean 作用域 -> 默认是单例模式 = 此 Bean 在整个框架（Spring 容器）中只有一份
    }
}

 4. 最后输出观察结果


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

        UserController userController = context.getBean("userController",UserController.class);
        userController.printUser();

        UserController2 userController2 = context.getBean("userController2",UserController2.class);
        userController2.printUser2();

    }
}

因此也可以得出结论：singleton 单例作用域，他们使用的 Bean 都是 Spring 容器中的同一个对象。这个 Bean 在整个 Spring 中只有一份，是全局共享的，当其他人修改了这个值之后，那么另一个人读到的就是被修改后的值了。

2. prototype(原型模式)(多例模式)

 在原型模式下，每次对该作用域下的 Bean 的请求都会创建新的实例，也就是说每次获取 Bean 对象和修改 Bean 对象都是针对新的 Bean 对象实例而言的。

需要添加注解 @Scope("prototype") 或者@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

代码演示： 

@Component
public class UserBeans {
    @Bean
    @Scope("prototype")
    //@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public User user(){
        User user = new User();
        user.setId(1);
        user.setName("张三");
        return user;
    }
}

 再次运行得到结果：

可以看出，在第二次通过 @Autowired 获取到 Bean 对象的时候，得到的是一个新的实例对象了。

3. 请求作用域：request

 每次 http 请求会创建新的 Bean 实例。适用于⼀次 http 的请求和响应的共享 Bean 的情况。

 限定SpringMVC中使⽤。

4. 会话作用域：session

在⼀个http session中，定义⼀个 Bean 实例。每次 Session 会话共享一个 Bean 对象。限定SpringMVC中使⽤。

三. Spring 的执行流程

 

四. Bean 的生命周期 

 1. 实例化

给 Bean 对象分配内存空间。 

此处要注意：初始化不等于实例化！！！

类的初始化是完成程序前的准备工作，在这个阶段，静态的会被执行，同时会开辟一块存储空间用来存放静态的数据，给对象的属性值赋值，调用初始化方法，初始化只在类加载的时候执行一次，也可以理解为给对象赋值的过程。

类的实例化，是指创建一个对象的过程，这个过程会在堆中开辟内存，将一些非静态的方法，变量存放在里面，属性值是默认值，在程序执行的过程中，可以创建多个对象，即多次实例化，每次实例化都会开辟一块新的内存。 

 2. 设置属性 

看需求，有的 Bean 对象需要被注入属性，这个属性也会是已经在 Spring 容器中的 Bean，如果该属性还不存在于 Spring 中，那么会先去将该属性 Bean 存储到 Spring 中。 

3. Bean 初始化  

   3.1 执行各种各种 Aware 通知； 

实现了各种 Aware 通知的⽅法，如 BeanNameAware、BeanFactoryAware、
ApplicationContextAware 的接⼝⽅法；

   3.2 执行初始化前置方法；

   3.3 执行初始化方法；

有两种方式，第一种是通过注解 @PostConstruct ，依赖注⼊操作之后执行注解修饰的方法；第二种是通过 xml 的方式，执行自己指定的 init-method ⽅法。如果两者都存在，那么先执行注解的初始化方法。

   3.4 执行初始化后置方法； 

4. 使用 Bean 对象

通过 getBean() 方法来获取容器中的 Bean 对象并使用。 

5. 销毁 Bean 对象 

销毁容器的各种⽅法，如 @PreDestroy、DisposableBean 接⼝⽅法、destroy-method(XML的方式)。  

6. 代码演示 

public class App {
    public static void main(String[] args) {
// 此时要使用 ApplicationContext 的子类，因为它本身是没有销毁方法的
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        BeanComponent beanComponent = context.getBean("beanComponent",BeanComponent.class);
        beanComponent.sayHi();
        context.close();
    }
}


public class BeanComponent implements BeanNameAware {
    @Override
    public void setBeanName(String s) {
        System.out.println("执行了通知 BeanName -> " + s);
    }

    /**
     * xml 方式的初始化方法
     */
    public void myInit(){
        System.out.println("XML 方式初始化");
    }


    @PostConstruct
    public void doPostConstruct(){
        System.out.println("注解的初始化方法");
    }

    public void sayHi(){
        System.out.println("执行 sayHi()");
    }

    // 销毁的方法，销毁的时候执行的一个方法
    @PreDestroy
    public void doPreDestroy(){
        System.out.println("do PreDestroy");
    }
}

 

PlLI-
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
（转）Spring中@Autowired注解和@Resource注解的区别
08-11
NULL 博文链接：https://forestqqqq.iteye.com/blog/2235292
基于注解的组件扫描详解
08-28
组件的作用域是指组件的生命周期。Spring 框架提供了多种作用域，例如 singleton、prototype 等。可以使用 @Scope 注解来指定组件的作用域，例如： @Scope("prototype") @Repository public class OracleUserDao ...
@Autowired 和 @Resource
qq_40813329的博客
04-01 2974
定义 @Autowired 对类成员变量、方法及构造函数进行标注，完成自动装配的工作 @Resource 在语义上被定义为通过其唯一的名称来标识特定的目标组件，其中声明的类型与匹配过程无关 如果没有明确指定名称，则默认名称是从字段名称或设置方法（get、set方法）派生的。 如果用在字段上，则采用字段名称 如果用在在setter方法，它采用其属性名称（例如setProperty()方法，取property做为属性名称)。 区别 在Spring框架中，如果在Service层中需要注入其他依赖的对象，通常
Java | Spring框架 | @Autowired与@Resource
最新发布
yingzix688的博客
05-08 826
本文主要分享 1. @Autowired与@Resource 2. AI+编程实践玩法(文章底部)
SpringBoot注解篇之@Resource与@Autowired
weixin_36808034的博客
10-12 3370
大家好，我是AK，最近在整理Java相关技术知识体系化；本篇主要介绍@Resource 注解和 @Autowired的区别以及使用，适合学习spring框架小伙伴了解学习。
@Autowired和@Resource区别
qq_40263124的博客
04-17 7431
@Autowired和@Resource区别
Spring中@Autowired注解、@Resource注解的区别
Baple的专栏
11-18 1478
【转自】 http://www.chinasb.org/archives/2011/06/2443.shtml Spring不但支持自己定义的@Autowired注解，还支持几个由JSR-250规范定义的注解，它们分别是@Resource、@PostConstruct以及@PreDestroy。 　　@Resource的作用相当于@Autowired，只不过@Autowired按byT
Autowired & Resource注解一站式彻底搞懂
qq_36851469的博客
10-18 161
可以使得类InstantiationAwareBeanPostProcessorAdapter选择性实现接口部分抽象方法。没有实现的接口方法，其子类必须实现。
简单了解spring bean的循环引用
08-25
在Spring框架中，Bean的循环引用（Circular Dependency）是指两个或多个Bean之间存在相互依赖的关系，导致Spring在实例化Bean时陷入死循环。这种问题如果不妥善处理，将导致应用程序无法正常启动。本篇文章将深入...
Spring注解驱动开发实战-annotation
02-16
在Spring中，我们可以使用注解来控制Bean的生命周期。@PostConstruct和@PreDestroy注解分别表示在Bean初始化后和销毁前执行的方法。例如： ```java @Service public class UserService { @PostConstruct public ...
Spring中常用注解的详细介绍
10-20
10. **@PostConstruct**和**@PreDestroy**：这两个注解分别标记在初始化和销毁方法上，用于在Bean生命周期中的特定阶段执行代码。 总的来说，Spring的注解大大简化了配置和代码，提高了可读性和可维护性。理解并...
spring系列笔记之常用注解
08-26
了解注解的元注解，如`@Target`, `@Retention`, 和 `@Documented`，有助于深入理解注解的工作原理和生命周期。`@Target`定义了注解可以应用于哪些元素类型，`@Retention`决定了注解在运行时是否可见，`@Documented`...
Spring 依赖注入方式及@Autowired 和 @Resource
cristianoxm的博客
08-31 1760
任何人都可以提交 JSR给 Java 官方，但只有最终确定的 JSR，才会以 JSR-XXX 的格式发布，如 JSR-250，而被发布的 JSR 就可以看作是 Java 语言的规范或标准。构造方法和属性注入不同，构造方法注入可适用于任何环境，无论是 IoC 框架还是非 IoC 框架，构造方法注入的代码都是通用的，所以它的通用性更好。因为依赖对象是在构造方法中执行的，而构造方法是在对象创建之初执行的，因此被注入的对象在使用之前，会被完全初始化，这也是构造方法注入的优点之一。...
Spring——依赖注入DI
Galip的博客
12-27 724
依赖注入（DI） 依赖注入（Dependency Injection,DI）。 依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 . 注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 . 构造器注入 我们在之前的案例4已经详细讲过了 settet注入 (重点) 要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属...
Resource 与 Autowired的区别
02-18 3457
目前有两种注解方式实现在一个类中实现依赖注入，@Resource 和 @Autowired 目前网上资料关于这两者的区别有如下几点： 1、来源不同 Resource注解是由javax.annotation.Resource，不是spring框架的，而Autowired由spring所提供，其位于org.springframework.beans.factory.annotation.Autowired 2、支持装配类型不同 Autowired只能按照类型进行装配，而Reso...
深入理解@Resource与@Autowired：用法与区别解析
那仰望的人，心底的孤独和叹息
01-27 764
@Resource和@Autowired区别和使用详解，用哪一个好？@Resource 是Java EE提供的注解。@Autowired是Spring框架提供的注解。总结：对于使用 Spring Boot 项目，通常建议优先使用 @Autowired 注解。因为 Spring Boot 默认集成了 Spring 框架，并做了一些自动配置，@Autowired 可以更好地适应和利用 Spring Boot 的特性。此外，@Autowired 的语义也更加清晰和直观。
@Autowired 与@Resource的区别(通俗易懂)
热门推荐
行者彡的博客
09-17 1万+
@Autowired 与@Resource的区别： 1、@Autowired与@Resource都可以用来装配bean. 都可以写在字段上,或写在setter方法上。 2、@Autowired默认按类型装配（这个注解是属业spring的），默认情况下必须要求依赖对象必须存在，如果要允许null值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用 3、@Resource（这个...
Spring——@Autowired和@Resource 的区别
生命不息，奋斗不止
10-07 294
@Autowired 默认是按照bytype进行注入的，如果发现找到多个bean，则再按照byname的方式查找，如果还有多个，抛出异常 //example： @Autowired private UserService userService ; spring先找类型为 Userservice 的bean； 如果存在且唯一，结束； 如果不唯一，找name为 userser...
Spring中@Resource和@Autowire的区别
渣渣想逆袭
03-27 1万+
1、@Autowired @Autowired默认byType自动注入，如果实例结果不唯一，那么将会抛出异常 @Autowired可与@Qualifier("beanName")搭配使用,注入指定bean。 @Autowired @Qualifier("baseDao") private BaseDao baseDao; 如，同一个接口，两个实现类，就可以使用该方式指定注入。 @Au...
@autowired注解和@resource注解区别
07-23
`@Autowired`和`@Resource`注解都是用于实现依赖注入的，但它们有一些区别： 1. 来源：`@Autowired`是Spring框架提供的注解，而`@Resource`是Java EE标准的注解。 2. 注入方式：`@Autowired`默认按照byType的方式进行装配，即根据类型来自动注入依赖对象。如果有多个匹配的bean，可以使用`@Qualifier`注解指定具体的bean。而`@Resource`默认按照byName的方式进行装配，即根据名称来自动注入依赖对象。如果没有指定name属性，则会根据字段或方法名进行匹配。 3. 兼容性：`@Autowired`是Spring框架特有的注解，与Spring相关的功能更加强大和灵活。而`@Resource`是Java EE标准的注解，可以在任何Java EE容器中使用。 4. 需要导入的包：`@Autowired`需要导入`org.springframework.beans.factory.annotation.Autowired`包，而`@Resource`需要导入`javax.annotation.Resource`包。 总体来说，`@Autowired`注解更加常用和灵活，适用于Spring项目；而`@Resource`注解则是Java EE标准的一部分，适用于Java EE容器。在实际使用中，可以根据需要选择合适的注解来实现依赖注入。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

PlLI-

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

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

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

打赏作者

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

抵扣说明：

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

余额充值