Spring高级49讲-第六讲：Aware接口

已于 2022-05-22 21:09:38 修改
阅读量689 收藏 1
点赞数
分类专栏： spring高级49讲 文章标签： spring java
于 2022-05-22 10:15:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52574640/article/details/124906884
版权

第六讲：Aware接口

1.Aware接口提供了一种【内置】的注入手段，可以注入BeanFactory，ApplicationContext

2.InitializingBean接口提供了一种【内置】的初始化手段

3.内置的注入和初始化不受扩展功能的影响，总会被执行。因此Spring框架内部的类常用它们

4.实战：@Aytiwired失效分析

一、Aware 接口及 InitializingBean 接口的作用

1. Aware 接口用于注入一些与容器相关信息, 例如
    a. BeanNameAware 注入 bean 的名字
    b. BeanFactoryAware 注入 BeanFactory 容器
    c. ApplicationContextAware 注入 ApplicationContext 容器
    d. EmbeddedValueResolverAware 注入解析器${}

2.InitializingBean 是用于完成初始化Bean

准备

package com.itheima.a06;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
import org.springframework.context.annotation.CommonAnnotationBeanPostProcessor;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;

/*
    Aware 接口及 InitializingBean 接口
 */
public class A06 {
    private static final Logger log = LoggerFactory.getLogger(A06.class);

    public static void main(String[] args) {
  
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean("myBean", MyBean.class);
        context.refresh(); 
        context.close();

       
    }
}


package com.itheima.a06;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

import javax.annotation.PostConstruct;

public class MyBean implements BeanNameAware, ApplicationContextAware, InitializingBean {

    private static final Logger log = LoggerFactory.getLogger(MyBean.class);
    //bean的名字
    @Override
    public void setBeanName(String name) {
        log.debug("当前bean " + this + " 名字叫:" + name);
    }
    //当前的容器
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        log.debug("当前bean " + this + " 容器是:" + applicationContext);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        log.debug("当前bean " + this + " 初始化");
    }


}

结果

    2. 有同学说: b、c、d 的功能用 @Autowired 就能实现啊, 为啥还要用 Aware 接口呢
    简单地说:
        a. @Autowired 的解析需要用到 bean 后处理器, 属于扩展功能
        b. 而 Aware 接口属于内置功能, 不加任何扩展, Spring 就能识别
    某些情况下, 扩展功能会失效, 而内置功能不会失效


 *

1.1: 你会发现用 Aware 注入 ApplicationContext 成功, 而 @Autowired 注入 ApplicationContext 失败 

package com.itheima.a06;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

import javax.annotation.PostConstruct;

public class MyBean implements BeanNameAware, ApplicationContextAware, InitializingBean {

    private static final Logger log = LoggerFactory.getLogger(MyBean.class);
    //bean的名字
    @Override
    public void setBeanName(String name) {
        log.debug("当前bean " + this + " 名字叫:" + name);
    }
    //当前的容器
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        log.debug("当前bean " + this + " 容器是:" + applicationContext);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        log.debug("当前bean " + this + " 初始化");
    }

    @Autowired
    public void aaa(ApplicationContext applicationContext) {
        log.debug("当前bean " + this + " 使用@Autowired 容器是:" + applicationContext);
    }

    @PostConstruct
    public void init() {
        log.debug("当前bean " + this + " 使用@PostConstruct 初始化");
    }
}

结果

我们发现这个 

你会发现用 Aware 注入 ApplicationContext 成功, 而 @Autowired 注入 ApplicationContext 失败 

那么加入后处理器结果会如何呢？

1.2 加入Bean后处理器

package com.itheima.a06;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
import org.springframework.context.annotation.CommonAnnotationBeanPostProcessor;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;

/*
    Aware 接口及 InitializingBean 接口
 */
public class A06 {
    private static final Logger log = LoggerFactory.getLogger(A06.class);

    public static void main(String[] args) {
    
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean(AutowiredAnnotationBeanPostProcessor.class);
        context.registerBean(CommonAnnotationBeanPostProcessor.class);
        context.registerBean("myBean", MyBean.class);


    }
}

得到结果

二、@Autowired失效分析

package com.itheima.a06;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
import org.springframework.context.annotation.CommonAnnotationBeanPostProcessor;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;

/*
    Aware 接口及 InitializingBean 接口
 */
public class A06 {
    private static final Logger log = LoggerFactory.getLogger(A06.class);

    public static void main(String[] args) {
     
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean("myConfig1", MyConfig1.class);
        context.registerBean(AutowiredAnnotationBeanPostProcessor.class);
        context.registerBean(CommonAnnotationBeanPostProcessor.class);
        context.registerBean(ConfigurationClassPostProcessor.class);


        context.refresh(); 
        context.close();

      
    }
}

package com.itheima.a06;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

@Configuration
public class MyConfig1 {

    private static final Logger log = LoggerFactory.getLogger(MyConfig1.class);

    @Autowired
    public void setApplicationContext(ApplicationContext applicationContext) {
        log.debug("注入 ApplicationContext");
    }

    @PostConstruct
    public void init() {
        log.debug("初始化");
    }



}

 得到结果

现在我们的注解是生效的 

当我们在配置类中加入BeanFactoryPostProcessor的时候注解就失效了

 

package com.itheima.a06;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

@Configuration
public class MyConfig1 {

    private static final Logger log = LoggerFactory.getLogger(MyConfig1.class);

    @Autowired
    public void setApplicationContext(ApplicationContext applicationContext) {
        log.debug("注入 ApplicationContext");
    }

    @PostConstruct
    public void init() {
        log.debug("初始化");
    }

    @Bean  //添加一个beanFactory的后处理器
    public  BeanFactoryPostProcessor processor1(){
        return  configurableListableBeanFactory -> {
            log.debug("执行processor1");
        };
    }



}

得到结果

 

 

 分析原因

Java 配置类不包含 BeanFactoryPostProcessor 的情况

Java 配置类包含 BeanFactoryPostProcessor 的情况，因此要创建其中的 BeanFactoryPostProcessor 必须提前创建 Java 配置类，而此时的 BeanPostProcessor 还未准备好，导致 @Autowired 等注解失效  

解决方案是：

 由于bean的后处理器还没有准备好，因此我们使用Aware内置接口来实现，接口是不受影响的 

代码
 

package com.itheima.a06;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfig2 implements InitializingBean, ApplicationContextAware {

    private static final Logger log = LoggerFactory.getLogger(MyConfig2.class);

    @Override
    public void afterPropertiesSet() throws Exception {
        log.debug("初始化");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        log.debug("注入 ApplicationContext");
    }

    @Bean //  beanFactory 后处理器
    public BeanFactoryPostProcessor processor2() {
        return beanFactory -> {
            log.debug("执行 processor2");
        };
    }
}

package com.itheima.a06;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
import org.springframework.context.annotation.CommonAnnotationBeanPostProcessor;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;

/*
    Aware 接口及 InitializingBean 接口
 */
public class A06 {
    private static final Logger l阿og = LoggerFactory.getLogger(A06.class);

    public static void main(String[] args) {
     
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean("myConfig2", MyConfig2.class);
        context.registerBean(AutowiredAnnotationBeanPostProcessor.class);
        context.registerBean(CommonAnnotationBeanPostProcessor.class);
        context.registerBean(ConfigurationClassPostProcessor.class);

        //refresh的执行顺序
// 1. beanFactory 后处理器,  2. 添加 bean 后处理器, 3. 初始化单例
        context.refresh();
        context.close();

 
    }
}

 结果

 总结

学到了什么
    a. Aware 接口提供了一种【内置】 的注入手段, 可以注入 BeanFactory, ApplicationContext
    b. InitializingBean 接口提供了一种【内置】的初始化手段
    c. 内置的注入和初始化不受扩展功能的影响, 总会被执行, 因此 Spring 框架内部的类常用它们
Tokey_W
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
QoS-Aware Automatic Service Composition: A Graph View
02-21
In the research of service composition, it demands efficient algorithms that not only retrieve correct service compositions automatically from thousands of services but also satisfy the quality ...
Spring Aware标记接口使用案例解析
08-19
Spring Aware 标记接口使用案例解析 Spring Aware 标记接口是 Spring 框架中的一种机制，用于让 Bean 对象感知 Spring 容器的存在，以便在 Bean 对象中使用 Spring 容器提供的功能。Aware 接口是一个标记接口，表示...
Spring的Aware接口有什么用？
浪丶荡
05-17 3533
ioc容器里面的对象分两种，一种是用户自定义对象，一种是容器对象 Aware 接口可以理解为用来获取某些容器对象的方法 例如一个普通的Bean对象，需要用到BeanFactory，可以这样做 @Component public class MyAware implements BeanFactoryAware { BeanFactory beanFactory; @Override public void setBeanFactory(BeanFactory beanFactory)
Spring Aware接口作用及原理
lishuzhen5678的博客
01-29 2175
前言 在Spring中有一个及其底层且名字很熟悉的接口Aware，如常见的BeanNameAware、Applicatio...
Spring框架Aware接口的作用和应用
最新发布
龙吟山庄
05-06 843
实现该接口的 Bean 可以在初始化时获取 Spring 的 Environment 环境对象，从而获取配置文件中的属性值、系统属性、环境变量等，Bean 可以根据不同的环境进行相应的逻辑处理，例如根据配置文件中的属性值决定 Bean 的行为，或者根据环境变量来动态调整 Bean 的配置等，使 Bean 在不同的环境下具有更灵活的适应性和可配置性。实现该接口的 Bean 可以在初始化时获取资源加载器ResourceLoader对象，用于加载各种资源，例如文件、URL、类路径等，实现更灵活的资源管理和处理。
【Java】Spring中Aware接口的作用
要继续努力的孤独的博客
01-08 1534
学习spring的笔记
Spring之Aware接口介绍
波波烤鸭的博客
03-03 8046
Spring 中的Aware接口详解
Spring原理学习（四）Aware 接口
小鲁蛋的博客
11-03 4440
Java 配置类包含 BeanFactoryPostProcessor 的情况，因此要创建其中的 BeanFactoryPostProcessor 必须提前创建 Java 配置类，而此时的 BeanPostProcessor 还未准备好，导致 @Autowired 等注解失效。例如下面这个例子：你会发现用 Aware 注入 ApplicationContext 成功，而 @Autowired 注入 ApplicationContext 失败要想生效就得加处理器。配置类MyConfig1。
Dual-Attentive-Tree-aware-Embedding:日期
05-28
日期：用于海关欺诈检测的双注意树嵌入 我们的KDD论文。 DATE是对非法贸易流进行分类和排名的模型，这些非法贸易流在被捕获时对整体海关收入的贡献最大。 DATE结合了基于树的可解释性模型和具有双重关注机制的...
matlab图像去模糊源码-depth-aware-motion-deblurring:来自https://square-src.de/git
05-19
第二遍是不可能的，因为视差图没有细化，但降级了。 代码结构 运动去模糊包含深度感知运动去模糊算法以及视差估计，区域树和边缘图实现。 顶层PSF估算无效（请参阅二手的两阶段内核估算），因此有一种解决方法。 ...
react-native-keyboard-aware-scrollview:由artald创建
05-02
react-native-keyboard-aware-scrollview 一个帮助程序组件，用于替代RN ScrollView，该组件在显示或隐藏键盘时可以正确处理ScrollView插入，以便所有内容都可滚动并可供用户使用。 安装 使用npm安装： npm i ...
Spring特性——Aware感知特性
08-11
NULL 博文链接：https://ylxy3058.iteye.com/blog/2225314
Spring中的以Aware结尾的接口是做什么的？
m0_54187478的博客
01-26 625
接口是Spring框架中的一部分，用于实现框架的依赖注入和控制反转（IoC）原则。它们允许beans与Spring框架的底层服务进行交互，而无需将框架代码硬编码到beans中，从而使得代码更加清晰、解耦合，并提高了可维护性。结尾的接口主要用于提供一种机制，允许Spring管理的beans获得对Spring容器的某些特定功能的访问权。当一个bean实现了这些。接口之一时，它能够获得对容器的某些资源或信息的访问，这通常涉及到一些容器的内部工作。在Spring框架中，以。
聊聊Spring的Aware接口
日拱一卒无有尽，功不唐捐终入海
09-19 672
背景： 最近有开发同学问我项目里面有很多地方实现了Aware 接口，到底是什么作用。他说这个原因是在我们的工程代码中看到有一些代码里实现了ResourceLoaderAware、BeanNameAware、ApplicationContextAware、BeanFactoryAware接口。我没法直接笼统回答，也没有法一句话简答，只好侧面的告诉他Aware接口是Spring 为了提供拓展的一种设计思想。凡是带Aware后缀的接口。主要作用是为了让实现了该接口的Bean在Spring容器中具有回调功能。
spring aware的使用；spring aware 各种接口的作用解析
boss_way的博客
10-28 2074
spring aware的使用： 使用了spring Aware 你的bean将会和spring 框架耦合， spring aware 的目的是为了让bean 获取spring容器的服务：   spring 提供的aware的接口： BeanNameAware ：可以获取容器中bean 的名称 BeanFactoryAware:获取当前bean factory 这也可以调用
spring之Aware接口
wujun2412的博客
03-11 4244
Aware接口介绍
Spring中的Aware接口及应用场景
Java技术攻略的博客
05-06 544
Aware接口是Spring Framework中提供的一组标记接口，用于在Bean装配的过程中获取Spring容器中提供的一些核心组件或运行时上下文等信息。通过使用Aware接口，我们可以在Bean实例化和初始化过程中获取到Spring容器中其他组件，方便Bean类实现更复杂的业务逻辑。本文将会一一介绍Spring中各个Aware接口，以及这些接口的主要应用场景。
Spring中的Aware作用以及源码
959
10-03 1129
文章目录1.源码2.Aware调用链3.initializeBean 初始化Bean 在有些场景中我们需要感知到容器的存在，需要获取容器的工具类，这个时候需要使用Spring Aware提供的工具类 Spring 框架中提供许多实现Aware接口的类，这些类主要是为了辅助Spring访问容器中的数据 1.源码 自定义实现ApplicationContextAware接口类，然后在setApplicationContext方法打断点，debug模式下查看堆栈信息 2.Aware调用链 createBe
Spring框架中的各种*Aware接口
成长的足迹
03-29 7225
Spring框架提供了多个*Aware接口，用于辅助Spring Bean以编程的方式调用Spring容器。通过实现这些接口，可以增强Spring Bean的功能，但是也会造成对Spring容器的绑定。org.springframework.context.ApplicationContextAware接口Spring框架启动时，ApplicationContext初始化实现了该接口的Spring...
on content-aware post-processing: adapting statistically learned models
04-30
内容感知后处理：适应统计学习模型，是一种通过应用统计学习模型来调整数字图像和视频的技术。该方法是一种自适应技术，可以快速识别图像或视频中的不希望的区域，并将其进行后处理，达到更佳的视觉效果。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值