精华内容
下载资源
问答
  • BeanPostProcessorspring中的后置处理器,spring中的bean的生命周期分为:创建,初始化,销毁。其中,在bean创建,属性赋值之后,会进行bean的初始化操作,而在初始化的前后会通过BeanPostProcessor进行前置和后置...

    什么是BeanPostProcessor

    BeanPostProcessor是spring中的后置处理器,spring中的bean的生命周期分为:创建,初始化,销毁。其中,在bean创建,属性赋值之后,会进行bean的初始化操作,而在初始化的前后会通过BeanPostProcessor进行前置和后置增强操作,通过源码分析可知:
    在这里插入图片描述
    在bean的初始化前后确实是通过后置处理器来增强的,而且在spring中的aop实现中,其实增强也是在这里进行的,只是前置处理在aop中是创建相应的bean的,而真正做增强业务的是在后置处理中。

    使用BeanPostProcessor

    搞清楚了BeanPostProcessor的作用,我们也可以在日常开发中来使用它,目的就是通过BeanPostProcessor在IOC容器加载我们的bean,初始化bean的前后进行对某些指定bean进行增强。

    需求

    对容器中Test5这个bean进行增强

    实现类
    @Component
    public class Test6 implements BeanPostProcessor {
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            if (bean instanceof Test5){
                System.out.println("1........." + bean + beanName);
            }
            return bean;
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            if (bean instanceof Test5){
                System.out.println("2........." + bean + beanName);
            }
            return bean;
        }
    }
    
    测试
    @RunWith(SpringRunner.class)
    @SpringBootTest(classes = DemoApplication.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
    public class DemoApplicationTests {
    
        @Autowired
        private BeanFactory beanFactory;
    
        @Test
        public void contextLoads() {
            Test6 bean =  beanFactory.getBean(Test6.class);
            System.out.println(bean);
    
        }
    
    }
    
    结果

    在这里插入图片描述
    测试可得出,在Test5被初始化前后被进行了增强。

    展开全文
  • jmeter——后置处理器

    2020-12-29 00:18:05
    1.1 什么是关联? 将请求1的输出 作为 请求2 的输入,则称之为关联,就是接口之间数据存在依赖关系 例如:“用户登录”请求中服务器返回了token,“查询用户信息”请求需要把token返回给服务器进行验证 1.2 正则...

    1 后置处理器

    1.1  什么是关联?

    将请求1的输出 作为 请求2 的输入,则称之为关联,就是接口之间数据存在依赖关系

     例如:“用户登录”请求中服务器返回了token,“查询用户信息”请求需要把token返回给服务器进行验证

    1.2 正则提取器

    正则提取器就是可以从请求的响应结果中取到需要的内容,从而实现关联,正则提取器在后置处理器里面

    • 引用名称:自己定义的变量名称,后续请求将要引用到的变量名,后续在其他接口引用时就使用{自己定义的变量名}
    • 正则表达式:提取内容的正则表达式
    • ()     括起来的部分就是需要提取的,对于你要提的内容需要用小括号括起来
    • .    点号表示匹配任何字符串
    • +   一次或多次
    • *   表示0次或多次
    • ?   在找到第一个匹配项后停止
    • 模板:用$$引用起来,如果在正则表达式中有多个正则表达式,就是有多个圆括号,则可以是$2$,$3$,表示解析到的第几个值给token。例如:$1$表示匹配到的第一个值
      • $-1$:表示取所有值
        $0$:表示随机取值
        $1$:表示取第1个
        $2$:表示取第二个
        以此类推:$n$:表示取第n个
    • 匹配数字:0代表随机取值,-1代表所有值,此时提取结果是一个数组,其余正整数代表第几个匹配的内容提取出来。如果匹配数字选择的是-1,还可以通过${token_1}的方式来取第1个匹配的内容,${token_2}来取第2个匹配的内容。
    • 缺省值:正则匹配失败时,取的值
    • 后续在其他接口要使用提取的token值,就使用{token}
    • 正则表达式中常用的关键字
      • 正则表达式使用特定字符作为关键字,这些字符对正则表达式引擎有特殊意义。在字符串中使用这些字符必须进行转义(使用反斜杠"\"),目的是将它们当成原始字符,而非正则表达式的关键字。下面是关键字和它们的含义: 

        ( ):组合。 

        [ ]:字符集合。 

        { }:重复。 

        + ?:重复。 

        .:任意匹配字符。 

        \:转义字符。 

        | -:选择符。 

        ^ $:字符串或行的起始和结尾。 

    1.3 进行关联

    接口返回的数据是json的话,使用json path extrator插件进行关联

    注意:使用json path extrator进行关联的时候,后置处理器指定提取的参数必须是实际存在的,不能是接口请求后没有返回的参数

     

    展开全文
  • BeanPostProcessor:bean后置处理器,bean创建对象初始化前后进行拦截工作...BeanFactoryPostProcessor是什么:beanFactory的后置处理器; * 在BeanFactory标准初始化之后调用,来定制和修改BeanFactory的内容; * ...

    BeanPostProcessor:bean后置处理器,bean创建对象初始化前后进行拦截工作的

    参考博客:Spring后置处理器之-BeanPostProcessor


    BeanFactoryPostProcessor是什么beanFactory的后置处理器;
     *         在BeanFactory标准初始化之后调用,来定制和修改BeanFactory的内容;
     *         所有的bean定义已经保存加载到beanFactory,但是bean的实例还未创建
     * 
    BeanFactoryPostProcessor原理:
     * 1)、ioc容器创建对象
     * 2)、invokeBeanFactoryPostProcessors(beanFactory);
     *         如何找到所有的BeanFactoryPostProcessor并执行他们的方法;
     *             1)、直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件,并执行他们的方法
     *             2)、在初始化创建其他组件前面执行


    BeanDefinitionRegistryPostProcessor是什么:
                BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor
     *         postProcessBeanDefinitionRegistry();
     *         在所有bean定义信息将要被加载,bean实例还未创建的时候加载;
     * 
     *         优先于BeanFactoryPostProcessor执行;
     *         利用BeanDefinitionRegistryPostProcessor给容器中再额外添加一些组件;
     * 
    BeanDefinitionRegistryPostProcessor原理:
     *         1)、ioc创建对象
     *         2)、refresh()-》invokeBeanFactoryPostProcessors(beanFactory);
     *         3)、从容器中获取到所有的BeanDefinitionRegistryPostProcessor组件。
     *             1、依次触发所有的postProcessBeanDefinitionRegistry()方法
     *             2、再来触发postProcessBeanFactory()方法BeanFactoryPostProcessor;
     * 
     *         4)、再来从容器中找到BeanFactoryPostProcessor组件;然后依次触发postProcessBeanFactory()方法


    注意执行顺序:BeanDefinitionRegistryPostProcessor优先于BeanFactoryPostProcessor执行,BeanFactoryPostProcessor优先于bean实例化执行;

    测试:

    1、新建MyBeanDefinitionRegistryPostProcessor .java类

    package com.atguigu.ext;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.beans.factory.support.AbstractBeanDefinition;
    import org.springframework.beans.factory.support.BeanDefinitionBuilder;
    import org.springframework.beans.factory.support.BeanDefinitionRegistry;
    import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
    import org.springframework.beans.factory.support.RootBeanDefinition;
    import org.springframework.stereotype.Component;
    
    import com.atguigu.bean.Blue;
    
    @Component
    public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor{
    
    	@Override
    	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    		// TODO Auto-generated method stub
    		System.out.println("MyBeanDefinitionRegistryPostProcessor...bean的数量:"+beanFactory.getBeanDefinitionCount());
    	}
    
    	//BeanDefinitionRegistry Bean定义信息的保存中心,以后BeanFactory就是按照BeanDefinitionRegistry里面保存的每一个bean定义信息创建bean实例;
    	@Override
    	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    		// TODO Auto-generated method stub
    		System.out.println("postProcessBeanDefinitionRegistry...bean的数量:"+registry.getBeanDefinitionCount());
    		//RootBeanDefinition beanDefinition = new RootBeanDefinition(Blue.class);
    		AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(Blue.class).getBeanDefinition();
    		registry.registerBeanDefinition("hello", beanDefinition);
    	}
    
    }
    

    2、新建MyBeanFactoryPostProcessor.java类

    package com.atguigu.ext;
    
    import java.util.Arrays;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.stereotype.Component;
    
    @Component
    public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    
    	@Override
    	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    		System.out.println("MyBeanFactoryPostProcessor...postProcessBeanFactory...");
    		int count = beanFactory.getBeanDefinitionCount();
    		String[] names = beanFactory.getBeanDefinitionNames();
    		System.out.println("当前BeanFactory中有"+count+" 个Bean");
    		System.out.println(Arrays.asList(names));
    	}
    
    }
    

    3、新建配置类

    @ComponentScan("com.atguigu.ext")
    @Configuration
    public class ExtConfig {
    	
    	@Bean
    	public Blue blue(){
    		return new Blue();
    	}
    
    }

    4、测试

    package com.atguigu.test;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationEvent;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    import com.atguigu.ext.ExtConfig;
    
    public class IOCTest_Ext {
    	
    	@Test
    	public void test01(){
    		AnnotationConfigApplicationContext applicationContext  = new AnnotationConfigApplicationContext(ExtConfig.class);
    		
    		applicationContext.close();
    	}
    
    }
    

    测试结果: 

    说明:按执行顺序1,2,3,说明BeanDefinitionRegistryPostProcessor优先于BeanFactoryPostProcessor执行,BeanFactoryPostProcessor优先于bean实例化执行; 

     

    ======以下于你或许是个好消息======

     

    好消息就是:欢迎访问下面的博客网站哈哈哈......

     

    网站名称:Java学习笔记网 (点击进入)

    url:https://www.javaxxbj.com/ (点击进入)

    网站特点:

    1. java主要网站的导航目录
    2. 你可以记录自己的博客,并可以控制显示和隐藏,可利于管理啦!!!
    3. 可以添加收藏各个网站的链接!!!
    4. 甚至也可以文章收藏,点赞,关注,查看我的消息等功能哦!!1

    看一小点点的截图:

    或可一试哦!

    展开全文
  • 首先要提到的是Bean的后置处理器与之前的初始化方法与销毁方法有什么区别呢,其实后置处理器的粒度要比初始化方法小,因为后置处理器是在bean初始化方法调用的前后做相关操作的。具体详细的介绍在代码中的注释都有...

    Spring注解驱动开发 第十节Bean的后置处理器

    首先要提到的是Bean的后置处理器与之前的初始化方法与销毁方法有什么区别呢,其实后置处理器的粒度要比初始化方法小,因为后置处理器是在bean初始化方法调用的前后做相关操作的。具体详细的介绍在代码中的注释都有介绍。

    /**
     * Bean后置处理器
     */
    @Component
    public class MyBeanPostProessor implements BeanPostProcessor{
    
        /**
         * 参数bean就是我们注册的实例,beanName就是实例的名称。
         * 返回值可以返回参数bean,也可以把参数bean包装后进行返回。
         * 后置处理器是在初始化方法调用时的前后添加相关操作的。
         * postProcessBeforeInitialization在我们以前学过的JSR250、initMethod方法之前调用。
         * 而postProcessAfterInitialization是在之后调用。
         */
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("postProcessBeforeInitialization  ....."+beanName);
            return bean;
        }
    
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("postProcessAfterInitialization  ....."+beanName);
            return bean;
        }
    }
    

    其中postProcessBeforeInitialization是在初始化之前调用,postProcessAfterInitialization在初始化之后调用。
    查看打印结果:

    四月 23, 2019 3:36:21 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext prepareRefresh
    信息: Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@2f410acf: startup date [Tue Apr 23 15:36:21 GMT+08:00 2019]; root of context hierarchy
    postProcessBeforeInitialization  .....org.springframework.context.event.internalEventListenerProcessor
    postProcessAfterInitialization  .....org.springframework.context.event.internalEventListenerProcessor
    postProcessBeforeInitialization  .....org.springframework.context.event.internalEventListenerFactory
    postProcessAfterInitialization  .....org.springframework.context.event.internalEventListenerFactory
    postProcessBeforeInitialization  .....mainConfig4
    postProcessAfterInitialization  .....mainConfig4
    black构造器被调用了....
    postProcessBeforeInitialization  .....black
    black afterPropertiesSet ...
    postProcessAfterInitialization  .....black
    Dog 默认构造器加载了...
    postProcessBeforeInitialization  .....dog
    Dog @PostConstruct ...
    postProcessAfterInitialization  .....dog
    Blue被加载到spring容器中了...
    postProcessBeforeInitialization  .....blue
    Blue init...
    postProcessAfterInitialization  .....blue
    org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalRequiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    mainConfig4
    black
    dog
    myBeanPostProessor
    blue
    Blue destory...
    Dog destory ...
    black destroy ...
    四月 23, 2019 3:36:21 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext doClose
    信息: Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@2f410acf: startup date [Tue Apr 23 15:36:21 GMT+08:00 2019]; root of context hierarchy
    
    Process finished with exit code 0
    

    可以看到,bean的任何初始化方法调用前都会调用bean的后置处理器,这也证实了我们之前说的完全正确。

    下面就来说一下bean后置处理器的原理

    在这里插入图片描述
    首先在后置处理器上打上断点,debug运行一下,我们查看一下方法调用栈。
    在这里插入图片描述
    我们的运行起点在test05上,经过spring的层层调用,我们把调用方法锁定在initializeBean上,点击它。
    在这里插入图片描述
    但是在这个之前的上一层有一个doCreateBean方法调用了这个方法
    在这里插入图片描述
    从这两张图看得出,是先给bean属性赋值,然后在进行bean后置处理器操作与初始化方法调用操作。当我们点击applyBeanPostProcessorsBeforeInitialization方法,也是上图的初始化方法调用之前的后置处理器方法调用。
    在这里插入图片描述
    上图就不用多说什么了,我们重写的方法被spring调用了。

    展开全文
  • 现了spring后置处理器beanpostprocessor。为什么说beanpostprocessor重要的呢?我们先来看看 他的作用。 BeanPostProcessor接口作用: 如果我们想在Spring容器中完成bean实例化、配置以及其他初始化方法前后要...
  • ⑥registerBeanPostProcessors() 注册(实例化)后置处理器 我们想要了解spring在什么时候注册自动代理,即@...实例化在registerBeanPostProcessor注册后置处理器阶段完成的。 public abstract class Abstra
  • 一、在调用注册后置处理器方法之前我们先看看截至当前,服务内总共有哪些后置处理器,都什么时机下被放到容器的什么地方 001 、加载系统默认beanDefinition 这个文章里面我们可以看到,首先加入的beanDefinition...
  • 简介调用顺序:在Bean的初始化前后调用,分别对应了其中的两个方法Bean的后置处理器对应的接口BeanPostProcessor,其中定义了两个方法,如下:public interface BeanPostProcessor { /** * 在Bean初始化之前...
  • 前置处理器 在发出取样器请求前执行一些操作 用的比较多的:设置一些...有什么后置处理器 后面,我们会对每个常用的前置、后置处理器单独讲解哦! 转自:https://www.cnblogs.com/poloyy/p/13153903.html ...
  • 学习spring源码也有一阶段时间了...但是看看源码之后,我觉得spring的后置处理器真牛逼,大名鼎鼎的AOP就利用了BeanPostProcessor和IOC容器建立了联系。不知道几个spring的后置处理器,你真不好意思说你学过spring。...
  • Jmeter后置处理器

    2017-09-18 22:51:00
    一、什么是关联? 将请求1的输出 作为 请求2 的输入,则称之为关联 例如:“用户登录”请求中服务器返回了token,“查询用户信息”请求需要把token返回给服务器进行验证 二、通过JSON Path Extrator进行关联 ...
  • 在 refresh() 方法里,invokeBeanFactoryPostProcessors(beanFactory...什么是 Bean 工厂后置处理器呢? 顾名思义,在创建了 Bean 工厂后,可以对 Bean 工厂进行处理。 接下来跟源码: 类 AbstractApplicationContex...
  • BeanPostProcessor(Bean后置处理器)常用在对bean内部的值进行修改;实现Bean的动态代理等。  BeanFactoryPostProcessor和BeanPostProcessor都spring初始化bean时对外暴露的扩展点。但它们有什么区别呢?  由...
  • 疑惑 @Configuraction注解的作用是什么,Spring是如何解析加了@Configuraction...ConfigurationClassPostProcessor 是一个BeanFactory的后置处理器,因此它的主要功能是参与BeanFactory的建造。在这个类中,会解析加
  • 1 是什么 是一种干预Bean工厂(DefaultListableBeanFactory)初始化过程的处理器,Bean工厂的初始化包括Bean工厂的属性设置,以及每一个Bean对应的BeanDefinition对象的实例化和初始化,代理的完成等等。 2 两个顶级...
  • 在调⽤初始化⽅法前后对 Bean 进⾏额外加⼯,ApplicationContext 会⾃动扫描实现了 BeanPostProcessor的 bean,并注册这些 bean 为后置处理器 Bean的统⼀前置后置处理⽽不是基于某⼀个bean 2.执⾏顺序 Spring IOC...
  • 文章目录BeanPostProcessor 有什么用Demo运行结果总结代码参考 BeanPostProcessor 有什么用 BeanPostProcessorSpring IOC容器给我们提供的一个扩展接口。 public interface BeanPostProcessor { @Nullable ...
  • 本文的主要重点在换行,这个也经过好几次试验最终得出来再jmeter中换行符与java语言中换行符不一致 标红框的部分第一次试验,\r回车\n换行的意思,按照jmeter...原因不知道为什么,询问开发的 windows --...
  • AnnotationAwareAspectJAutoProxyCreator后置器的作用是什么? Spring AOP自动增强bean是如何实现的。 如何在spring上下文添加AnnotationAwareAspectJAutoProxyCreator? 如何利用ProxyFactory硬编码实现一个bean的...
  • 通过bean工厂后置处理器我们还可以在初始化时进行一些额外的操作。 在这篇文章中,来介绍下bean factory post processor。在第一部分,我们来发现下这个概念背后玄机。之后我们会写一些有趣代码来让大伙更好地理解...
  • 写在前面 前一讲中,我们一步一步分析到了AbstractAutoProxyCreator抽象类的...那么,在这一讲中,我们就来看看AnnotationAwareAspectJAutoProxyCreator作为后置处理器,它的postProcessBefore
  • 上篇说到的BeanPostProcessor(Bean后置处理器)常用在对bean内部的值进行修改;实现Bean的动态代理等。 BeanFactoryPostProcessor和BeanPostProcessor都spring初始化bean时对外暴露的扩展点。但它们有什么区别呢?...
  • spring-BeanFactoryPostProcessor有什么功能呢。他能改变bean在实例化之前的一些原注解值,比如单例变原型,手动减轻BeanFactory的工作压力。 原注解指spring默认为bean装配的注解比如:@Scope,@lazy,@Primary,...
  • 本文能帮你解答的问题 @PostConstruct和@PreDestroy注解标注的方法是在什么阶段调用的? @Resource是如何完成属性自动注入的? @Resource相比@Autowired查找候选者的过程差异是什么
  • ConfigurationClassPostProcessor的作用是什么? @Configuration、@Component、@ComponentScan、@ComponentScans、@Bean、@Import等注解是如何完成bean注册的? @Conditional注解如何控制配置类是否需要解析? @...
  • 在使用Jmeter进行接口测试、性能测试时,经常...那么什么是关联呢?简而言之,就是解决接口请求之间的依赖关系。在Jmeter中,解决关联问题则首先会考虑到正则表达式提取器。下面我将对正则表达式提取器的用法进行讲解。
  • 让我觉得奇怪的,作者没有放出每个提取器里写了什么,为啥用一段XML的报文能测这么多提取器 实验了一下发现,作者的测试方法就是提取器里什么都不写 当且仅当什么都没写时,作者的结论才正确的…… 但如果...
  • ​ 在调用初始化方法前后对Bean进行额外加功,AppliactionContext会自动扫描实现了BeanPostProcessord的bean,并注册这些bean为后置处理器Bean的统一前置处理器而不是基于某一个bean。和之前讲的init和destroy...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 134
精华内容 53
关键字:

后置处理器是什么