Spring BPP中優雅的建立動態代理Bean

時間  2019-11-05
標籤 spring bpp 優雅 建立 動態 代理 bean 欄目 Spring 简体版
原文   原文鏈接

1、前言

　　本文章所講並無基於Aspectj，而是直接經過Cglib以及ProxyFactoryBean去建立代理Bean。經過下面的例子，能夠看出Cglib方式建立的代理Bean和ProxyFactoryBean建立的代理Bean的區別。java

2、基本測試代碼

　　測試實體類，在BPP中建立BppTestDepBean類型的代理Bean。git

@Component
public static class BppTestBean {
    @Autowired
    private BppTestDepBean depBean;

    public void test1() {
        depBean.testDep();
    }

    public void test2() {
        depBean.testDep();
    }

    @TestMethod
    public void test3() {
        depBean.testDep();
    }
}

@Component
public static class BppTestDepBean {
    public void testDep() {
        System.out.println("HEHE");
    }
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TestMethod {
}

　　測試類github

@RunWith(SpringRunner.class)
@SpringBootTest
public class BppTest {

    @Autowired
    private BppTestBean bppTestBean;

    @Test
    public void test() {
        bppTestBean.test1();
        bppTestBean.test2();
        bppTestBean.test3();
    }
}

3、使用Cglib建立代理Bean

public class ProxyBpp1 implements BeanPostProcessor {
    private static final Logger LOGGER = LoggerFactory.getLogger(ProxyBpp1.class);

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof BppTestBean) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(bean.getClass());
            //標識Spring-generated proxies
            enhancer.setInterfaces(new Class[]{SpringProxy.class});
            //設置加強
            enhancer.setCallback((MethodInterceptor) (target, method, args, methodProxy) -> {
                if ("test1".equals(method.getName())) {
                    LOGGER.info("ProxyBpp1 開始執行...");
                    Object result = methodProxy.invokeSuper(target, args);
                    LOGGER.info("ProxyBpp1 結束執行...");
                    return result;
                }
                return method.invoke(target, args);
            });

            return enhancer.create();
        }
        return bean;
    }
}

　　主要是代理 BppTestBean的test1方法。其實這種方式建立的代理Bean使用問題的，@Autowired字段沒有注入進來，因此會有出現NPE。methodProxy.invokeSuper(target, args)，這一行代碼是有問題的，targe是代理類對象，而真實的對象是postProcessBeforeInitialization(Object bean, String beanName) 中的bean對象，此時bean對象@Autowired字段已經注入了。因此能夠將methodProxy.invokeSuper(target, args) 修改成method.invoke(bean, args)解決沒法注入@Autowired字段的問題。spring

4、使用ProxyFactoryBean建立代理Bean

public class ProxyBpp2 implements BeanPostProcessor {
    private static final Logger LOGGER = LoggerFactory.getLogger(ProxyBpp2.class);

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof BppTestBean) {
            ProxyFactoryBean pfb = new ProxyFactoryBean();
            pfb.setTarget(bean);
            pfb.setAutodetectInterfaces(false);
            NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor();
            advisor.addMethodName("test1");
            advisor.setAdvice((MethodInterceptor) invocation -> {
                LOGGER.info("ProxyBpp2 開始執行...");
                Object result = invocation.getMethod().invoke(invocation.getThis(), invocation.getArguments());
                LOGGER.info("ProxyBpp2 結束執行...");
                return result;
            });
            pfb.addAdvisor(advisor);

            return pfb.getObject();
        }
        return bean;
    }
}

　　　使用ProxyFactoryBean建立代理Bean的時候，必定要一個targe對象的。Advisor在切入的時候，會逐個執行Advice。invocation.getThis()就是在經過ProxyFactoryBean建立代理Bean的時候傳入的target對象。因爲target對象就是postProcessBeforeInitialization(Object bean, String beanName) 中的bean對象，因此@Autowired字段也已經注入進來了。安全

5、@Autowired註解什麼時候被處理

　　想必你們都知道@Autowired字段的處理也是經過一個BPP，不過這個BPP比咱們日常使用的要高級一些，它就是InstantiationAwareBeanPostProcessor。這個BPP能夠實現Bean的建立、屬性的注入和解析（好比@Autowired、@Value、@Resource等等），你們能夠參考一下CommonAnnotationBeanPostProcessor（處理JSR-250相關注解），AutowiredAnnotationBeanPostProcessor（處理@Autowired、@Value、@Inject相關注解）。springboot

　　InstantiationAwareBeanPostProcessor中有一個以下的方法，AutowiredAnnotationBeanPostProcessor就是覆蓋這個方法實現了帶有相關注解屬性的自動注入。app

@Nullable
default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
        throws BeansException {

    return null;
}
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    try {
        metadata.inject(bean, beanName, pvs);
    }
    catch (BeanCreationException ex) {
        throw ex;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
    }
    return pvs;
}

　　InstantiationAwareBeanPostProcessor的postProcessProperties方法實在Spring AbstractAutowireCapableBeanFactory的populateBean方法中被調用。在AbstractAutowireCapableBeanFactory的doCreateBan中有以下代碼。ide

// Initialize the bean instance.
Object exposedObject = bean;#
try {
    populateBean(beanName, mbd, instanceWrapper);
    exposedObject = initializeBean(beanName, exposedObject, mbd);
}

　　也就是先進行了Bean的屬性填充，而後進行Bean的初始化工做。initializeBean方法中主要作了四件事。工具

　　一、invokeAwareMethods
　　二、applyBeanPostProcessorsBeforeInitialization
　　三、invokeInitMethods
　　四、applyBeanPostProcessorsAfterInitializationpost

　　其中2和4就是分別調用的普通的BPP中的postProcessBeforeInitialization方法和postProcessAfterInitialization方法。

　　這就是爲何在BPP中建立代理Bean的時候，對應的目標Bean相關的@Autowired字段已經注入的緣由了。

6、InstantiationAwareBeanPostProcessor方式建立動態代理Bean

　　InstantiationAwareBeanPostProcessor接口中有個postProcessBeforeInstantiation方法，可讓咱們本身去實例化Bean。經過查看AbstractAutowireCapableBeanFactory，方法調用：createBean方法 -> resolveBeforeInstantiation方法 -> applyBeanPostProcessorsBeforeInstantiation方法 ->InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation方法，若是最終返回一個非null的實例，那麼就不會再執行doCreateBean方法。這就意味着不會有Bean屬性的填充和初始化的流程了，可是能夠藉助AbstractAutowireCapableBeanFactory幫助咱們實現。

public <T> T postProcess(T object) {
    if (object == null) {
        return null;
    }
    T result;
    try {
        // 使用容器autowireBeanFactory標準依賴注入方法autowireBean()處理 object對象的依賴注入
        this.autowireBeanFactory.autowireBean(object);
        // 使用容器autowireBeanFactory標準初始化方法initializeBean()初始化對象 object
        result = (T) this.autowireBeanFactory.initializeBean(object,
                object.toString());
    } catch (RuntimeException e) {
        Class<?> type = object.getClass();
        throw new RuntimeException(
                "Could not postProcess " + object + " of type " + type, e);
    }
    return result;
}

　　上圖代碼，能夠幫組咱們實現非Spring容器Bean自動注入和初始化的功能。使用過Spring security同窗都知道，內部也是用了這個方式解決對象中的屬性注入問題。若是你閱讀了Spring security的源碼，你會發現不少對象，好比WebSecurity、ProviderManager、各個安全Filter等，這些對象的建立並非經過bean定義的形式被容器發現和註冊進入spring容器的，而是直接new出來的。Spring security提供的AutowireBeanFactoryObjectPostProcessor這個工具類可使這些對象具備容器bean一樣的生命週期，也能注入相應的依賴，從而進入準備好被使用的狀態。

　　使用Cglib在InstantiationAwareBeanPostProcessor 中建立動態代理Bean。

public class ProxyBpp3 implements InstantiationAwareBeanPostProcessor {
    private static final Logger LOGGER = LoggerFactory.getLogger(ProxyBpp3.class);

    private final AutowireCapableBeanFactory autowireBeanFactory;

    ProxyBpp3(AutowireCapableBeanFactory autowireBeanFactory) {
        this.autowireBeanFactory = autowireBeanFactory;
    }

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if (beanClass.equals(BppConfig.BppTestBean.class)) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(beanClass);
            //標識Spring-generated proxies
            enhancer.setInterfaces(new Class[]{SpringProxy.class});
            //設置加強
            enhancer.setCallback((MethodInterceptor) (target, method, args, methodProxy) -> {
                if ("test1".equals(method.getName())) {
                    LOGGER.info("ProxyBpp3 開始執行...");
                    Object result = methodProxy.invokeSuper(target, args);
                    LOGGER.info("ProxyBpp3 結束執行...");
                    return result;
                }
                return methodProxy.invokeSuper(target, args);
            });

            return this.postProcess(enhancer.create());
        }
        return null;
    }

    ...
}

　　使用ProxyFactoryBean在InstantiationAwareBeanPostProcessor 中建立動態代理Bean。

public class ProxyBpp4 implements InstantiationAwareBeanPostProcessor {
    private static final Logger LOGGER = LoggerFactory.getLogger(ProxyBpp4.class);

    private final AutowireCapableBeanFactory autowireBeanFactory;

    ProxyBpp4(AutowireCapableBeanFactory autowireBeanFactory) {
        this.autowireBeanFactory = autowireBeanFactory;
    }

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if (beanClass.equals(BppConfig.BppTestBean.class)) {
            ProxyFactoryBean pfb = new ProxyFactoryBean();
            pfb.setTarget(this.postProcess(BeanUtils.instantiateClass(beanClass)));
            pfb.setAutodetectInterfaces(false);
            NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor();
            advisor.addMethodName("test1");
            advisor.setAdvice((MethodInterceptor) invocation -> {
                LOGGER.info("ProxyBpp4 開始執行...");
                Object result = invocation.getMethod().invoke(invocation.getThis(), invocation.getArguments());
                LOGGER.info("ProxyBpp4 結束執行...");
                return result;
            });
            pfb.addAdvisor(advisor);

            return pfb.getObject();
        }
        return null;
    }
    ...
}

　　上述向兩種方式，注意，實例化bean後主動經過postProcess方法藉助AbstractAutowireCapableBeanFactory完成對象相關屬性的注入以及對象的初始化流程。

7、源碼分享

　　點我查看源碼，若是有任何疑問請關注公衆號後進行諮詢。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程