org.zodiac.plugin.extension.ExtensionInitializer Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of zodiac-plugin Show documentation
Zodiac Plugin
There is a newer version: 1.6.8
package org.zodiac.plugin.extension;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.zodiac.commons.util.Colls;
import org.zodiac.plugin.factory.process.pipe.PluginPipeProcessorExtend;
import org.zodiac.plugin.factory.process.pipe.PluginPreProcessorExtend;
import org.zodiac.plugin.factory.process.pipe.bean.PluginBeanRegistrarExtend;
import org.zodiac.plugin.factory.process.pipe.classs.PluginClassGroupExtend;
import org.zodiac.plugin.factory.process.pipe.loader.PluginResourceLoader;
import org.zodiac.plugin.factory.process.post.PluginPostProcessorExtend;
import org.zodiac.sdk.toolkit.model.OrderPriority;
import org.zodiac.sdk.toolkit.util.collection.CollUtil;

import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 * 静态的扩展初始化器。
 */
public class ExtensionInitializer {

    private static final Logger LOG = LoggerFactory.getLogger(ExtensionInitializer.class);

    private static final AtomicBoolean IS_INIT = new AtomicBoolean(false);

    private static final List RESOURCE_LOADERS_EXTENDS = CollUtil.list();
    private static final List PIPE_PROCESSOR_EXTENDS = CollUtil.list();
    private static final List BEAN_REGISTRAR_EXTEND = CollUtil.list();
    private static final List CLASS_GROUP_EXTENDS = CollUtil.list();
    private static final List PRE_PROCESSOR_EXTENDS = CollUtil.list();
    private static final List POST_PROCESSOR_EXTENDS = CollUtil.list();

    private ExtensionInitializer() {
    }

    public static synchronized void initialize(ApplicationContext applicationContext, ExtensionFactory extensionWebFactory) {
        if (applicationContext == null) {
            LOG.error("ApplicationContext is null, cannot initialize");
            return;
        }
        if (IS_INIT.get()) {
            throw new RuntimeException("The extension has been initialized");
        }
        Map pluginExtensionMap = extensionWebFactory.getPluginExtensions();
        for (Map.Entry entry : pluginExtensionMap.entrySet()) {
            PluginExtension pluginExtension = entry.getValue();
            if (pluginExtension == null) {
                continue;
            }
            try {
                pluginExtension.initialize(applicationContext);
                initialize(pluginExtension, applicationContext);
            } catch (Exception e) {
                LOG.error("Plugin extension '{}' initialize exception. {}", pluginExtension.key(), e.getMessage(), e);
            }
        }
        IS_INIT.set(true);
    }

    private static void initialize(PluginExtension pluginExtension, ApplicationContext applicationContext) {
        StringBuilder debug = new StringBuilder();
        debug.append("Plugin extension '").append(pluginExtension.key()).append("'").append(" are [");
        iteration(pluginExtension.getPluginResourceLoader(), extend -> {
            RESOURCE_LOADERS_EXTENDS.add(extend);
            debug.append(extend.key()).append("、");
        }, bean -> bean.order());

        iteration(pluginExtension.getPluginPreProcessor(applicationContext), extend -> {
            PRE_PROCESSOR_EXTENDS.add(extend);
            debug.append(extend.key()).append("、");
        }, bean -> bean.order());

        iteration(pluginExtension.getPluginBeanRegistrar(applicationContext), extend -> {
            BEAN_REGISTRAR_EXTEND.add(extend);
            debug.append(extend.key()).append("、");
        }, null);

        iteration(pluginExtension.getPluginPipeProcessor(applicationContext), extend -> {
            PIPE_PROCESSOR_EXTENDS.add(extend);
            debug.append(extend.key()).append("、");
        }, bean -> bean.order());

        iteration(pluginExtension.getPluginClassGroup(applicationContext), extend -> {
            CLASS_GROUP_EXTENDS.add(extend);
            debug.append(extend.key()).append("、");
        }, null);

        iteration(pluginExtension.getPluginPostProcessor(applicationContext), extend -> {
            POST_PROCESSOR_EXTENDS.add(extend);
            debug.append(extend.key());
        }, bean -> bean.order());

        debug.append("] is registered");
        LOG.info("Plugin extension '{}' is registered", pluginExtension.key());
        LOG.debug(debug.toString());
    }

    public static List getResourceLoadersExtends() {
        return RESOURCE_LOADERS_EXTENDS;
    }

    public static List getPreProcessorExtends() {
        return PRE_PROCESSOR_EXTENDS;
    }

    public static List getPipeProcessorExtends() {
        return PIPE_PROCESSOR_EXTENDS;
    }

    public static List getPluginBeanRegistrarExtends() {
        return BEAN_REGISTRAR_EXTEND;
    }

    public static List getClassGroupExtends() {
        return CLASS_GROUP_EXTENDS;
    }

    public static List getPostProcessorExtends() {
        return POST_PROCESSOR_EXTENDS;
    }

    /**
     * 迭代器。
     * 
     * @param  元素类型
     * @param list 当前处理的集合
     * @param consumer 消费集合中的数据项
     * @param order 排序集合。传入 null 表示不需要排序
     */
    private static  void iteration(List list, Consumer consumer, final Function order) {
        if (list == null || list.isEmpty()) {
            return;
        }
        if (order != null) {
            list.stream().filter(t -> t != null).sorted(CollUtil.sortPriority(order)).forEach(consumer);;
        } else {
            for (T t : list) {
                if (t != null) {
                    consumer.accept(t);
                }
            }
        }
    }

}