import io.nuun.kernel.api.plugin.InitState; //导入依赖的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.InitState; //导入依赖的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.InitState; //导入依赖的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.InitState; //导入依赖的package包/类
@Override
public InitState initialize(InitContext initContext) {
    return InitState.INITIALIZED;
}