Java ModuleDescriptor.Builder方法代码示例

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
private ModuleDescriptor descriptor(Set<Module> requiresTransitive,
                                    Set<Module> requires) {

    ModuleDescriptor.Builder builder = ModuleDescriptor.newModule(root.name());

    if (!root.name().equals(JAVA_BASE))
        builder.requires(Set.of(MANDATED), JAVA_BASE);

    requiresTransitive.stream()
        .filter(m -> !m.name().equals(JAVA_BASE))
        .map(Module::name)
        .forEach(mn -> builder.requires(Set.of(TRANSITIVE), mn));

    requires.stream()
        .filter(m -> !requiresTransitive.contains(m))
        .filter(m -> !m.name().equals(JAVA_BASE))
        .map(Module::name)
        .forEach(mn -> builder.requires(mn));

    return builder.build();
}
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
/**
 * Converts the given automatic module to a normal module.
 *
 * Replace this module's dependences with the given requires and also
 * declare service providers, if specified in META-INF/services configuration file
 */
private NormalModule(Module m, Map<String, Boolean> requires) {
    super(m.name(), m.location, m.descriptor, m.exports, m.opens, m.isSystem, m.reader());

    ModuleDescriptor.Builder builder = ModuleDescriptor.newModule(m.name());
    requires.keySet().forEach(mn -> {
        if (requires.get(mn).equals(Boolean.TRUE)) {
            builder.requires(Set.of(ModuleDescriptor.Requires.Modifier.TRANSITIVE), mn);
        } else {
            builder.requires(mn);
        }
    });
    // exports all packages
    m.descriptor.packages().forEach(builder::exports);
    m.descriptor.uses().forEach(builder::uses);
    m.descriptor.provides().forEach(builder::provides);
    this.md = builder.build();
}
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
private static ModuleDescriptor descriptorOf(ResourcePoolModule mod) {
    ModuleDescriptor md = mod.descriptor();

    // drop hashes
    ModuleDescriptor.Builder builder = ModuleDescriptor.newModule(md.name());
    md.requires().stream()
      .forEach(builder::requires);
    md.exports().stream()
      .forEach(builder::exports);
    md.opens().stream()
      .forEach(builder::opens);
    md.uses().stream()
      .forEach(builder::uses);
    md.provides().stream()
      .forEach(builder::provides);
    builder.packages(md.packages());

    md.version().ifPresent(builder::version);
    md.mainClass().ifPresent(builder::mainClass);

    return builder.build();
}
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
/**
 * Parses a string of the form {@code name[@version]} and returns a
 * ModuleDescriptor with that name and version. The ModuleDescriptor
 * will have a requires on java.base.
 */
static ModuleDescriptor newModuleDescriptor(String mid) {
    String mn;
    String vs;
    int i = mid.indexOf("@");
    if (i == -1) {
        mn = mid;
        vs = null;
    } else {
        mn = mid.substring(0, i);
        vs = mid.substring(i+1);
    }
    ModuleDescriptor.Builder builder
        = ModuleDescriptor.newModule(mn).requires("java.base");
    if (vs != null)
        builder.version(vs);
    return builder.build();
}
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
private Module createModule(final String moduleName) {
    final Module structMod = context.getStructLoader().getModule();
    final ModuleDescriptor.Builder builder =
        ModuleDescriptor.newModule(moduleName, Set.of(Modifier.SYNTHETIC))
                .requires("java.logging")
                .requires(NASHORN_MODULE.getName())
                .requires(structMod.getName())
                .packages(Set.of(SCRIPTS_PKG));

    if (Context.javaSqlFound) {
        builder.requires("java.sql");
    }

    if (Context.javaSqlRowsetFound) {
        builder.requires("java.sql.rowset");
    }

    final ModuleDescriptor descriptor = builder.build();

    final Module mod = Context.createModuleTrusted(structMod.getLayer(), descriptor, this);
    loadModuleManipulator();
    return mod;
}
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
private static ModuleDescriptor createModuleDescriptor(ModuleNode moduleNode, Path moduleInfoPath) {
  boolean isOpen = (moduleNode.access & ACC_OPEN) != 0;
  ModuleDescriptor.Builder builder = isOpen?
      ModuleDescriptor.newOpenModule(moduleNode.name):
      ModuleDescriptor.newModule(moduleNode.name);
  
  moduleNode.requires.forEach(require -> builder.requires(requireModifiers(require.access), require.module));
  moduleNode.exports.forEach(export -> {
    if (export.modules.isEmpty()) {
      builder.exports(export.packaze);
    } else {
      builder.exports(export.packaze, export.modules.stream().collect(toSet()));
    }
  });
  moduleNode.opens.forEach(open -> {
    if (open.modules.isEmpty()) {
      builder.opens(open.packaze);
    } else {
      builder.opens(open.packaze, open.modules.stream().collect(toSet()));
    }
  });
  moduleNode.uses.forEach(builder::uses);
  moduleNode.provides.forEach(provide -> builder.provides(provide.service, provide.providers));

  Path moduleDirectory = moduleInfoPath.getParent();
  Set<String> javaPackages = findJavaPackages(moduleDirectory);
  javaPackages.removeAll(moduleNode.exports.stream().map(export -> export.packaze).collect(Collectors.toList()));
  javaPackages.removeAll(moduleNode.opens.stream().map(export -> export.packaze).collect(Collectors.toList()));
  builder.packages(javaPackages);

  ModuleDescriptor descriptor = builder.build();
  //System.out.println(descriptor.name() + " " + descriptor.packages());

  return descriptor;
}
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
private ModuleDescriptor dropHashes(ModuleDescriptor md) {
    ModuleDescriptor.Builder builder = ModuleDescriptor.newModule(md.name());
    md.requires().forEach(builder::requires);
    md.exports().forEach(builder::exports);
    md.opens().forEach(builder::opens);
    md.provides().stream().forEach(builder::provides);
    md.uses().stream().forEach(builder::uses);
    builder.packages(md.packages());
    return builder.build();
}
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
RootModule(String name) {
    super(name);

    ModuleDescriptor.Builder builder = ModuleDescriptor.newModule(name);
    this.descriptor = builder.build();
}
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
/**
 * Adds a dependence on a module with the given (possibly un-parsable)
 * version string.
 */
void requires(ModuleDescriptor.Builder builder,
              Set<Requires.Modifier> ms,
              String mn,
              String rawCompiledVersion);
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
/**
 * Creates a "non-strict" builder for building a module. This allows the
 * test the create ModuleDescriptor objects that do not require java.base.
 */
private static ModuleDescriptor.Builder newBuilder(String mn) {
    return SharedSecrets.getJavaLangModuleAccess()
            .newModuleBuilder(mn, false, Set.of());
}
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
/**
 * Creates a builder for building a module with the given module name.
 *
 * @param strict
 *        Indicates whether module names are checked or not
 */
ModuleDescriptor.Builder newModuleBuilder(String mn,
                                          boolean strict,
                                          Set<ModuleDescriptor.Modifier> ms);
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
/**
 * Returns a snapshot of the packages in the module.
 */
Set<String> packages(ModuleDescriptor.Builder builder);
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
void transform(ModuleDescriptor.Builder builder);