@Component
@Slf4j
public class TimeCostPriorityOrderedBeanPostProcessor implements BeanPostProcessor, PriorityOrdered {


    private Map<String, Long> costMap = Maps.newConcurrentMap();


    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        costMap.put(beanName, System.currentTimeMillis());
        return bean;
    }


    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (costMap.containsKey(beanName)) {
            Long start = costMap.get(beanName);
            long cost = System.currentTimeMillis() - start;
            if (cost > 50) {
                log.info("==>Before方法耗時(shí)beanName:{},操作耗時(shí):{}", beanName, cost);
            }
        }
        return bean;
    }


    @Override
    public int getOrder() {
        return Integer.MIN_VALUE;
    }
}

@Component
@Slf4j
public class ZBeanPostProcessor implements BeanPostProcessor {


    private Map<String, Long> costMap = Maps.newConcurrentMap();


    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        costMap.put(beanName, System.currentTimeMillis());
        return bean;
    }


    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (costMap.containsKey(beanName)) {
            Long start = costMap.get(beanName);
            long cost = System.currentTimeMillis() - start;
            if (cost > 50) {
                log.info("==>After方法耗時(shí)beanName:{},操作耗時(shí):{}", beanName, cost);
            }
        }
        return bean;
    }
}

@SneakyThrows
    @Override
    public Object postProcessBeforeInitialization(@NonNull Object bean, String beanName) throws BeansException {
        if (this.isMatchPackage(bean)) {


            if (isProvider()) {
                this.scanProvider(bean, beanName);
            }


            if (isConsumer()) {
                this.scanConsumer(bean, beanName);
            }
        }
        return bean;
    }
    
    private void scanConsumer(Object bean, String beanName) {
        Class<?> beanClass = bean.getClass();
        Set<Field> fields = getFieldSetWithSuperClassFields(beanClass);


        for (Field field : fields) {
            boolean accessible = field.isAccessible();


            try {
                if (!accessible) {
                    field.setAccessible(true);
                }


                JsfConsumerTemplate jsfConsumerTemplate = null;
                JsfConsumer jsfConsumer = field.getAnnotation(JsfConsumer.class);
                if (jsfConsumer != null) {
                    jsfConsumerTemplate = convert(jsfConsumer, JsfConsumerTemplate.class);
                }


                if (jsfConsumerTemplate != null) {
                    logger.info("==> Final consumer config for JSF interface [{}]: {}", beanClass, JSON.toJSONString(jsfConsumerTemplate));
                    //生成客戶端配置
                    ConsumerConfig consumerConfig = this.parseAnnotationConsumer(jsfConsumerTemplate, field.getType());


                    addFilters(beanName, consumerConfig);
                    //觸發(fā)refer方法執(zhí)行，生成代理對象
                    Object ref = consumerConfig.refer();
                    if (ref != null) {
                        if (!this.beanFactory.containsSingleton(field.getName())) {
                            //將生成的對象注冊到spring容器
                            this.beanFactory.registerSingleton(field.getName(), consumerConfig);
                        }


                        Object fieldBean = beanFactory.getBean(field.getName());
                        try {
                            logger.info("JsfConsumer class {} field {} inject", bean.getClass().getSimpleName(), field.getName());
                            //將代理對象設(shè)置到對應(yīng)的屬性
                            field.set(bean, fieldBean);
                        } catch (IllegalAccessException exp) {
                            throw new InitErrorException("Set proxy to field error", exp);
                        }
                    }
                }
            } finally {
                if (!accessible) {
                    field.setAccessible(false);
                }


            }
        }
    }

public static final ThreadPoolExecutor CONSUMER_REFER = new ThreadPoolExecutor(
            32, 32,
            60, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(102400),
            ThreadFactories.create("JSF-REFER"),
            new ThreadPoolExecutor.CallerRunsPolicy());
            
    /**
     * 掃描當(dāng)前bean的所有屬性，查看該屬性是否攜帶有JsfConsumer注解，如果有的話，需要調(diào)用{@link ConsumerConfig#refer()}生成代理，
     * 該方法使用了異步線程池進(jìn)行操作，這樣可以不阻塞localhost線程的執(zhí)行
     * 在進(jìn)行導(dǎo)出之前使用了synchronized關(guān)鍵字鎖住當(dāng)前字段，防止出現(xiàn)并發(fā)，出現(xiàn)并發(fā)的情況可能是在兩個(gè)bean里面注入了同一個(gè)consumer導(dǎo)致
     * @param bean
     * @param beanName
     */
    private void scanConsumer(Object bean, String beanName) {
        Class<?> beanClass = bean.getClass();
        Set<Field> fields = getFieldSetWithSuperClassFields(beanClass);


        for (Field field : fields) {
            boolean accessible = field.isAccessible();
            //首先將需要處理的字段計(jì)數(shù)，防止在異步線程丟失
            REFER_COUNT.increment();
            Future<?> referFuture = CONSUMER_REFER.submit(() -> {
                try {
                    if (!accessible) {
                        field.setAccessible(true);
                    }
                    JsfConsumerTemplate jsfConsumerTemplate = null;
                    JsfConsumer jsfConsumer = field.getAnnotation(JsfConsumer.class);
                    if (jsfConsumer != null) {
                        jsfConsumerTemplate = convert(jsfConsumer, JsfConsumerTemplate.class);
                    }
                    if (jsfConsumerTemplate != null) {
                        //鎖住當(dāng)前字段,防止多線程并發(fā)導(dǎo)出導(dǎo)致異常
                        synchronized (field.getType()) {
                            logger.info("==> Final consumer config for JSF interface [{}]: {}", beanClass, JSON.toJSONString(jsfConsumerTemplate));
                            ConsumerConfig consumerConfig = this.parseAnnotationConsumer(jsfConsumerTemplate, field.getType());


                            addFilters(beanName, consumerConfig);
                            Object ref = consumerConfig.refer();
                            if (ref != null) {
                                if (!this.beanFactory.containsSingleton(field.getName())) {
                                    this.beanFactory.registerSingleton(field.getName(), consumerConfig);
                                }


                                Object fieldBean = beanFactory.getBean(field.getName());
                                try {
                                    logger.info("JsfConsumer class {} field {} inject", bean.getClass().getSimpleName(), field.getName());
                                    field.set(bean, fieldBean);
                                } catch (IllegalAccessException var18) {
                                    throw new InitErrorException("Set proxy to field error", var18);
                                }
                            }
                        }
                    }
                } finally {
                    if (!accessible) {
                        field.setAccessible(false);
                    }
                    //執(zhí)行完成后減1
                    REFER_COUNT.decrement();
                }
            });
            //加到future里面 會(huì)監(jiān)聽ContextRefreshedEvent判斷異步任務(wù)是否都已經(jīng)完成
            REFER_FUTURE.add(referFuture);
        }
    }
    
    /**
     * 監(jiān)聽容器刷新事件
     *
     * @param contextRefreshedEvent the event to respond to
     */
    @Override
    @Order(Ordered.LOWEST_PRECEDENCE)
    public synchronized void onApplicationEvent(@NonNull ContextRefreshedEvent contextRefreshedEvent) {
        logger.info("==> Ready for JSF consumer refer! Application name: {} count:{}", contextRefreshedEvent.getApplicationContext().getApplicationName(), REFER_FUTURE.size());
        CONSUMER_REFER.allowCoreThreadTimeOut(true);
        try {
            int i = 100;
            boolean isDone = false;
            while (i-- > 0) {
                if (REFER_COUNT.sum() == 0) {
                    isDone = true;
                    break;
                }
                Thread.sleep(100);
            }
            if (!isDone) {
                throw new InitErrorException(Strings.format("init jsf consumer error, undo sum :[{}]", REFER_COUNT.sum()));
            }
            for (Future<?> future : REFER_FUTURE) {
                future.get();
            }
        } catch (Exception exp) {
            // 在Web應(yīng)用中，容器可能是一個(gè)父子容器，因此關(guān)閉上下文時(shí)需要遞歸往上遍歷，把父容器也一起收拾掉
            logger.error("<== Exception while batch exporting JSF refer!", exp instanceof ApplicationException ? exp.getCause() : exp);
            ApplicationContext toClose = contextRefreshedEvent.getApplicationContext();
            while (toClose instanceof ConfigurableApplicationContext) {
                ApplicationContext parentApplicationContext = toClose.getParent();
                try {
                    ((ConfigurableApplicationContext) toClose).close();
                } catch (Exception closeExp) {
                    logger.error("<== Exception while close application context: {}", toClose.getDisplayName(), closeExp);
                }
                toClose = parentApplicationContext;
            }
            return;
        }
    }

/**
     * 根據(jù)config實(shí)例化所需的Reference實(shí)例<br/>
     * 返回的應(yīng)該是具備全操作能力的接口代理實(shí)現(xiàn)類對象
     *
     * @see org.springframework.beans.factory.FactoryBean#getObject()
     */
    @Override
    @JSONField(serialize = false)
    public T getObject() throws Exception {
        object = CommonUtils.isUnitTestMode() ? null : refer();
        return object;
    }

/**
 * 延遲導(dǎo)出的ConsumerBean
 * 該類的getObject方法會(huì)返回一個(gè)自定義的代理對象
 */
public class DelayConsumerBean<T> extends ConsumerConfig<T> implements InitializingBean, FactoryBean<T>, ApplicationContextAware, DisposableBean, BeanNameAware {


    private static final long serialVersionUID = 6835324481364430812L;


    private static final Logger LOGGER = LoggerFactory.getLogger(DelayConsumerBean.class);


    private ApplicationContext applicationContext;


    @Setter
    protected transient String beanName;


    private transient T object;


    private transient Class objectType;


    public static final List<Future<?>> REFER_FUTURE_LIST = Lists.newArrayList();


    public static final ThreadPoolExecutor CONSUMER_REFER_EXECUTOR = new ThreadPoolExecutor(
            32, 32,
            60, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(102400),
            ThreadFactories.create("JSF-REFER-2"),
            new ThreadPoolExecutor.CallerRunsPolicy());


    @JSONField(
            serialize = false
    )
    @SuppressWarnings("unchecked")
    public T getObject() throws Exception {
        Class<T> consumerInterfaceClass = ClassLoaderUtils.forName(this.interfaceId);
        //先生成一個(gè)代理對象
        T delayConsumer = (T) Proxy.newProxyInstance(
                consumerInterfaceClass.getClassLoader(),
                new Class[]{consumerInterfaceClass},
                new DelayConsumerInvocationHandler()
        );


        //使用異步線程refer
        REFER_FUTURE_LIST.add(CONSUMER_REFER_EXECUTOR.submit(() -> {
            super.refer();
        }));


        object = CommonUtils.isUnitTestMode() ? null : delayConsumer;
        //返回提前生成的代理對象
        return object;
    }


    private class DelayConsumerInvocationHandler implements InvocationHandler {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if (method.getDeclaringClass() == Object.class) {
                return method.invoke(DelayConsumerBean.this, args);
            }
            if (DelayConsumerBean.this.proxyIns == null) {
                throw new RuntimeException("DelayConsumerBean.this.proxyIns is null");
            }
            try {
                //客戶端發(fā)起調(diào)用后，觸發(fā)真實(shí)的consumer代理執(zhí)行
                return method.invoke(DelayConsumerBean.this.proxyIns, args);
            } catch (InvocationTargetException exp) {
                throw exp.getTargetException();
            } catch (Exception ex) {
                throw ApplicationException.mirrorOf(ex);
            }
        }
    }
    
     /**
     * 等待所有的任務(wù)完成，確保所有的consumer都refer成功了
     * @param contextRefreshedEvent
     */
    public static void waitForRefer(ContextRefreshedEvent contextRefreshedEvent) {
        CONSUMER_REFER_EXECUTOR.allowCoreThreadTimeOut(true);
        LOGGER.info("==> Ready for JSF consumer 2 refer! Application name: {} count:{}", contextRefreshedEvent.getApplicationContext().getApplicationName(), REFER_FUTURE_LIST.size());
        try {
            for (Future<?> future : REFER_FUTURE_LIST) {
                future.get();
            }
        } catch (Exception exp) {
            // 在Web應(yīng)用中，容器可能是一個(gè)父子容器，因此關(guān)閉上下文時(shí)需要遞歸往上遍歷，把父容器也一起關(guān)閉
            LOGGER.error("<== Exception while batch exporting JSF provider!", exp instanceof ApplicationException ? exp.getCause() : exp);
            ApplicationContext toClose = contextRefreshedEvent.getApplicationContext();
            while (toClose instanceof ConfigurableApplicationContext) {
                ApplicationContext parentApplicationContext = toClose.getParent();
                try {
                    ((ConfigurableApplicationContext) toClose).close();
                } catch (Exception closeExp) {
                    LOGGER.error("<== Exception while close application context: {}", toClose.getDisplayName(), closeExp);
                }
                toClose = parentApplicationContext;
            }
        }
    }




    protected DelayConsumerBean() {
    }


    public void setApplicationContext(ApplicationContext appContext) throws BeansException {
        this.applicationContext = appContext;
    }


}