Spring之后处理器

最新推荐文章于 2024-06-07 01:02:59 发布
最新推荐文章于 2024-06-07 01:02:59 发布
阅读量615 收藏
点赞数 2
分类专栏： Spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61313896/article/details/128533312
版权

目录

一：概述

二：案例演示

三：Bean的后处理器----BeanPostProcessor

案例：对Bean方法进行执行时间日志增强

四：Spring ioc整体流程总结

一：概述

              Spring的后处理器是Spring对外开发的重要扩展点、允许我们介入到Bean的整个实例化流程中来， 以达到动态注册 BeanDefinition， 动态修改BeanDefinition， 以及动态修改Bean的作用。Spring主要有两种后处理器：

  • BeanFactoryPostProcessor：Bean工厂后处理器， 在BeanDefinitionMap填充完毕， Bean实例化之前执行；

  • BeanPostProcessor：Bean后处理器， 一般在Bean实例化之后， 填充到单例池singletonObjects之前执行。

              Bean工厂后处理器-BeanFactoryPostProcessor BeanFactoryPostProcessor是一个接口规范， 实现了该接口的类只要交由Spring容器管理的话， 那么Spring就会回调该接口的方法， 用于对BeanDefinition注册和修改的功能。

        BeanFactoryPostProcessor定义如下：

public interface BeanFactoryPostProcessor{
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) ；
}

二：案例演示

①:注册BeanDefinition

1.编写MyBeanFactoryPostProcessor类,实现BeanFactoryPostProcessor接口，并实现接口方法

package com.tangyuan.processor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.RootBeanDefinition;

/**
 * @author 唐渊
 * @create  2022-11-25 16:15
 */
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {


    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("beanDefinitionMap填充完毕后回调该方法");
        //不在主xml文件中进行配置bean
        //动态注册Beandifinition
          BeanDefinition beanDefinition=new RootBeanDefinition();
          beanDefinition.setBeanClassName("com.tangyuan.dao.impl.PeresonDaoImpl");                                     System.out.println(beanFactory);                       //org.springframework.beans.factory.support.DefaultListableBeanFactory@737996a0: defining beans
        //强转成DefaultListableBeanFactory
        DefaultListableBeanFactory defaultListableBeanFactory= (DefaultListableBeanFactory) beanFactory;
        defaultListableBeanFactory.registerBeanDefinition("PersonDao",beanDefinition);

    }
}

2.测试

//创建ApplicationContext，加载配置文件，实例化容器
ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
PeresonDao bean = applicationContext.getBean(PeresonDao.class);
System.out.println(bean);//com.tangyuan.dao.impl.PeresonDaoImpl@6ddf90b0

②:注册BeanDefinition

            Spring提供了一个BeanFactoryPostProcessor的子接BeanDefinitionRegistryPostProcessor专门用于注册BeanDefinition操作

public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor{

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException{}

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException{

BeanDefinition beanDefinition=new RootBeanDefinition() ；
beanDefinition.setBeanClassName("com.tangyuan.dao.UserDaoImp12")；

beanDefinitionRegistry.registerBeanDefinition("userDao2"，beanDefinition) ；

}
}

案例演示：

        1.编写MyBeanDefinitionRegistryPostProcessor类,实现BeanDefinitionRegistryPostProcessor接口，并实现接口方法

package com.tangyuan.processor;

import com.alibaba.druid.support.spring.stat.SpringStatUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.beans.factory.support.RootBeanDefinition;

/**
 * @author 唐渊
 * @create  2022-11-28 10:21
 */
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        System.out.println("MyBeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法");
        //向容器当中注册BeanDefinition
        BeanDefinition beanDefinition=new RootBeanDefinition();
        beanDefinition.setBeanClassName("com.tangyuan.dao.impl.PeresonDaoImpl");
         beanDefinitionRegistry.registerBeanDefinition("PersonDao",beanDefinition);

    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("MyBeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法");
    }
}

2.将MyBeanDefinitionRegistryPostProcessor类在xml文件中进行配置

<bean class="com.tangyuan.processor.MyBeanDefinitionRegistryPostProcessor"></bean>

3.测试

//创建ApplicationContext，加载配置文件，实例化容器
ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
PeresonDao bean = applicationContext.getBean(PeresonDao.class);
System.out.println(bean);//com.tangyuan.dao.impl.PeresonDaoImpl@5a8e6209

ps:方法的执行顺序

1.MyBeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
2.MyBeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
3.MyBeanFactoryPostProcessor的postProcessBeanFactory方法

③:使用Spring的BeanFactoryPostProcessor扩展点完成自定义注解扫描

要求如下：

  • 自定义@MyComponent注解， 使用在类上；

  • 使用资料中提供好的包扫描器工具BaseClassScanUtils完成指定包的类扫描；

  • 自定义BeanFactoryPostProcessor完成注解@MyComponent的解析， 解析后最终被Spring管理。

1.创建一个OtherBean类,并定义@MyComponent注解

package com.tangyuan.beans;

import com.tangyuan.anno.MyComponent;

/**
 * @author 唐渊
 * @create  2022-11-28 15:34
 */
@MyComponent("OtherBean")
public class OtherBean {
}
package com.tangyuan.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author 唐渊
 * @create  2022-11-28 15:35
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyComponent {
    String value();
}

2.BaseClassScanUtils 帮助类编写

package com.tangyuan.utils;

import com.tangyuan.anno.MyComponent;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.util.ClassUtils;

import java.lang.annotation.Annotation;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class BaseClassScanUtils {

    //设置资源规则
    private static final String RESOURCE_PATTERN = "/**/*.class";

    public static Map<String, Class> scanMyComponentAnnotation(String basePackage) {

        //创建容器存储使用了指定注解的Bean字节码对象
        Map<String, Class> annotationClassMap = new HashMap<String, Class>();

        //spring工具类，可以获取指定路径下的全部类
        ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
        try {
            String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                    ClassUtils.convertClassNameToResourcePath(basePackage) + RESOURCE_PATTERN;
            Resource[] resources = resourcePatternResolver.getResources(pattern);
            //MetadataReader 的工厂类
            MetadataReaderFactory refractory = new CachingMetadataReaderFactory(resourcePatternResolver);
            for (Resource resource : resources) {
                //用于读取类信息
                MetadataReader reader = refractory.getMetadataReader(resource);
                //扫描到的class
                String classname = reader.getClassMetadata().getClassName();
                Class<?> clazz = Class.forName(classname);
                //判断是否属于指定的注解类型
                if(clazz.isAnnotationPresent(MyComponent.class)){
                    //获得注解对象
                    MyComponent annotation = clazz.getAnnotation(MyComponent.class);
                    //获得属value属性值
                    String beanName = annotation.value();
                    //判断是否为""
                    if(beanName!=null&&!beanName.equals("")){
                        //存储到Map中去
                        annotationClassMap.put(beanName,clazz);
                        continue;
                    }

                    //如果没有为"",那就把当前类的类名作为beanName
                    annotationClassMap.put(clazz.getSimpleName(),clazz);

                }
            }
        } catch (Exception exception) {
        }

        return annotationClassMap;
    }

    public static void main(String[] args) {
        Map<String, Class> stringClassMap = scanMyComponentAnnotation("com.tangyuan");
        System.out.println(stringClassMap);
    }
}

3.编写MyComponentBeanFactoryPostProcessor类,并实现BeanDefinitionRegistryPostProcessor接口

package com.tangyuan.processor;

import com.tangyuan.utils.BaseClassScanUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.beans.factory.support.RootBeanDefinition;

import java.util.Map;

/**
 * @author 唐渊
 * @create  2022-11-28 15:45
 */
public class MyComponentBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        //通过扫描工具去扫描指定包及其包下的所有类,收集使用@MyComponent注解的类
        Map<String, Class> map = BaseClassScanUtils.scanMyComponentAnnotation(
                "com.tangyuan"
        );
        //循环遍历,组装BeanDefinition进行注册
        map.forEach((beanName,clazz)->{
       //获取BeanClassName
            String name = clazz.getName();//com.tangyuan.beans.OtherBean
        //创建BeanDefinition
            BeanDefinition beanDefinition=new RootBeanDefinition();
            beanDefinition.setBeanClassName(name);
           //注册
            beanDefinitionRegistry.registerBeanDefinition(name,beanDefinition);


        });

    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }
}

4.在xml文件编写MyComponentBeanFactoryPostProcessor类的bean

<bean class="com.tangyuan.processor.MyComponentBeanFactoryPostProcessor"></bean>

5.测试

OtherBean bean1 = applicationContext.getBean(OtherBean.class);
System.out.println(bean1);//com.tangyuan.beans.OtherBean@1877ab81

6.编写一个BookBean类,并实现@MyComponent注解

package com.tangyuan.beans;

import com.tangyuan.anno.MyComponent;
import org.springframework.stereotype.Component;

/**
 * @author 唐渊
 * @create  2022-11-28 16:09
 */
@MyComponent("BookBean")
public class BookBean {
}

7.再次测试

//创建ApplicationContext，加载配置文件，实例化容器
ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
BookBean bean2 = applicationContext.getBean(BookBean.class);
System.out.println(bean2);//com.tangyuan.beans.BookBean@1877ab81

三：Bean的后处理器----BeanPostProcessor

                   Bean被实例化后， 到最终缓存到名为singletonObjects单例池之前， 中间会经过Bean的初始化过程， 例如：属性的 填充、初始方法init的执行等， 其中有一个对外进行扩展的点BeanPostProcessor,我们称为Bean后处理。跟上面的 Bean工厂后处理器相似， 它也是一个接口， 实现了该接口并被容器管理的BeanPostProcessor， 会在流程节点上被 Spring自动调用。

BeanPostProcessor的接口定义如下：

public interface BeanPostProcessor{
@Nullable
//在属性注入完毕， init初始化方法执行之前被回调
default Object postProcesBeforeInitialization(Object bean， String bean Name)throws BeansException{
return bean；
}

//在初始化方法执行之后， 被添加到单例池singletonObjects之前被回调
@Nullable
default Object postProcessAfterInitialization(Object bean， String bean Name) throws BeansException{
return bean；
}
}

案例：对Bean方法进行执行时间日志增强

要求如下：

  • Bean的方法执行之前控制台打印当前时间；

  • Bean的方法执行之后控制台打印当前时间。

分析：

  • 对方法进行增强主要就是代理设计模式和包装设计模式；

  • 由于Bean方法不确定， 所以使用动态代理在运行期间执行增强操作；

  • 在Bean实例创建完毕后， 进入到单例池之前， 使用Proxy代替真是的目标Bean

思路：编写BeanPostProcessor, 增强逻辑编写在after方法中

public Object post Process After Initialization(Object bean，String beanName) throws BeansException{
//Bean进行动态代理,返回的是Proxy代理对象
Object proxy Bean=Proxy.newProxyInstance(bean.getClass() .getClassLoader() ，
bean.getClass() .getInterfaces() ，
(Object proxy， Method method，Object[] args) ->{
long start=System.currentTimeMillis() ；
system.out.println("开始时间："+new Date(start) ) ；
//执行目标方法BIN
Object result=method.invoke(bean，args) ；
long end=System.currentTimeMillis() ；
System.out.println("结束时间："+new Date(end) ) ；
return result；
});
//返回代理对象
return proxy Bean；
}

实现代码如下：

1.编写一个TimeLogBeanPostProcessor类,接口BeanPostProcessor实现,方法也实现

package com.tangyuan.processor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Date;

/**
 * @author 唐渊
 * @create  2022-11-29 9:48
 */
public class TimeLogBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
          //使用动态代理对目标Bean进行增强,返回proxy对象,进而存储到单例池singletonObjects中
            Object beanProxy= Proxy.newProxyInstance(
                bean.getClass().getClassLoader(),
                bean.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //1.输出开始时间
                        System.out.println("方法:"+method.getName()+"-开始时间:"+new Date());
                        //2.执行目标方法
                        Object invoke = method.invoke(bean, args);
                        //3.输出结束时间
                        System.out.println("方法:"+method.getName()+"-结束时间:"+new Date());
                        return invoke;
                    }
                }
        );

        return beanProxy;
    }
}

2.在xml文件上完成对TimeLogBeanPostProcessor类的配置

<bean class="com.tangyuan.processor.TimeLogBeanPostProcessor"></bean>

3.编写方法

package com.tangyuan.dao;

/**
 * @author 唐渊
 * @create  2022-11-20 9:29
 */
public interface UserDao {
    void show();
}
package com.tangyuan.dao.impl;

import com.tangyuan.dao.UserDao;
import org.springframework.beans.factory.InitializingBean;

/**
 * @author 唐渊
 * @create  2022-11-20 9:29
 */
public class UserDaoImpl implements UserDao , InitializingBean {
    public UserDaoImpl() {
        System.out.println("UserDao实例化");
    }

    public void init(){
        System.out.println("init初始化方法执行");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("属性设置之后执行~~~~");
    }

    @Override
    public void show() {//ctrl+Alt+t
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("show.....");
    }
}

4.测试

//创建ApplicationContext，加载配置文件，实例化容器
ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao dao = (UserDao) applicationContext.getBean("userDao");
dao.show();
方法:show-开始时间:Tue Nov 29 10:21:31 GMT+08:00 2022
show.....
方法:show-结束时间:Tue Nov 29 10:21:31 GMT+08:00 2022

四：Spring ioc整体流程总结

 

渊婉
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring 容器后处理器
01-31
Spring 容器后处理器
Spring中的后置处理器BeanPostProcessor详解
08-25
Spring中的后置处理器BeanPostProcessor详解 在 Spring 框架中，BeanPostProcessor 是一个非常重要的组件，它提供了一种方式来在bean实例化、配置和初始化方法前后添加自定义逻辑处理。下面我们将详细介绍 ...
Spring Bean后处理器
Buynow_Zhao的博客
10-30 246
Spring Bean后处理器 Spring提供了两类后处理器 1.Bean后处理器 2.容器后处理器   Spring的很多功能就是通过这些后处理来提供高质量的服务。而程序员只需要简单几部同样可以自定义功能强大的后处理器，今天我们将简述Bean后处理器   一、Bean后处理器 用来加强Spring容器中的bean处理。可以在bean在spring容器中初始化前后对bea...
spring之后处理器BeanFactoryPostProcessor和BeanPostProcessor
最新发布
weixin_42336161的博客
06-07 747
Spring的后处理器是Spring对外开发的重要扩展点，允许我们介入到Bean的整个实例化流程中来，以达到动态注册BeanDefinition，动态修改BeanDefinition，以及动态修改Bean的作用。BeanFactoryPostProcesser：Bean工厂后处理器，在BeanDefinitionMap填充完毕后，Bean实例化之前执行，执行一次；动态注册BeanDefinition，动态修改BeanDefinition。
六、Spring后处理器
l_zerol的博客
12-11 344
bean后处理器
6.1 两种后处理器
吃螃蟹的虾子
05-23 1684
本章要点利用后处理器扩展Spring容器AOP的基本概念如何生成AOP代理自动生成AOP代理Spring的事务策略配置简化的事务代理和自动事务代理Spring整合StrutsSpring整合Hibernate上一章已经介绍了Spring框架的基础内容，详细介绍了Spring容器的核心机制——依赖注入，并介绍了Spring容器对Bean的管理。实际上，上一章介绍的
Spring——Spring的后处理器
weixin_45700937的博客
10-06 167
认识 BeanFactoryPostProcessor 和 BeanPostProcessor
Spring实战之容器后处理器操作示例
08-25
容器后处理器可以在Bean实例化之前或之后执行某些操作，以满足特殊的需求。 下面是一个简单的容器后处理器示例： ```xml ``` 在上面的示例中，我们定义了一个容器后处理器 Bean，名为"beanFactoryPostProcessor"，...
Spring实战之Bean的后处理器操作示例
08-25
Spring实战之Bean的后处理器操作示例 本文主要介绍了Spring实战之Bean的后处理器操作，结合实例形式详细分析了Bean的后处理器相关配置、操作方法及使用注意事项。 Bean的后处理器 在Spring框架中，Bean的后处理器...
解析Java的Spring框架的BeanPostProcessor发布处理器
09-03
`postProcessAfterInitialization()` 方法则在bean的初始化方法执行之后调用，可用于进行后期处理，如设置默认值或执行一些最终配置。同样，返回的对象会被Spring容器识别为bean的最终状态。 Spring框架的...
Spring 的两种后处理器
Hinbo的博客
09-07 582
Spring 容器允许开发者使用两种后处理器扩展 IoC 容器，这两种后处理器可以后处理 IoC 容器本身，或者对容器中所有的 Bean 进行后处理。 Spring 提供的两种常用的后处理器： ① Bean 后处理器 ② 容器后处理器 1、Bean 后处理器Bean 后处理器是一种特殊的 Bean ，并不对外提供服务且必须实现 BeanPostProcessor 接口。如果使用 Applica
spring 的后置处理器
qwer123451234123的博客
04-22 4801
spring的后置处理器 spring提供了三种后置处理器 BeanFactoryPostProcessor BeanPostProcessor InitializingBean 我们来依次看每个后置处理器的执行流程。 BeanFactoryPostProcessor 首先还是回到refresh方法中，我们可以看到在创建普通bean对象的上面有个方法叫invokeBeanFactoryPostProcessor，从方法名就可以看出是执行BeanFactoryPostProcessor方法 .
Spring Bean后处理器以及容器后处理器
Aaron的学习历程
09-29 3662
Bean后处理器：即当Spring容器实例化Bean实例之后进行的增强处理。 容器后处理器：对容器本身进行处理，并总是在容器实例化其他任何Bean之前读取配置文件的元数据并可能修改这些数据。 一、Bean后处理器       实现了BeanPostProcessor接口的类即可作为一个Bean后处理器，以下是一个Bean后处理器的范例       1、编写一个实
Spring后处理器
ChambersC的博客
11-08 377
Spring后处理器
Spring：后处理器（配置器）&零配置（注解）
燕双嘤
01-28 1983
1，两种后处理器 Spring框架提供了很好的扩展，除了可以与各种第三方框架良好整合外，其IoC容器也允许开发者进行扩展，这种扩展甚至无须实现BeanFactory或ApplicationContext接口，而是允许通过两个后处理器对IoC容器进行扩展。 Bean后处理器：这种后处理器会对容器中的Bean进行后处理，对Bean进行额外加强。 容器后处理器：这种后处理器对IoC容器进行后处理，用于增强容器功能。 Bean的生命周期：https://shao12138.blog.csdn.net/art
Spring的后处理器
qq_60619678的博客
11-19 312
Spring的后处理器是spring对外开发的重要扩展点，允许我们介入到Bean的整个实例化流程来，以达到动态注册BeanDefintion，动态修改BeanDefintion，以及动态修改Bean的作用。Bean被实例化后，到最终缓存到名为singletonObjects单例池之前，中间会经过Bean的初始化过程，例如：属性填充，初始化方法init的执行等，BeanFactoryPostProcessor：Bean工厂后处理器，BeanDefintionMap填充完毕，Bean实例化之前执行；
Java Spring后处理器
涂涂写写的笔记
11-24 820
是Spring对外开放的重要扩展点，允许我们介入到Bean的整个实例化流程中来，以达到动态注册BeanDefinition，动态修改BeanDefinition，以及动态修改Bean的作用。BeanBeanDefintion到beanBeanDefintionMap中去，注册功能可以理解注解的实现，工厂后处理器去遍历带上注解的类，让后将其进行注册。的Map集合中去，那么除了直接将类信息配置的方式外，还有别的方式可以对想要交给Spring管理的类进行针对性处理封装，这里就可以使用到Spring的后处理器。
8 -- 深入使用Spring -- 1...2 Bean后处理器的用处
limeOracle的博客
02-07 103
　　　　　　8.1.2 Bean后处理器的用处 　　　　　　　　Spring提供的两个常用的后处理器： 　　　　　　　　⊙ BeanNameAutoProxyCreator ： 根据Bean实例的name属性，创建Bean实例的代理。 　　　　　　　　⊙ DefaultAdvisorAutoProxyCreator ： 根据提供的Advisor，对容器中的所有Bean实例创建代理。...
spring后置处理器
u013376634的博客
01-12 7030
1. BeanPostProcessor bean的后置处理器，主要在bean初始化前后工作。接口定义： public interface BeanPostProcessor { // 在初始化方法(如：afterPropertiesSet 或 init-method)执行前触发 @Nullable default Object postProcessBeforeInitializatio...
Spring Bean后置处理器 详细
05-11
Spring Bean后置处理器（BeanPostProcessor）是Spring框架中非常重要的一个功能，它允许我们在Bean实例化、依赖注入、初始化等步骤之前或之后，对Bean进行一些自定义操作。 Bean后置处理器是一个接口，它有两个方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值