Java ModuleDescriptor类代码示例

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
/**
 * Test the scenario where a module contains a package p and reads
 * a module that exports package p.
 */
@Test(expectedExceptions = { ResolutionException.class })
public void testPackageSuppliedBySelfAndOther() {

    ModuleDescriptor descriptor1 = newBuilder("m1")
            .requires("m2")
            .packages(Set.of("p"))
            .build();

    ModuleDescriptor descriptor2 = newBuilder("m2")
            .exports("p")
            .build();

    ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);

    // m1 contains package p, module m2 exports package p to m1
    resolve(finder, "m1");
}
 

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
Optional<ModuleDescriptor> describeModule(URI uri) {
  var path = load(uri);
  if (!path.isPresent()) {
    return Optional.empty();
  }
  try {
    debug("describeModule({0} -> {1})", uri, path);
    return describeModule(path.get(), true);
  } finally {
    try {
      Files.delete(path.get());
    } catch (Exception e) {
      debug("deleting temp file failed: {0}", e);
    }
  }
}
 

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
public void testOpensToTargets() {
    Set<String> targets = new HashSet<>();
    targets.add("bar");
    targets.add("gus");
    Opens o = ModuleDescriptor.newModule("foo")
            .opens("p", targets)
            .build()
            .opens()
            .iterator()
            .next();
    assertEquals(o, o);
    assertTrue(o.modifiers().isEmpty());
    assertEquals(o.source(), "p");
    assertTrue(o.isQualified());
    assertTrue(o.targets().size() == 2);
    assertTrue(o.targets().contains("bar"));
    assertTrue(o.targets().contains("gus"));
}
 

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
public static void main(String[] args) throws Exception {

        final String MY_MODULE_NAME = "myModule";

        // Verify that JVMTI reports exactly the same info as Java regarding the named modules
        Asserts.assertEquals(ModuleLayer.boot().modules(), getModulesJVMTI());

        // Load a new named module
        ModuleDescriptor descriptor = ModuleDescriptor.newModule(MY_MODULE_NAME).build();
        ModuleFinder finder = finderOf(descriptor);
        ClassLoader loader = new ClassLoader() {};
        Configuration parent = ModuleLayer.boot().configuration();
        Configuration cf = parent.resolve(finder, ModuleFinder.of(), Set.of(MY_MODULE_NAME));
        ModuleLayer my = ModuleLayer.boot().defineModules(cf, m -> loader);

        // Verify that the loaded module is indeed reported by JVMTI
        Set<Module> jvmtiModules = getModulesJVMTI();
        for (Module mod : my.modules()) {
            if (!jvmtiModules.contains(mod)) {
                throw new RuntimeException("JVMTI did not report the loaded named module: " + mod.getName());
            }
        }

    }
 

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
static void checkModuleDescriptor(ModuleDescriptor md, String... packages) throws IOException {
    String mainClass = md.name().replace('m', 'p') + ".Main";
    if (!md.mainClass().get().equals(mainClass)) {
        throw new RuntimeException(md.mainClass().toString());
    }

    // ModuleTarget attribute should be present
    if (!hasModuleTarget(md.name())) {
        throw new RuntimeException("ModuleTarget missing for " + md.name());
    }

    Set<String> pkgs = md.packages();
    if (!pkgs.equals(Set.of(packages))) {
        throw new RuntimeException(pkgs + " expected: " + Set.of(packages));
    }
}
 

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
public void testExportsToTargets() {
    Set<String> targets = new HashSet<>();
    targets.add("bar");
    targets.add("gus");
    Exports e
        = ModuleDescriptor.newModule("foo")
            .exports("p", targets)
            .build()
            .exports()
            .iterator()
            .next();
    assertEquals(e, e);
    assertTrue(e.modifiers().isEmpty());
    assertEquals(e.source(), "p");
    assertTrue(e.isQualified());
    assertTrue(e.targets().size() == 2);
    assertTrue(e.targets().contains("bar"));
    assertTrue(e.targets().contains("gus"));
}
 

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
/**
 * Basic test to ensure that no automatic modules are resolved when
 * an automatic module is not a root or required by other modules.
 */
public void testInConfiguration4() throws IOException {
    ModuleDescriptor descriptor1
        = ModuleDescriptor.newModule("m1")
            .requires("java.base")
            .build();

    // automatic modules
    Path dir = Files.createTempDirectory(USER_DIR, "mods");
    createDummyJarFile(dir.resolve("auto1.jar"), "p1/C.class");
    createDummyJarFile(dir.resolve("auto2.jar"), "p2/C.class");
    createDummyJarFile(dir.resolve("auto3.jar"), "p3/C.class");

    // module finder locates m1 and the modules in the directory
    ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
    ModuleFinder finder2 =  ModuleFinder.of(dir);
    ModuleFinder finder = ModuleFinder.compose(finder1, finder2);

    Configuration parent = ModuleLayer.boot().configuration();
    Configuration cf = resolve(parent, finder, "m1");

    // ensure that no automatic module is resolved
    assertTrue(cf.modules().size() == 1);
    assertTrue(cf.findModule("m1").isPresent());
}
 

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
/**
 * Test "uses p.S" where p is contained in a different module.
 */
@Test(expectedExceptions = { ResolutionException.class })
public void testContainsService2() {
    ModuleDescriptor descriptor1 = newBuilder("m1")
            .packages(Set.of("p"))
            .build();

    ModuleDescriptor descriptor2 = newBuilder("m2")
            .requires("m1")
            .uses("p.S")
            .build();

    ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);

    // m2 does not read a module that exports p
    resolve(finder, "m2");
}
 

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
@DataProvider(name = "sortedModuleDescriptors")
public Object[][] sortedModuleDescriptors() {
    return new Object[][]{

        { ModuleDescriptor.newModule("m2").build(),
          ModuleDescriptor.newModule("m1").build()
        },

        { ModuleDescriptor.newModule("m").version("2").build(),
          ModuleDescriptor.newModule("m").version("1").build()
        },

        { ModuleDescriptor.newModule("m").version("1").build(),
          ModuleDescriptor.newModule("m").build()
        },

        { ModuleDescriptor.newOpenModule("m").build(),
          ModuleDescriptor.newModule("m").build()
        },

    };
}
 

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
/**
  * Exercise defineModules with a configuration with a module that
  * contains a package that is the same name as a non-exported package in
  * a parent layer.
  */
 public void testContainsSamePackageAsBootLayer() {

     // check assumption that java.base contains sun.launcher
     ModuleDescriptor base = Object.class.getModule().getDescriptor();
     assertTrue(base.packages().contains("sun.launcher"));

     ModuleDescriptor descriptor = newBuilder("m1")
            .requires("java.base")
            .packages(Set.of("sun.launcher"))
            .build();

     ModuleFinder finder = ModuleUtils.finderOf(descriptor);

     Configuration parent = ModuleLayer.boot().configuration();
     Configuration cf = parent.resolve(finder, ModuleFinder.of(), Set.of("m1"));
     assertTrue(cf.modules().size() == 1);

     ClassLoader loader = new ClassLoader() { };
     ModuleLayer layer = ModuleLayer.boot().defineModules(cf, mn -> loader);
     assertTrue(layer.modules().size() == 1);
}
 

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
/**
 * Test two modules exporting package p to a module that reads both.
 */
@Test(expectedExceptions = { ResolutionException.class })
public void testPackageSuppliedByTwoOthers() {

    ModuleDescriptor descriptor1 = newBuilder("m1")
            .requires("m2")
            .requires("m3")
            .build();

    ModuleDescriptor descriptor2 = newBuilder("m2")
            .exports("p")
            .build();

    ModuleDescriptor descriptor3 = newBuilder("m3")
            .exports("p", Set.of("m1"))
            .build();

    ModuleFinder finder
        = ModuleUtils.finderOf(descriptor1, descriptor2, descriptor3);

    // m2 and m3 export package p to module m1
    resolve(finder, "m1");
}
 

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
private void dedups(ModuleDescriptor md) {
    // exports
    for (Exports e : md.exports()) {
        dedupSetBuilder.stringSet(e.targets());
        dedupSetBuilder.exportsModifiers(e.modifiers());
    }

    // opens
    for (Opens opens : md.opens()) {
        dedupSetBuilder.stringSet(opens.targets());
        dedupSetBuilder.opensModifiers(opens.modifiers());
    }

    // requires
    for (Requires r : md.requires()) {
        dedupSetBuilder.requiresModifiers(r.modifiers());
    }

    // uses
    dedupSetBuilder.stringSet(md.uses());
}
 

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
/**
 * Service provider dependency not found
 */
@Test(expectedExceptions = { FindException.class })
public void testServiceProviderDependencyNotFound() {

    // service provider dependency (on m3) not found

    ModuleDescriptor descriptor1 = newBuilder("m1")
            .exports("p")
            .uses("p.S")
            .build();

    ModuleDescriptor descriptor2 = newBuilder("m2")
            .requires("m1")
            .requires("m3")
            .provides("p.S", List.of("q.T"))
            .build();

    ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);

    // should throw ResolutionException because m3 is not found
    Configuration cf = resolveAndBind(finder, "m1");
}
 

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
/**
 * Apply transitive reduction on the resulting graph and reports
 * recommended requires.
 */
private void analyzeDeps() {
    printModuleDescriptor(log, root);

    ModuleDescriptor analyzedDescriptor = descriptor();
    if (!matches(root.descriptor(), analyzedDescriptor)) {
        log.format("  [Suggested module descriptor for %s]%n", root.name());
        analyzedDescriptor.requires()
            .stream()
            .sorted(Comparator.comparing(ModuleDescriptor.Requires::name))
            .forEach(req -> log.format("    requires %s;%n", req));
    }

    ModuleDescriptor reduced = reduced();
    if (!matches(root.descriptor(), reduced)) {
        log.format("  [Transitive reduced graph for %s]%n", root.name());
        reduced.requires()
            .stream()
            .sorted(Comparator.comparing(ModuleDescriptor.Requires::name))
            .forEach(req -> log.format("    requires %s;%n", req));
    }

    checkQualifiedExports();
    log.println();
}
 

import java.lang.module.ModuleDescriptor; //导入依赖的package包/类
public void testAutomaticModule() {
    ModuleDescriptor descriptor = ModuleDescriptor.newAutomaticModule("foo")
            .packages(Set.of("p"))
            .provides("p.Service", List.of("q.ServiceImpl"))
            .build();

    // modifiers
    assertTrue(descriptor.modifiers().contains(ModuleDescriptor.Modifier.AUTOMATIC));
    assertTrue(descriptor.isAutomatic());

    // requires
    assertTrue(descriptor.requires().size() == 1);
    Set<String> names = descriptor.requires()
            .stream()
            .map(Requires::name)
            .collect(Collectors.toSet());
    assertEquals(names, Set.of("java.base"));

    // packages
    assertEquals(descriptor.packages(), Set.of("p", "q"));
    assertTrue(descriptor.exports().isEmpty());
    assertTrue(descriptor.opens().isEmpty());
}