package cn.com.xxxx.service.impl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.SingletonBeanRegistry;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor;
import org.springframework.stereotype.Service;

import java.lang.reflect.Method;
import java.util.Set;

@Service
public class ScheduledBeanInitializer implements ApplicationListener<ContextRefreshedEvent> {

    private static final Logger logger = LoggerFactory.getLogger("xxxInfo");

    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {

        //spring context才执行，springMvc context不执行
        final ApplicationContext context = contextRefreshedEvent.getApplicationContext();
        if (context.getParent() != null) {
            return;
        }

        new Thread() {
            @Override
            public void run() {

                //休息10秒
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                logger.info("ScheduledBeanInitializer开始执行........");
                ScheduledAnnotationBeanPostProcessor postProcessor = context.getBean(ScheduledAnnotationBeanPostProcessor.class);
                try {
                    //查找包含@Lazy注解的类
                    ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
                    provider.addIncludeFilter(new AnnotationTypeFilter(Lazy.class));

                    //遍历类
                    Set<BeanDefinition> beanDefinitionSet = provider.findCandidateComponents("cn.xxx");
                    logger.info("查找cn.xxx下有@Lazy注解的类：" + beanDefinitionSet.size() + "个。");
                    for (BeanDefinition beanDefinition : beanDefinitionSet) {
                        try {
                            // 检查类的方法上是否有@Scheduled注解
                            Class<?> beanClass = Class.forName(beanDefinition.getBeanClassName());
                            if (isScheduledPresent(beanClass)) {

                                //@Lazy(true)的
                                Lazy lazyAnnotation = beanClass.getAnnotation(Lazy.class);
                                if (lazyAnnotation != null && lazyAnnotation.value()) {

                                    //初始化Bean
                                    try {
                                        AutowireCapableBeanFactory autowireCapableBeanFactory = context.getAutowireCapableBeanFactory();
                                        if (autowireCapableBeanFactory instanceof SingletonBeanRegistry) {
                                            //没有实例存在，才创建
                                            boolean isLoaded = ((SingletonBeanRegistry) autowireCapableBeanFactory).containsSingleton(beanDefinition.getBeanClassName());
                                            if (!isLoaded) {
                                                Object beanInstance = context.getBean(beanClass);
                                                logger.info("已初始化Bean:" + beanInstance.toString());

                                                //注册定时任务
                                                postProcessor.postProcessAfterInitialization(beanInstance, beanClass.getName());
                                            }
                                        }
                                    } catch (Exception e) {
                                        logger.error("初始化Bean时出错:", e);
                                    }
                                }
                            }

                        } catch (Exception e) {
                            logger.error("检测Bean定义时出错:", e);
                        }
                    }
                } catch (Exception e) {
                    logger.error("ScheduledBeanInitializer执行出错", e);
                }
                //添加为调度
                postProcessor.afterSingletonsInstantiated();
                logger.info("ScheduledBeanInitializer执行结束........");
            }
        }.start();
        logger.info("ScheduledBeanInitializer 直接返回，新线程负责创建Bean");
    }

    /**
     * 类的Method上是否有@Scheduled注解
     *
     * @param beanClass 类
     * @return
     */
    private boolean isScheduledPresent(Class<?> beanClass) {
        // 获取类中所有声明的方法
        Method[] methods = beanClass.getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(Scheduled.class)) {
                return true;
            }
        }
        return false;
    }
}