实战@Import注解 加事件监听模式[杂乱]

@Java110ListenerDiscovery(
        listenerPublishClass = ServiceDataFlowEventPublishing.class,
        basePackages = {"com.lvhao.api.listener"})
public class ApiApplicationStart {
    public static void main(String[] args) {
        SpringApplication.run(ApiApplicationStart.class);
    }

处理 Java110ListenerDiscovery注解	
package com.java110.core.annocation;


import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;

import java.beans.Introspector;
import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * 自定义侦听扫描
 * Created by wuxw on 2018/7/2.
 */
public class Java110ListenerDiscoveryRegistrar
        implements ImportBeanDefinitionRegistrar,
        ResourceLoaderAware, BeanClassLoaderAware {

    private ResourceLoader resourceLoader;

    private ClassLoader classLoader;

    public Java110ListenerDiscoveryRegistrar(){

    }

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        try {
            registerListener(importingClassMetadata,registry);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    /**
     * 注册侦听
     * @param metadata
     * @param registry
     */
    public void registerListener(AnnotationMetadata metadata,
                                 BeanDefinitionRegistry registry) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        ClassPathScanningCandidateComponentProvider scanner = getScanner();

        scanner.setResourceLoader(this.resourceLoader);
        Set<String> basePackages;
        Map<String, Object> attrs = metadata
                .getAnnotationAttributes(Java110ListenerDiscovery.class.getName());

        Object listenerPublishClassObj =  attrs.get("listenerPublishClass");

        Assert.notNull(listenerPublishClassObj,"Java110ListenerDiscovery 没有配置 listenerPublishClass 属性");

        Class<?> listenerPublishClass = (Class<?>) listenerPublishClassObj;

        AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
                Java110Listener.class);

        scanner.addIncludeFilter(annotationTypeFilter);
        basePackages = getBasePackages(metadata);

        for (String basePackage : basePackages) {
            Set<BeanDefinition> candidateComponents = scanner
                    .findCandidateComponents(basePackage);
            for (BeanDefinition candidateComponent : candidateComponents) {
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
                    // verify annotated class is an interface
                    AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                    AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();

                    Map<String, Object> attributes = annotationMetadata
                            .getAnnotationAttributes(
                                    Java110Listener.class.getCanonicalName());

                    String beanName = getListenerName(attributes,beanDefinition);

                    /*BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
                    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);*/
                    Method method = listenerPublishClass.getMethod("addListener",String.class);
                    method.invoke(beanName,null);

                }
            }
        }
    }

    protected ClassPathScanningCandidateComponentProvider getScanner() {
        return new ClassPathScanningCandidateComponentProvider(false) {

            @Override
            protected boolean isCandidateComponent(
                    AnnotatedBeanDefinition beanDefinition) {
                if (beanDefinition.getMetadata().isIndependent()) {
                    // TODO until SPR-11711 will be resolved
                    if (beanDefinition.getMetadata().isInterface()
                            && beanDefinition.getMetadata()
                            .getInterfaceNames().length == 1
                            && Annotation.class.getName().equals(beanDefinition
                            .getMetadata().getInterfaceNames()[0])) {
                        try {
                            Class<?> target = ClassUtils.forName(
                                    beanDefinition.getMetadata().getClassName(),
                                   Java110ListenerDiscoveryRegistrar.this.classLoader);
                            return !target.isAnnotation();
                        }
                        catch (Exception ex) {
                            this.logger.error(
                                    "Could not load target class: "
                                            + beanDefinition.getMetadata().getClassName(),
                                    ex);

                        }
                    }
                    return true;
                }
                return false;

            }
        };
    }

    protected Set<String> getBasePackages(AnnotationMetadata importingClassMetadata) {
        Map<String, Object> attributes = importingClassMetadata
                .getAnnotationAttributes(Java110ListenerDiscovery.class.getCanonicalName());

        Set<String> basePackages = new HashSet<String>();
        for (String pkg : (String[]) attributes.get("value")) {
            if (StringUtils.hasText(pkg)) {
                basePackages.add(pkg);
            }
        }
        for (String pkg : (String[]) attributes.get("basePackages")) {
            if (StringUtils.hasText(pkg)) {
                basePackages.add(pkg);
            }
        }
        if (basePackages.isEmpty()) {
            basePackages.add(
                    ClassUtils.getPackageName(importingClassMetadata.getClassName()));
        }
        return basePackages;
    }


    /**
     * 获取名称
     * @param listeners
     * @param beanDefinition
     * @return
     */
    private String getListenerName(Map<String, Object> listeners, AnnotatedBeanDefinition beanDefinition) {
        if (listeners == null) {
            String shortClassName = ClassUtils.getShortName(beanDefinition.getBeanClassName());
            return Introspector.decapitalize(shortClassName);
        }
        String value = (String) listeners.get("value");
        if (!StringUtils.hasText(value)) {
            value = (String) listeners.get("name");
        }
        if (StringUtils.hasText(value)) {
            return value;
        }

        String shortClassName = ClassUtils.getShortName(beanDefinition.getBeanClassName());
        value = Introspector.decapitalize(shortClassName);
        return value;
    }


}

package com.java110.core.annocation;

import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

/**
 * 侦听注入
 * Created by wuxw on 2018/7/2.
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(Java110ListenerDiscoveryRegistrar.class)
public @interface Java110ListenerDiscovery {

    String[] basePackages() default {};

    String[] value() default {};

    Class<?> listenerPublishClass();
}

package com.java110.core.annocation;

import org.springframework.core.annotation.AliasFor;
import org.springframework.stereotype.Component;

import java.lang.annotation.*;

/**
 * Created by wuxw on 2018/7/2.
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Java110Listener {
    @AliasFor("name")
    String value() default "";

    @AliasFor("value")
    String name() default "";
}

// 数据流事件发布
public class ServiceDataFlowEventPublish {
    private static final Map<String, List<ServiceListener>> cacheListenerMap = new HashMap<String, List<ServiceListener>>();
    /**
     * 保存侦听实例信息，一般启动时加载
     */
    private static final List<String> listeners = new ArrayList<String>();
    private static Executor taskExecutor;

    /**
     * 添加 侦听，这个只有启动时，单线程 处理，所以是线程安全的
     *
     * @param listener
     */
    public static void addListener(String listener) {
        listeners.add(listener);
    }

    public static List<String> getListeners() {
        return listeners;
    }
    public static void multicastEvent(String police, String asyn) throws Exception{
        List<ServiceListener>listeners = getListener(police);
        if ("A".equals(asyn)) {
            Executor executor = getTaskExecutor();
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    try {

                        // 一个线程池
                        invokeLisnerers(listeners, police);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        } else {
            invokeLisnerers(listeners, police);
        }


    }

    private static synchronized Executor getTaskExecutor() {
        if (  null==taskExecutor) {
            taskExecutor = Executors.newFixedThreadPool(4);
        }
        return taskExecutor;
    }

    private static void invokeLisnerers(List<ServiceListener> listeners, String police) throws InterruptedException {
        for (ServiceListener listener : listeners) {
            listener.invokeMethod(police);
        }
    }

    private static List<ServiceListener> getListener(String police) {
        if (cacheListenerMap.containsKey(police)) {
            return cacheListenerMap.get(police);
        }
      List<ServiceListener> serviceListener = new ArrayList<>();
        for (String listenerBeanName : getListeners()) {
            ServiceListener listener = ApplicationContextFactory.getBean(listenerBeanName, ServiceListener.class);
            serviceListener.add(listener);

        }
        if(!serviceListener.isEmpty())
            cacheListenerMap.put(police,serviceListener);
        return serviceListener;
    }
}

详情参考 大佬git地址
https://gitee.com/java110/MicroCommunityWeb.git