您现在的位置是:首页 >学无止境 >@Autowired和@Resource注解之间的关系区别,Bean的作用域和生命周期,Spring的执行流程网站首页学无止境

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

PlLI- 2023-06-30 16:00:03
简介@Autowired和@Resource注解之间的关系区别,Bean的作用域和生命周期,Spring的执行流程

目录

一. @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");
    }
}

 

 

风语者!平时喜欢研究各种技术,目前在从事后端开发工作,热爱生活、热爱工作。