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

置顶 PlLI-

已于 2024-03-03 13:37:02 修改

阅读量3k

点赞数 3

文章标签： spring java mybatis

于 2023-04-30 18:41:01 首次发布

本文链接：https://blog.csdn.net/weixin_69417428/article/details/130447772

版权

一. @Autowired 和 @Resource 注解

二. Bean的作用域

1. singleton(单例模式)

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

一. @Autowired 和 @Resource 注解

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

@Resource 来自于 jdk，而 @Autowired 来自于 Spring；
使⽤时设置的参数不同：相⽐于 @Autowired 来说，@Resource ⽀持更多的参数设置，例如

name 设置，根据名称获取 Bean；
@Autowired 可⽤于 Setter 注⼊、构造函数注⼊和属性注⼊，⽽ @Resource 只能⽤于 Setter 注⼊和属性注⼊，不能⽤于构造函数注⼊；
@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
评论
@Autowired和@Resource注解之间的关系区别，Bean的作用域和生命周期，Spring的执行流程

讲解@Autowired和@Resource之间的区别联系，Bean的生命周期和作用域，以及Spring的执行过程
复制链接

扫一扫