way-to-architect
  • 前言
  • Java
    • Java关键字
      • Java中四种修饰符的限制范围
      • static和final
    • 容器
      • 容器概述
        • 容器:综述
        • Iterator原理及实现
        • fast-fail机制
        • 比较器Comparator
        • Collections工具类
      • List
        • List综述
        • ArrayList原理分析
        • ArrayList在循环过程中删除元素的问题
        • 常用的小技巧
        • CopyOnWrite
      • Set
        • Set综述
        • HashSet
        • LinkedHashSet
        • TreeSet
      • Queue
        • Queue综述
        • ArrayBlockingQueue实现原理
        • LinkedBlockingQueue实现原理
        • 高性能无锁队列Disruptor
      • Map
        • Map综述
        • HashMap
          • HashMap实现原理
          • HashMap中的位运算
          • HashMap其他问题
        • LinkedHashMap
        • TreeMap
        • ConcurrentHashMap
          • ConcurrentHashMap实现原理JDK1.7
          • ConcurrentHashMap实现原理JDK1.8
        • ConcurrentSkipListMap
        • Map中key和value的null的问题
    • 线程
      • 线程
        • 创建线程
        • 线程状态及切换
        • 线程中断的理解
        • 几种方法的解释
        • 用户线程与守护线程
        • 线程组ThreadGroup
      • 线程池
        • 线程池工作原理及创建
        • Executor
        • 如何确保同一属性的任务被同一线程执行
      • ThreadLocal
        • ThreadLocal原理
        • ThreadLocal之父子线程传值
        • InheritableThreadLocal
      • 同步与锁
        • 线程安全与锁优化
        • synchronize关键字
        • Lock
          • 队列同步器
            • 同步状态的获取与释放
            • 使用方式
            • 示例:Mutex
            • 示例:TwinsLock
          • 重入锁和读写锁
          • LockSupport
          • Condition
          • 并发工具类
        • CAS
          • CAS的理解
          • Java中原子操作类
        • 3个经典同步问题
      • fork/join的理解
    • I/O
      • I/O概述
        • 磁盘I/O与网络I/O
        • 主要接口
        • 输入流和输出流的使用示例
        • InputStream的重复读
        • BufferdxxxxStream
        • Serailizable
        • File常用方法
        • Files和Path
        • RandomAccessFile
        • 通过零拷贝实现有效数据传输
        • 正确地处理文件
      • NIO基础
      • NIO2
      • Netty
        • Java I/O的演进之路
        • 为什么是Netty
        • 更多
      • I/O调优
    • 异常
      • 异常体系及为什么要有这种异常设计
      • 多catch的执行情况
      • try catch finally 与reture
      • 异常处理的误区
      • Preconditions:方法入参校验工具
    • 枚举
      • 常见用法
      • 枚举类在序列化中的问题
    • 注解
      • 概述
      • Spring中的组合注解的条件注解
      • 常用注解
        • JSR-330标准注解
    • 反射
      • 概述
      • 内部类的反射
      • 反射中需要注意的地方
    • 流程控制
      • switch case without break
      • Java: for(;;) vs. while(true)
    • JVM
      • JVM内存结构
      • Java内存模型
      • 垃圾收集器和内存分配策略
      • 四种引用类型区别及何时回收
      • 类文件结构
      • 类初始化顺序
      • 类加载机制
      • 虚拟机执行引擎
      • 逃逸分析
      • JVM常用配置
      • GC日志分析
      • Java8 JVM 参数解读
      • 垃圾收集器和内存分配策略
    • 面向对象
      • Object类中的方法
      • Class类中的方法
      • 值传递还是引用传递?
      • 接口和抽象类的区别
      • 深拷贝和浅拷贝
      • Integer.parseInt()与Interger.valueof()
      • hashCode()与equal()
      • String
        • String池化及intern()方法的作用
        • 关于字符串
    • 序列化
      • Java序列化的方式有哪些?
    • 新特性
      • 流 Stream
        • Stream是什么
        • Stream API详解
        • Stream进阶
        • 流编程
        • 其他事项
      • lambda表达式
      • 默认方法(Default Methods)
      • @FunctionalInterface注解
    • SPI
      • 理解SPI
    • 字节码
      • javaagent
      • 字节码操纵
      • 如何查看类编译后的字节码指令
      • 字节码指令有哪些
  • Python
    • 异常处理
  • Go
  • 数据结构与算法
    • 数据结构
      • 概述
        • 线性表
        • 栈
        • 队列
        • 串
        • 树
        • 图
      • Java的一些实现
      • 红黑树
      • 双缓冲队列
      • 跳表SkipList
    • 算法
      • 概述
      • 常见算法
        • 基本排序
        • 高级排序
        • 动态规划
  • 框架或工具
    • Spring
      • Spring基础
        • Spring整体架构
        • 什么是IoC
        • Ioc容器的基本实现
        • Spring的MainClass
          • Spring的BeanFactory
          • Spring的Register
          • Spring的Resource和ResourceLoader
          • Spring的PropertySource
          • Spring的PropertyResolver
          • Spring的PropertyEditor
          • Spring的Convert
          • Spring的BeanDefinition
          • Spring的BeanDefinitionReader
          • Spring的BeanDefiniton其他Reader
          • Spring的BeanDefinition其他Reader2
          • Spring的Aware
          • Spring的BeanFctoryPostProcessor
          • Spring的BeanPostProcessor
          • Spring的Listener
        • Xml格式的应用启动
          • Xml格式的应用启动2
          • Xml格式的应用启动3
          • Xml格式的应用启动4
          • Xml格式的应用启动5
          • Xml格式的应用启动6
          • Xml格式的应用启动7
        • Spring中的设计模式
        • 什么是AOP
        • Spring中AOP的实现
      • Spring应用
        • Spring的事务控制
        • @Transactional注解在什么情况下会失效
        • 如何在数据库事务提交成功后进行异步操作
        • Spring中定时任务的原理
    • SpringMVC
      • Controller是如何将参数和前端传来的数据一一对应的
      • 请求处理流程
    • Zookeeper
      • Zookeeper是什么
      • Zookeeper能干啥
    • Shiro
    • druid
    • Netty
    • Consul
      • Consul是什么
    • etcd
    • confd
    • Akka
      • Actor模型是什么
  • 数据库
    • 基本概念
    • MySQL
      • 基本配置
      • MySQL数据类型
      • MySQL存储引擎
      • MySQL事务
        • MySQL事务概念
      • MySQL索引
        • MySQL中的索引类型
        • B-Tree/B+Tree概述
        • 为什么使用B+Tree
        • MySQL中的B+Tree索引
        • MySQL高性能索引策略
      • MySQL查询
        • MySQL查询过程
        • MySQL查询性能优化
        • 使用EXPLAIN
      • MySQL锁
        • MySQL中锁概述
        • InnoDB的并发控制
        • MySQL乐观锁
      • MySQL分库分表
        • 分库/分表
        • 跨库JOIN
        • 跨库分页
        • 分库分表后的平滑扩容
        • 分区表
        • 分布式ID生成方法
      • MySQL实战
        • 在线表结构变更
        • MySQL优化规则
        • MySQL问题排查
        • 常见查询场景
    • Redis
    • Hbase
    • OpenTSDB
    • rrd
    • MongoDB
    • 连接池
  • 系统设计
    • 一致性Hash算法
    • 限流
      • 限流是什么
      • 限流算法
      • 应用内限流
      • 分布式限流
      • 接入层限流
        • ngx_http_limit_conn_module
        • ngx_http_limit_req_module
        • lua_resty_limit-tarffic
      • 节流
    • 降级
      • 降级详解
      • 人工降级开关的实现
      • 自动降级的实现:Hystrix
    • 负载均衡
      • 概述
      • 互联网架构下的负载均衡
      • Nginx负载均衡(七层)
      • Nginx负载均衡(四层)
      • Nginx动态配置
    • 超时与重试机制
      • 什么地方要超时与重试
      • 代理层超时与重试
      • Web容器超时
      • 中间件客户端超时与重试
      • 数据库超时
      • NoSQL客户端超时设置
      • 业务超时
      • 前端请求超时
    • 网关
    • CAP
      • 什么是CAP
      • CAP理解
    • 生产者-消费者模型
      • 使用notify/wait方式
      • 使用await/signal实现
      • 使用阻塞队列实现
      • 使用信号量实现
      • 使用管道流实现
      • 无锁队列Disruptor
      • 双缓冲队列
    • 缓存
      • 缓存概述
      • 数据库缓存
      • 应用缓存
      • 前端缓存
      • 本地缓存
    • 秒杀
    • LRU
  • 版本控制
    • Git
      • Git常用命令
      • 场景命令
    • Svn
  • 计算机操作系统
    • Linux
      • Linux中重要概念
      • 常用命令
      • 查看日志
      • 权限管理
      • 登录或传输
      • 防火墙
      • 配置ssh免密
      • 进程
      • 防火墙
    • Mac
    • 计算机基础
      • 进制
      • Java中的位运算
      • 计算机存储系统结构
  • 网络
    • TCP三次握手和四次挥手
    • 网络术语
      • 网关、路由器、交换机、IP等
      • VLAN
      • LAN
  • 设计模式
    • 设计模式概述
    • 创建型
      • 单例模式
      • 工厂模式
      • 建造者模式
      • 原型模式
      • 享元模式
    • 行为型
      • 观察者模式
      • 策略模式
      • 模板模式
      • 责任链模式
      • 命令模式
      • 外观模式
      • 迭代器模式
      • 中介者模式
        • 中介模式续
      • 状态模式
        • 状态模式实例
        • 状态模式思考
      • 访问者模式
        • 访问者实例1
        • 访问者模式续
    • 结构型
      • 组合模式
        • 组合模式续
      • 装饰模式
        • 装饰模式续
      • 代理模式
      • 备忘录模式
      • 桥接模式
        • 桥接模式实例一
  • 构建工具
    • Maven
      • 常用命令
      • Maven生命周期
      • Maven中的变量和属性
      • 不同环境的如何配置不同的变量
      • 常用插件及配置
      • 其他问题
      • dependencies与dependencyManagement的区别
    • Gradle
  • 大数据
    • Hadoop
    • Storm
    • Spark
  • 服务器
    • Tomcat
      • server.xml配置详解
      • 线程池和连接数配置
      • Maven远程部署
      • 一些小技巧
      • Tomcat类加载机制分析
      • Tomcat的日志
      • Tomcat架构
        • 概述
        • Server 的启动流程
        • 请求处理流程
    • Nginx
      • 常用命令
      • 基本配置
      • Lua
    • Tengine
  • 中间件
    • 任务调度
      • 为什么需要任务调度
    • 消息队列
      • 为什么需要消息队列
      • 消息队列关键点
      • 消息中间件需要解决的问题
      • 不同消息队列产品对比
      • RocketMQ
        • 快速入门
        • 整体架构
        • 部署方式
          • Broker部署方案
        • 客户端使用
          • 客户端使用指南
          • 快速开始
          • 简单示例
          • 有序消息示例
          • 广播消息示例
          • 定时消息示例
          • 批量消息示例
          • 过滤消息示例
          • 日志输出配置示例
        • 关键点实现
          • 顺序消息的实现
        • 最佳实践
          • Broker的最佳实践
          • 生产者最佳实践
            • 生产者最佳实践续
          • 消费者最佳实践
            • 消费者最佳实践续
          • 名称服务最佳实践
          • JVM/kernel配置的最佳实践
          • 新特性 Filter Server
          • 其他事项
      • RabbitMQ
      • Kafka
    • 分布式事务
      • 什么是分布式事务
      • 解决方案
    • 服务治理
      • RPC概念
      • RPC最简实现
      • 为什么需要服务治理
      • Dubbo
        • Dubbo整体架构
      • Java RMI
    • 分布式锁
      • 如何设计分布式锁
        • 基于zookeeper
        • 基于Redis
    • 注册中心
      • 注册中心的职责
      • 不同注册中心的比较
    • 配置中心
      • 概述
      • 配置中心的实现与选型
  • Web开发
    • Http请求类型及区别
    • 常见的content-type
    • 如何处理跨域
    • Restful最佳实践
    • HTTP状态码
    • Http下载原理
  • 测试
    • 压测:apache bench
    • 压测:Jmeter
Powered by GitBook
On this page
  • BeanPostProcessor
  • 参考
  1. 框架或工具
  2. Spring
  3. Spring基础
  4. Spring的MainClass

Spring的BeanPostProcessor

PreviousSpring的BeanFctoryPostProcessorNextSpring的Listener

Last updated 6 years ago

BeanPostProcessor

BeanPostProcessor,字面意思就是“Bean之后的处理器”(post可以理解为after),接口如下:

  • Object postProcessBeforeInitialization(Object bean, String beanName):该方法会在与beanName对应的Bean完成初始化(且已经被填充了属性值)之后,但在其他初始化回调(如该Bean实现了InitializingBean的afterPropertiesSet或者该Bean定制了init-method)之前,进行调用。返回值bean可以是原始Bean(即入参Object bean)的包装类。

  • Object postProcessAfterInitialization(Object bean, String beanName):该方法会在与beanName对应的Bean完成初始化(且已经被填充了属性值)之后,且在其他初始化回调(如该Bean实现了InitializingBean的afterPropertiesSet或者该Bean定制了init-method)之后,进行调用。返回值bean可以是原始Bean(即入参Object bean)的包装类。

即BeanPostProcessor可以在Bean完成初始化(且已填充完属性)时,对Bean做一些处理。InstantiationAwareBeanPostProcessor

它定义了比BeanPostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization更早的方法:

//在实例化之前的回调(即在new之前),返回值往往是原始对象的包装
Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
//在实例化之后,但是还没有填充属性(即在new之后,但set属性之前)
postProcessAfterInstantiation(Object bean, String beanName)
//填充属性时的回调方法(即在set属性时)
PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)

就英文单词字面意思来看,Instantiation表示实例化,Initialization表示初始化,这5个方法的执行的顺序为(越靠前越先执行):postProcessBeforeInstantiation < postProcessAfterInstantiation < postProcessPropertyValues < postProcessBeforeInitialization < postProcessAfterInitialization。

SmartInstantiationAwareBeanPostProcessor

如字面意思一样,它定义了两个比较smart的方法:

Class<?> predictBeanType(Class<?> beanClass, String beanName):预测这个processor最终返回的Bean的类型。

Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName):预测这个processor使用哪些构造器来创建最终返回的Bean。

除了这两个对得起它名字的smart的方法,该接口还定义了一个非常重要(解决循环依赖)的方法:

Object getEarlyBeanReference(Object bean, String beanName):返回一个还没有完全实例化好的Bean。

DestructionAwareBeanPostProcessor

上述的三个接口都是在将Bean的实例化、初始化,而这个接口则是在Bean销毁的时候,进行处理:

//在销毁Bean之前被回调
void postProcessBeforeDestruction(Object bean, String beanName)

与DisposableBean的destroy方法和自定义的destory-method一样,该processor也同样只在单例Bean的生命周期中被回调。

MergedBeanDefinitionPostProcessor

该接口是指对beanDefinition进行处理,显然这个是Bean生命周期的最早阶段的事情。

//beanDefinition是合并后的最终的beanDefinition
void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);

InstantiationAwareBeanPostProcessorAdapter

这个类其实什么都没有做,它对SmartInstantiationAwareBeanPostProcessor / InstantiationAwareBeanPostProcessor / BeanPostProcessor这三个接口中的8个方法都进行了“什么都不做”的实现(即实现方法都是空的,与接口中方法的默认行为一致),这样子类只需要重写真正关心的方法就可以了,而不用再处理其他不关心的方法。这个类只是Spring内部实现时使用,我们关心哪个方法,直接实现对应的接口就可以了,不用继承该类。

BeanPostProcessor接口及其子接口提供了对Bean生命周期的各个阶段的扩展。这些扩展到底有哪些呢?就在它们的实现类中。

InitDestroyAnnotationBeanPostProcessor

从名字猜测,init,destroy,annotation这三个关键词就解释了它的作用:调用Bean中用注解配置的init和destroy方法,可以通过如下方法来指定哪个注解标识的方法是init方法,哪个注解标识的是destroy方法:

void setInitAnnotationType(Class<? extends Annotation> initAnnotationType)
void setDestroyAnnotationType(Class<? extends Annotation> destroyAnnotationType)

但通常来讲,init方法通常使用@PostConstruct,destroy方法通常使用@PreDestroy。

实现思路:在postProcessBeforeInitialization中调用Bean的init方法,在postProcessAfterInitialization中调用Bean的destroy方法。

而Bean的init和destroy方法到底是什么,则从postProcessMergedBeanDefinition中获取。

CommonAnnotationBeanPostProcessor

这个实现非常重要。

首先它继承自InitDestroyAnnotationBeanPostProcessor,具备了调用Bean中用注解配置的init和destroy方法,它设置的init和destroy的注解分别为@PostConstruct和@PreDestroy。

此外,它实现了InstantiationAwareBeanPostProcessor,说明它会在Bean实例化之前和之后,Bean初始化之后做一些事情。具体的事情则在对应的实现方法中,主要是在postProcessPropertyValues中,通过Bean的定义,拿到有哪些属性标注了@Resource注解(field.isAnnotationPresent(Resource.class)),然后注入到Bean中(field.set(target, getResourceToInject(target, requestingBeanName));)。具体实现比较复杂,涉及到缓存和线程安全等问题。

public PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
    InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
    try {
        metadata.inject(bean, beanName, pvs);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
    }
    return pvs;
}

即CommonAnnotationBeanPostProcessor可以将我们在类中使用@Resource注解来声明的属性Bean,真正地注入到该类中。

todo 这些processor的注册问题

AutowiredAnnotationBeanPostProcessor

这个实现同样非常重要。从它的名字autowired,annotation可以看出,它负责处理表示自动装配的注解,这些注解默认包括:Spring提供的@Autowired和@Value,以及JSR-330中的@Inject。也可以通过void setAutowiredAnnotationType(Class<? extends Annotation> autowiredAnnotationType)进行自定义这些注解。

主要是在postProcessPropertyValues中,通过Bean的定义,拿到有哪些属性标注了设置的表示自动装配的注解(field.isAnnotationPresent(XXXXX.class)),然后注入到Bean中(field.set(target, getResourceToInject(target, requestingBeanName));)。

即AutowiredAnnotationBeanPostProcessor可以将我们在类中使用@Autowired/@Value/@Inject注解来声明的属性Bean,真正地注入到该类中。

RequiredAnnotationBeanPostProcessor

负责检测标注了@Required的属性是否真的有值,没有值则抛异常。实现也非常简单,在postProcessPropertyValues方法中,检查PropertyValues,如果一个属性加了@Required注解,则检查它对应的value是否为null。

上述的AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor是通过在xml配置如下信息来开启的:

<context:annotation-config/>
<context:component-scan base-package="com.maxwell.learning.spring"/>

并且,注解方式的注入是先于在xml配置的Bean注入执行的,所以xml的注入配置会覆盖注解的注入配置。

还有这样一个问题:假如配置了多个BeanPostProcessor,它执行的先后顺序是什么呢?

所有的BeanPostProcessor的最终实现类都会实现PriorityOrdered接口,它定义了int getOrder();方法来表示该processor的优先级:order越大,优先级越低;order越小,优先级越高。

上面的几个实现类:CommonAnnotationBeanPostProcessor的order为Integer.MAX_VALUE-3,AutowiredAnnotationBeanPostProcessor的order为Integer.MAX_VALUE-2,RequiredAnnotationBeanPostProcessor的order为Integer.MAX_VALUE-1,所以他们的执行的先后顺序为:CommonAnnotationBeanPostProcessor > AutowiredAnnotationBeanPostProcessor > RequiredAnnotationBeanPostProcessor。

ApplicationContextAwareProcessor

负责处理Bean实现的Aware的6个接口,是在Bean已经完全初始化好之后,主要逻辑如下:

@Override
public Object postProcessBeforeInitialization(final Object bean, String beanName){
   if (bean instanceof Aware) {
    if (bean instanceof EnvironmentAware) {
        ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
    }
    if (bean instanceof EmbeddedValueResolverAware) {
        ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
    }
    if (bean instanceof ResourceLoaderAware) {
        ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
    }
    if (bean instanceof ApplicationEventPublisherAware) {
        ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
    }
    if (bean instanceof MessageSourceAware) {
        ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
    }
    if (bean instanceof ApplicationContextAware) {
        ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
    }
}

ServletContextAwareProcessor 负责处理Bean实现的两个Aware接口:ServletContextAware和ServletConfigAware。 BeanValidationPostProcessor 负责处理Bean中标注的JSR-303中用于验证Bean属性值的注解,如@NotNull,@Min(value),@Pattern(value)等等。 MethodValidationPostProcessor 负责处理方法的参数中标注的JSR-303中用于验证的注解,如:

public @NotNull Object myValidMethod(@NotNull String arg1, @Max(10) int arg2)

它的实现方式是为方法加上AOP增强,增强逻辑即为验证逻辑。 AbstractAutoProxyCreator 这个实现类非常重要,是实现AOP的地方。 如果某个Bean使用AOP进行了功能增强,那么AbstractAutoProxyCreator会为该Bean生成代理,生成代理这个操作需要在Bean实例化之前进行,因此,它的实现主要在postProcessBeforeInstantiation方法中。 AOP相关的功能实现,都在AbstractAutoProxyCreator及其子类当中。 ScheduledAnnotationBeanPostProcessor 负责处理Bean中的使用@Scheduled注解标注的方法。一般这样的方法都是具体的业务逻辑,所以需要在Bean完全初始化好之后进行处理,即在postProcessAfterInitialization中处理。 AsyncAnnotationBeanPostProcessor 负责处理Bean中的使用@Async注解标注的方法。 这些processor,有的是参与到创建Bean的过程中,有的是对Bean功能的增强,大大减少了BeanFactory的工作。当然,还需要告诉BeanFactory到底有哪些processor,一般在具体的BeanFactory实现类中,会选择性地添加这些proccssor,以实现特定的功能。

参考

Spring的BeanFactoryPostProcessor和BeanPostProcessor
Spring源代码分析(4)---BeanFactoryPostProcessor
Spring核心——官配BeanFactoryPostProcessor
浅谈Spring的PropertyPlaceholderConfigurer
Spring Core Container 源码分析五:@Autowired
Spring内部的BeanPostProcessor接口总结
JSR 303 - Bean Validation 介绍及最佳实践