import io.nuun.kernel.api.plugin.context.InitContext; //导入依赖的package包/类
@SuppressWarnings({"rawtypes", "unchecked"})
@Override
public InitState initialize(InitContext initContext) {
    Map<Specification, Collection<Class<?>>> classesBySpec = initContext.scannedTypesBySpecification();

    streamClasses(classesBySpec.get(BusinessSpecifications.EXPLICIT_ASSEMBLER), Assembler.class).forEach(
            assemblerClasses::add);
    LOGGER.debug("Assemblers => {}", assemblerClasses);

    streamClasses(classesBySpec.get(BusinessSpecifications.DEFAULT_ASSEMBLER), Assembler.class).forEach(
            defaultAssemblerClasses::add);
    LOGGER.debug("Default assemblers => {}", defaultAssemblerClasses);

    streamClasses(classesBySpec.get(BusinessSpecifications.DTO_OF), Object.class).forEach(dtoOfClasses::add);
    LOGGER.debug("DTO classes mappable with default assemblers => {}", dtoOfClasses);

    streamClasses(classesBySpec.get(BusinessSpecifications.DTO_INFO_RESOLVER), DtoInfoResolver.class).forEach(
            dtoInfoResolverClasses::add);
    sortByPriority(dtoInfoResolverClasses);
    LOGGER.debug("DTO info resolvers => {}", dtoInfoResolverClasses);

    // Add bindings for explicit assemblers
    bindings.putAll(associateInterfaceToImplementations(Assembler.class, assemblerClasses, false));
    overridingBindings.putAll(associateInterfaceToImplementations(Assembler.class, assemblerClasses, true));

    // Then add bindings for default assemblers
    bindingStrategies.addAll(new DefaultAssemblerCollector(getApplication(), bindings, defaultAssemblerClasses)
            .collect(dtoOfClasses)
    );

    return InitState.INITIALIZED;
}
 

import io.nuun.kernel.api.plugin.context.InitContext; //导入依赖的package包/类
@Override
public InitState initialize(InitContext initContext) {
    Map<Specification, Collection<Class<?>>> classesBySpec = initContext.scannedTypesBySpecification();

    streamClasses(classesBySpec.get(BusinessSpecifications.SPECIFICATION_TRANSLATOR),
            SpecificationTranslator.class).forEach(specificationTranslatorClasses::add);
    LOGGER.debug("Specification translator classes => {}", specificationTranslatorClasses);

    streamClasses(classesBySpec.get(BusinessSpecifications.SPECIFICATION_CONVERTER),
            SpecificationConverter.class).forEach(specificationConverterClasses::add);
    LOGGER.debug("Specification converter classes => {}", specificationConverterClasses);

    return InitState.INITIALIZED;
}
 

import io.nuun.kernel.api.plugin.context.InitContext; //导入依赖的package包/类
@SuppressWarnings({"rawtypes", "unchecked"})
@Override
public InitState initialize(InitContext initContext) {
    Map<Specification, Collection<Class<?>>> classesBySpec = initContext.scannedTypesBySpecification();

    streamClasses(classesBySpec.get(BusinessSpecifications.DATA_IMPORTER), DataImporter.class)
            .filter(importerClass -> !DefaultDataImporter.class.isAssignableFrom(importerClass))
            .forEach(importerClasses::add);
    LOGGER.debug("Data importers => {}", importerClasses);

    streamClasses(classesBySpec.get(BusinessSpecifications.DATA_EXPORTER), DataExporter.class)
            .filter(exporterClass -> !DefaultDataExporter.class.isAssignableFrom(exporterClass))
            .forEach(exporterClasses::add);
    LOGGER.debug("Data exporters => {}", exporterClasses);

    streamClasses(classesBySpec.get(BusinessSpecifications.DATA_SET), Object.class).forEach(
            dataClasses::add);
    LOGGER.debug("DTO classes with default importer/exporter => {}", dataClasses);

    // Add bindings for explicit data importers/exporters
    bindings.putAll(associateInterfaceToImplementations(DataImporter.class, importerClasses, false));
    overridingBindings.putAll(associateInterfaceToImplementations(DataImporter.class, importerClasses, true));
    bindings.putAll(associateInterfaceToImplementations(DataExporter.class, exporterClasses, false));
    overridingBindings.putAll(associateInterfaceToImplementations(DataExporter.class, exporterClasses, true));

    Set<Class<?>> classesWithExplicitImporter = importerClasses.stream()
            .map(importerClass -> (Class<?>) BusinessUtils.resolveGenerics(DataImporter.class, importerClass)[0])
            .collect(toSet());
    Set<Class<?>> classesWithExplicitExporter = exporterClasses.stream()
            .map(exporterClass -> (Class<?>) BusinessUtils.resolveGenerics(DataExporter.class, exporterClass)[0])
            .collect(toSet());

    // Then add bindings for default data importers/exporters
    bindingStrategies.addAll(new DefaultDataCollector(classesWithExplicitImporter, classesWithExplicitExporter)
            .collect(dataClasses));

    buildImporterDefs(classesWithExplicitImporter);
    buildExporterDefs(classesWithExplicitExporter);

    return InitState.INITIALIZED;
}
 

import io.nuun.kernel.api.plugin.context.InitContext; //导入依赖的package包/类
@Override
public InitState initialize(InitContext initContext) {
    return InitState.INITIALIZED;
}
 

import io.nuun.kernel.api.plugin.context.InitContext; //导入依赖的package包/类
/**
 * Associates scanned interfaces to their implementations. It also handles qualified bindings in
 * the case where there is multiple implementation for the same interface. <p> This is the
 * "default mode" for binding in the business framework. </p>
 *
 * @param initContext      the context containing the implementations.
 * @param interfaces       the interfaces to bind.
 * @param specsByInterface the specifications used to scan implementations, indexed by
 *                         interfaces.
 * @param overridingMode   if true, only implementations that satisfy {@link
 *                         #isOverridingImplementation()} are bound, if false only implementations
 *                         that don't satisfy {@link #isOverridingImplementation()} are bound.
 * @param <T>              supertype of all interfaces to bind.
 * @return the map of interface/implementation to bind.
 * @see BindingUtils#resolveBindingDefinitions(Class, Class, Class[])
 */
@SuppressWarnings("unchecked")
public static <T extends Class> Map<Key<T>, ? extends T> associateInterfacesToImplementations(
        InitContext initContext, Collection<T> interfaces, Map<T, Specification<? extends T>> specsByInterface,
        boolean overridingMode) {
    Map<Key<T>, ? extends T> keyMap = new HashMap<>();
    for (T anInterface : interfaces) {
        keyMap.putAll(associateInterfaceToImplementations(anInterface, initContext.scannedTypesBySpecification()
                .get(specsByInterface.get(anInterface)), overridingMode));

    }
    return keyMap;
}