BeanPostProcessor与Spring无侵入扩展

2024年4月21日 互联网

目录

    • 一、BeanPostProcessor
    • 二、用户透明无侵入扩展功能
      • 2.1 注解
      • 2.2 动态代理
      • 2.3 BeanPostProcessor创建代理
      • 2.4 业务类
      • 2.5 配置启动类
    • 三、总结

一、BeanPostProcessor

BeanPostProcessor接口有2个方法：

Object postProcessBeforeInitialization(Object bean, String beanName)
Object postProcessAfterInitialization(Object bean, String beanName)

感觉Initialization很有误导性，这里的Initialization并不是指类的初始化，也不是指实例的初始化。

而是指调用init-method这个初始化方法，就是类似于下面init-method指定的方法init调用前执行postProcessBeforeInitialization，调用之后执行postProcessAfterInitialization。

@Bean(initMethod = "init")

<bean id="id" class="Class" init-method="init"></bean>

想一想也有道理，都post类实例了，不是早就执行玩类初始化和类实例初始化了么，那么就只有init-method这个初始化了。

init-method方法是在InitializingBean接口的afterPropertiesSet方法之后执行，所以bean的属性已经设置完成了。

二、用户透明无侵入扩展功能

通过BeanPostProcessor我们可以实现对用户透明的代理，之前我们介绍动态代理的时候，要自己创建代理类，感觉非常不友好。

这里我们介绍一个通过BeanPostProcessor结合注解与动态代理来实现对用户透明的打印方法执行时间的功能，来感受一下BeanPostProcessor的强大。

2.1 注解

首先我们创建一个注解，用户想要打印一个方法的执行时间的时候，只需要添加该注解就可以了。

import org.curitis.jdk.LogExeDurationInvacationHandler;import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogExeDuration {Class value() default LogExeDurationInvacationHandler.class;
}

为了简化一点动态代理的逻辑，我们这里没有使用方法注解，而是使用了类注解，就是只要类上添加了LogExeDuration，就打印这个类中方法执行时间。

这里使用的Class属性是日志类，就是日志打印到哪里，默认是LogExeDurationInvacationHandler，还没见过，没关系，马上来。

2.2 动态代理

import org.curitis.annotation.LogExeDuration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.time.Duration;
import java.time.Instant;public class LogExeDurationInvacationHandler implements InvocationHandler {private Object target;private Logger logger;public LogExeDurationInvacationHandler(Object target,LogExeDuration logExeDuration) {this.target = target;this.logger = LoggerFactory.getLogger(logExeDuration.value());}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Instant start = Instant.now();Object result = method.invoke(target, args);Instant end = Instant.now();logger.info(String.format("%s execution cost %d ms",method.getName(), Duration.between(start,end).toMillis()));return result;}public static Object getProxy(Object target, LogExeDuration annotation){Class<?> clazz = target.getClass();ClassLoader classLoader = clazz.getClassLoader();Class<?>[] interfaces = clazz.getInterfaces();LogExeDurationInvacationHandler h = new LogExeDurationInvacationHandler(target,annotation);return Proxy.newProxyInstance(classLoader, interfaces, h);}
}

InvocationHandler我们的老朋友了，一看到基本就可以确定是JDK动态代理的实现逻辑部分，重点关注invoke方法，我们看到逻辑非常简单就是在调用目标方法前后记录了一下时间，并打印。

静态方法getProxy是一个方便获取代理类的工厂方法。

2.3 BeanPostProcessor创建代理

接下来，请出大佬BeanPostProcessor：

import org.curitis.annotation.LogExeDuration;
import org.curitis.jdk.LogExeDurationInvacationHandler;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;@Component
public class LogExeDurationBeanPostProcessor implements BeanPostProcessor {public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {return bean;}public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {Class<?> clazz = bean.getClass();LogExeDuration annotation = clazz.getAnnotation(LogExeDuration.class);if(annotation != null){bean = LogExeDurationInvacationHandler.getProxy(bean,annotation);}return bean;}
}

逻辑很简单，就是如果bean创建之后看这个bean有没有LogExeDuration注解，如果有，就把这个bean替换为一个代理类。

2.4 业务类

public interface BusinessService {String doSomething(Integer id,String name);
}

import org.curitis.annotation.LogExeDuration;
import org.curitis.service.BusinessService;
import org.springframework.stereotype.Service;@Service("businessService")
@LogExeDuration
public class BusinessServiceImpl implements BusinessService{@Overridepublic String doSomething(Integer id, String name) {return id + " " + name;}
}

2.5 配置启动类

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;@Configuration
@ComponentScan({"org.curitis.component","org.curitis.service"
})
public class ApplicationConfig {
}

import org.curitis.config.ApplicationConfig;
import org.curitis.service.BusinessService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class Start {private static final Logger logger = LoggerFactory.getLogger(Start.class);public static void main(String[] args) {logger.info("start......");ApplicationContext context = new AnnotationConfigApplicationContext(ApplicationConfig.class);BusinessService service = context.getBean(BusinessService.class);String result = service.doSomething(1, "curitis");System.out.println(result);}
}

输出

三、总结

通过BeanPostProcessor、注解、动态代理来基本已经成了扩展Spring的标准套路了。

例如@Transactional注解实现事务透明扩展，通过@Cache来实现缓存透明扩展。

用户使用起来也是爽歪歪，只需要在对应的方法、类上添加相应的注解就可以了，这就对用户非常友好，友好到很多人使用了很久的@Transational注解都不知道到底是怎么回事，当然这其中也包括我。

最新文章