spring-注解----ext

时间 2019-11-12

标签 spring 注解 ext 栏目 Spring 繁體版

原文原文链接

spring-注解----extjava

package com.zwj.ext;

public class Blue {
    
    public Blue(){
        System.out.println("blue...constructor");
    }
    
    public void init(){
        System.out.println("blue...init...");
    }
    
    public void detory(){
        System.out.println("blue...detory...");
    }
    
    

}

Blue

package com.zwj.ext;

import java.util.concurrent.Executor;

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextClosedEvent;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.SimpleApplicationEventMulticaster;


/**
 * 扩展原理：
 * BeanPostProcessor：bean后置处理器，bean建立对象初始化先后进行拦截工做的
 * 
 * 一、BeanFactoryPostProcessor：beanFactory的后置处理器；
 *         在BeanFactory标准初始化以后调用，来定制和修改BeanFactory的内容；
 *         全部的bean定义已经保存加载到beanFactory，可是bean的实例还未建立
 * 
 * 
 * BeanFactoryPostProcessor原理:
 * 1)、ioc容器建立对象
 * 2)、invokeBeanFactoryPostProcessors(beanFactory);
 *         如何找到全部的BeanFactoryPostProcessor并执行他们的方法；
 *             1）、直接在BeanFactory中找到全部类型是BeanFactoryPostProcessor的组件，并执行他们的方法
 *             2）、在初始化建立其余组件前面执行
 * 
 * 二、BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor
 *         postProcessBeanDefinitionRegistry();
 *         在全部bean定义信息将要被加载，bean实例还未建立的；
 * 
 *         优先于BeanFactoryPostProcessor执行；
 *         利用BeanDefinitionRegistryPostProcessor给容器中再额外添加一些组件；
 * 
 *     原理：
 *         1）、ioc建立对象
 *         2）、refresh()-》invokeBeanFactoryPostProcessors(beanFactory);
 *         3）、从容器中获取到全部的BeanDefinitionRegistryPostProcessor组件。
 *             一、依次触发全部的postProcessBeanDefinitionRegistry()方法
 *             二、再来触发postProcessBeanFactory()方法BeanFactoryPostProcessor；
 * 
 *         4）、再来从容器中找到BeanFactoryPostProcessor组件；而后依次触发postProcessBeanFactory()方法
 *     
 * 三、ApplicationListener：监听容器中发布的事件。事件驱动模型开发；
 *       public interface ApplicationListener<E extends ApplicationEvent>
 *         监听 ApplicationEvent 及其下面的子事件；
 * 
 *      步骤：
 *         1）、写一个监听器（ApplicationListener实现类）来监听某个事件（ApplicationEvent及其子类）
 *             @EventListener;
 *             原理：使用EventListenerMethodProcessor处理器来解析方法上的@EventListener；
 * 
 *         2）、把监听器加入到容器；
 *         3）、只要容器中有相关事件的发布，咱们就能监听到这个事件；
 *                 ContextRefreshedEvent：容器刷新完成（全部bean都彻底建立）会发布这个事件；
 *                 ContextClosedEvent：关闭容器会发布这个事件；
 *         4）、发布一个事件：
 *                 applicationContext.publishEvent()；
 *     
 *  原理：
 *      ContextRefreshedEvent、IOCTest_Ext$1[source=我发布的时间]、ContextClosedEvent；
 *  1）、ContextRefreshedEvent事件：
 *      1）、容器建立对象：refresh()；
 *      2）、finishRefresh();容器刷新完成会发布ContextRefreshedEvent事件
 *  2）、本身发布事件；
 *  3）、容器关闭会发布ContextClosedEvent；
 *  
 *  【事件发布流程】：
 *      3）、publishEvent(new ContextRefreshedEvent(this));
 *              1）、获取事件的多播器（派发器）：getApplicationEventMulticaster()
 *              2）、multicastEvent派发事件：
 *              3）、获取到全部的ApplicationListener；
 *                  for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
 *                  1）、若是有Executor，能够支持使用Executor进行异步派发；
 *                      Executor executor = getTaskExecutor();
 *                  2）、不然，同步的方式直接执行listener方法；invokeListener(listener, event);
 *                   拿到listener回调onApplicationEvent方法；
 *  
 *  【事件多播器（派发器）】
 *      1）、容器建立对象：refresh();
 *      2）、initApplicationEventMulticaster();初始化ApplicationEventMulticaster；
 *          1）、先去容器中找有没有id=“applicationEventMulticaster”的组件；
 *          2）、若是没有this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
 *              而且加入到容器中，咱们就能够在其余组件要派发事件，自动注入这个applicationEventMulticaster；
 *  
 *  【容器中有哪些监听器】
 *      1）、容器建立对象：refresh();
 *      2）、registerListeners();
 *          从容器中拿到全部的监听器，把他们注册到applicationEventMulticaster中；
 *          String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
 *          //将listener注册到ApplicationEventMulticaster中
 *          getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
 *          
 *   SmartInitializingSingleton 原理：->afterSingletonsInstantiated();
 *           1）、ioc容器建立对象并refresh()；
 *           2）、finishBeanFactoryInitialization(beanFactory);初始化剩下的单实例bean；
 *               1）、先建立全部的单实例bean；getBean();
 *               2）、获取全部建立好的单实例bean，判断是不是SmartInitializingSingleton类型的；
 *                   若是是就调用afterSingletonsInstantiated();
 *         
 * 
 *
 */
@ComponentScan("com.zwj.ext")
@Configuration
public class ExtConfig {
    
    @Bean
    public Blue blue(){
        return new Blue();
    }

}

ExtConfig

package com.zwj.ext;

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

//@Component
public class MyApplicationListener implements ApplicationListener<ApplicationEvent> {

    //当容器中发布此事件之后，方法触发
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        // TODO Auto-generated method stub
        System.out.println("收到事件："+event);
    }

}

MyApplicationListener

package com.zwj.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.stereotype.Component;


//@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);
    }

}

MyBeanDefinitionRegistryPostProcessor

package com.zwj.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));
    }

}

MyBeanFactoryPostProcessor

package com.zwj.ext;

import org.springframework.context.ApplicationEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    
    @EventListener(classes={ApplicationEvent.class})
    public void listen(ApplicationEvent event){
        System.out.println("UserService。。监听到的事件："+event);
    }

}

UserService

package com.zwj.test;

import org.junit.Test;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.zwj.ext.ExtConfig;


public class IOCTest_Ext {
    
    @Test
    public void test01(){
        AnnotationConfigApplicationContext applicationContext  = new AnnotationConfigApplicationContext(ExtConfig.class);
        
        
        //发布事件；
        applicationContext.publishEvent(new ApplicationEvent(new String("我发布的时间")) {
        });
        
        applicationContext.close();
    }

}


/*
blue...constructor
UserService。。监听到的事件：org.springframework.context.event.ContextRefreshedEvent[source=org.springframework.context.annotation.AnnotationConfigApplicationContext@11028347: startup date [Sun Oct 28 13:24:35 CST 2018]; root of context hierarchy]
UserService。。监听到的事件：com.zwj.test.IOCTest_Ext$1[source=我发布的时间]
UserService。。监听到的事件：org.springframework.context.event.ContextClosedEvent[source=org.springframework.context.annotation.AnnotationConfigApplicationContext@11028347: startup date [Sun Oct 28 13:24:35 CST 2018]; root of context hierarchy]
*/

IOCTest_Ext

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.zwj</groupId>
  <artifactId>spring-annotation---ext</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.12.RELEASE</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.3.12.RELEASE</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.3.12.RELEASE</version>
        </dependency>
        
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.inject/javax.inject -->
        <dependency>
            <groupId>javax.inject</groupId>
            <artifactId>javax.inject</artifactId>
            <version>1</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/c3p0/c3p0 -->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.44</version>
        </dependency>





    </dependencies>
</project>

pom.xml