下面列出了怎么用java.lang.module.ModuleDescriptor.Exports的API类实例代码及写法,或者点击链接到github查看源代码。
/**
* Returns the non-exported packages of the specified module.
*/
private static Set<String> nonExportedPkgs(ModuleDescriptor md) {
// start with all packages in the module
Set<String> pkgs = new HashSet<>(md.packages());
// remove the non-qualified exported packages
md.exports().stream()
.filter(p -> !p.isQualified())
.map(Exports::source)
.forEach(pkgs::remove);
// remove the non-qualified open packages
md.opens().stream()
.filter(p -> !p.isQualified())
.map(Opens::source)
.forEach(pkgs::remove);
return pkgs;
}
/**
* Returns the non-exported packages of the specified module.
*/
private static Set<String> nonExportedPkgs(ModuleDescriptor md) {
// start with all packages in the module
Set<String> pkgs = new HashSet<>(md.packages());
// remove the non-qualified exported packages
md.exports().stream()
.filter(p -> !p.isQualified())
.map(Exports::source)
.forEach(pkgs::remove);
// remove the non-qualified open packages
md.opens().stream()
.filter(p -> !p.isQualified())
.map(Opens::source)
.forEach(pkgs::remove);
return pkgs;
}
/**
* Validates if exported and open packages are present
*/
void validatePackages() {
Set<String> nonExistPackages = new TreeSet<>();
descriptor.exports().stream()
.map(Exports::source)
.filter(pn -> !packages.contains(pn))
.forEach(nonExistPackages::add);
descriptor.opens().stream()
.map(Opens::source)
.filter(pn -> !packages.contains(pn))
.forEach(nonExistPackages::add);
if (!nonExistPackages.isEmpty()) {
throw new PluginException("Packages that are exported or open in "
+ descriptor.name() + " are not present: " + nonExistPackages);
}
}
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());
}
void newExports(Set<Exports.Modifier> ms, String pn, Set<String> targets) {
int modifiersSetIndex = dedupSetBuilder.indexOfExportsModifiers(ms);
if (!targets.isEmpty()) {
int stringSetIndex = dedupSetBuilder.indexOfStringSet(targets);
mv.visitVarInsn(ALOAD, modifiersSetIndex);
mv.visitLdcInsn(pn);
mv.visitVarInsn(ALOAD, stringSetIndex);
mv.visitMethodInsn(INVOKESTATIC, MODULE_DESCRIPTOR_BUILDER,
"newExports", EXPORTS_MODIFIER_SET_STRING_SET_SIG, false);
} else {
mv.visitVarInsn(ALOAD, modifiersSetIndex);
mv.visitLdcInsn(pn);
mv.visitMethodInsn(INVOKESTATIC, MODULE_DESCRIPTOR_BUILDER,
"newExports", EXPORTS_MODIFIER_SET_STRING_SIG, false);
}
}
private void validatePackages(ModuleDescriptor descriptor, Set<String> packages) {
Set<String> nonExistPackages = new TreeSet<>();
descriptor.exports().stream()
.map(Exports::source)
.filter(pn -> !packages.contains(pn))
.forEach(nonExistPackages::add);
descriptor.opens().stream()
.map(Opens::source)
.filter(pn -> !packages.contains(pn))
.forEach(nonExistPackages::add);
if (!nonExistPackages.isEmpty()) {
throw new CommandException("err.missing.export.or.open.packages",
descriptor.name(), nonExistPackages);
}
}
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"));
}
/**
* Initialize/setup a module's exports.
*
* @param m the module
* @param nameToModule map of module name to Module (for qualified exports)
*/
private static void initExports(Module m, Map<String, Module> nameToModule) {
Map<String, Set<Module>> exportedPackages = new HashMap<>();
for (Exports exports : m.getDescriptor().exports()) {
String source = exports.source();
if (exports.isQualified()) {
// qualified exports
Set<Module> targets = new HashSet<>();
for (String target : exports.targets()) {
Module m2 = nameToModule.get(target);
if (m2 != null) {
addExports0(m, source, m2);
targets.add(m2);
}
}
if (!targets.isEmpty()) {
exportedPackages.put(source, targets);
}
} else {
// unqualified exports
addExportsToAll0(m, source);
exportedPackages.put(source, EVERYONE_SET);
}
}
if (!exportedPackages.isEmpty())
m.exportedPackages = exportedPackages;
}
/**
* Returns a new {@code ModuleDescriptor} instance.
*/
ModuleDescriptor newModuleDescriptor(String name,
Version version,
Set<ModuleDescriptor.Modifier> ms,
Set<Requires> requires,
Set<Exports> exports,
Set<Opens> opens,
Set<String> uses,
Set<Provides> provides,
Set<String> packages,
String mainClass,
int hashCode);
/**
* Returns a new {@code ModuleDescriptor} instance.
*/
ModuleDescriptor newModuleDescriptor(String name,
Version version,
Set<ModuleDescriptor.Modifier> ms,
Set<Requires> requires,
Set<Exports> exports,
Set<Opens> opens,
Set<String> uses,
Set<Provides> provides,
Set<String> packages,
String mainClass,
int hashCode);
@Test(dataProvider = "legalModuleNames")
public void testLegalExports(String mn, String expected) throws Exception {
ModuleDescriptor md = newBuilder("m")
.requires("java.base")
.exports("p", Set.of(mn))
.build();
ByteBuffer bb = toBuffer(md);
ModuleDescriptor descriptor = ModuleDescriptor.read(bb);
Optional<Exports> export = descriptor.exports().stream().findAny();
assertTrue(export.isPresent());
assertTrue(export.get().targets().contains(expected));
}
private Exports exports(Set<Exports.Modifier> mods, String pn) {
return ModuleDescriptor.newModule("foo")
.exports(mods, pn)
.build()
.exports()
.iterator()
.next();
}
private Exports exports(Set<Exports.Modifier> mods, String pn, String target) {
return ModuleDescriptor.newModule("foo")
.exports(mods, pn, Set.of(target))
.build()
.exports()
.iterator()
.next();
}
public void testExportsToAll() {
Exports e = exports("p");
assertEquals(e, e);
assertTrue(e.modifiers().isEmpty());
assertEquals(e.source(), "p");
assertFalse(e.isQualified());
assertTrue(e.targets().isEmpty());
}
public void testExportsToTarget() {
Exports e = exports("p", "bar");
assertEquals(e, e);
assertTrue(e.modifiers().isEmpty());
assertEquals(e.source(), "p");
assertTrue(e.isQualified());
assertTrue(e.targets().size() == 1);
assertTrue(e.targets().contains("bar"));
}
public void testExportsToAllWithModifier() {
Exports e = exports(Set.of(Exports.Modifier.SYNTHETIC), "p");
assertEquals(e, e);
assertTrue(e.modifiers().size() == 1);
assertTrue(e.modifiers().contains(Exports.Modifier.SYNTHETIC));
assertEquals(e.source(), "p");
assertFalse(e.isQualified());
assertTrue(e.targets().isEmpty());
}
public void testExportsToTargetWithModifier() {
Exports e = exports(Set.of(Exports.Modifier.SYNTHETIC), "p", "bar");
assertEquals(e, e);
assertTrue(e.modifiers().size() == 1);
assertTrue(e.modifiers().contains(Exports.Modifier.SYNTHETIC));
assertEquals(e.source(), "p");
assertTrue(e.isQualified());
assertTrue(e.targets().size() == 1);
assertTrue(e.targets().contains("bar"));
}
public void testExportsCompare() {
Exports e1 = exports("p");
Exports e2 = exports("p");
assertEquals(e1, e2);
assertTrue(e1.hashCode() == e2.hashCode());
assertTrue(e1.compareTo(e2) == 0);
assertTrue(e2.compareTo(e1) == 0);
}
public void testExportsCompareWithSameModifiers() {
Exports e1 = exports(Set.of(Exports.Modifier.SYNTHETIC), "p");
Exports e2 = exports(Set.of(Exports.Modifier.SYNTHETIC), "p");
assertEquals(e1, e2);
assertTrue(e1.hashCode() == e2.hashCode());
assertTrue(e1.compareTo(e2) == 0);
assertTrue(e2.compareTo(e1) == 0);
}
public void testExportsCompareWithDifferentModifiers() {
Exports e1 = exports(Set.of(Exports.Modifier.SYNTHETIC), "p");
Exports e2 = exports("p");
assertNotEquals(e1, e2);
assertTrue(e1.compareTo(e2) == 1);
assertTrue(e2.compareTo(e1) == -1);
}
public void testExportsCompareWithSameTargets() {
Exports e1 = exports("p", "x");
Exports e2 = exports("p", "x");
assertEquals(e1, e2);
assertTrue(e1.hashCode() == e2.hashCode());
assertTrue(e1.compareTo(e2) == 0);
assertTrue(e2.compareTo(e1) == 0);
}
public void testExportsCompareWithDifferentTargets() {
Exports e1 = exports("p", "y");
Exports e2 = exports("p", "x");
assertNotEquals(e1, e2);
assertTrue(e1.compareTo(e2) == 1);
assertTrue(e2.compareTo(e1) == -1);
}
public void testOpenModule() {
ModuleDescriptor descriptor = ModuleDescriptor.newOpenModule("foo")
.requires("bar")
.exports("p")
.provides("p.Service", List.of("q.ServiceImpl"))
.build();
// modifiers
assertTrue(descriptor.modifiers().contains(ModuleDescriptor.Modifier.OPEN));
assertTrue(descriptor.isOpen());
// requires
assertTrue(descriptor.requires().size() == 2);
Set<String> names = descriptor.requires()
.stream()
.map(Requires::name)
.collect(Collectors.toSet());
assertEquals(names, Set.of("bar", "java.base"));
// packages
assertEquals(descriptor.packages(), Set.of("p", "q"));
// exports
assertTrue(descriptor.exports().size() == 1);
names = descriptor.exports()
.stream()
.map(Exports::source)
.collect(Collectors.toSet());
assertEquals(names, Set.of("p"));
// opens
assertTrue(descriptor.opens().isEmpty());
}
private static int modifierToInt(Exports.Modifier modifier) {
switch(modifier) {
case MANDATED:
return ACC_MANDATED;
case SYNTHETIC:
return ACC_SYNTHETIC;
default:
throw new IllegalStateException("unknown modifier " + modifier);
}
}
/**
* Returns a {@link Exports} for a qualified export, with
* the given (and possibly empty) set of modifiers,
* to a set of target modules.
*/
public static Exports newExports(Set<Exports.Modifier> ms,
String pn,
Set<String> targets) {
return JLMA.newExports(ms, pn, targets);
}
private void printModuleInfo(PrintWriter writer, ModuleDescriptor md) {
writer.format("%smodule %s {%n", open ? "open " : "", md.name());
Map<String, Module> modules = configuration.getModules();
// first print requires
Set<Requires> reqs = md.requires().stream()
.filter(req -> !req.name().equals("java.base") && req.modifiers().isEmpty())
.collect(Collectors.toSet());
reqs.stream()
.sorted(Comparator.comparing(Requires::name))
.forEach(req -> writer.format(" requires %s;%n",
toString(req.modifiers(), req.name())));
if (!reqs.isEmpty()) {
writer.println();
}
// requires transitive
reqs = md.requires().stream()
.filter(req -> !req.name().equals("java.base") && !req.modifiers().isEmpty())
.collect(Collectors.toSet());
reqs.stream()
.sorted(Comparator.comparing(Requires::name))
.forEach(req -> writer.format(" requires %s;%n",
toString(req.modifiers(), req.name())));
if (!reqs.isEmpty()) {
writer.println();
}
if (!open) {
md.exports().stream()
.peek(exp -> {
if (exp.isQualified())
throw new InternalError(md.name() + " qualified exports: " + exp);
})
.sorted(Comparator.comparing(Exports::source))
.forEach(exp -> writer.format(" exports %s;%n", exp.source()));
if (!md.exports().isEmpty()) {
writer.println();
}
}
md.provides().stream()
.sorted(Comparator.comparing(Provides::service))
.map(p -> p.providers().stream()
.map(impl -> " " + impl.replace('$', '.'))
.collect(joining(",\n",
String.format(" provides %s with%n",
p.service().replace('$', '.')),
";")))
.forEach(writer::println);
if (!md.provides().isEmpty()) {
writer.println();
}
writer.println("}");
}
/**
* Returns a {@link Exports} for a qualified export, with
* the given (and possibly empty) set of modifiers,
* to a set of target modules.
*/
public static Exports newExports(Set<Exports.Modifier> ms,
String pn,
Set<String> targets) {
return JLMA.newExports(ms, pn, targets);
}
private void describeModule(ModuleDescriptor md,
ModuleTarget target,
ModuleHashes hashes,
String uriString)
throws IOException
{
StringBuilder sb = new StringBuilder();
sb.append(md.toNameAndVersion());
if (!uriString.equals(""))
sb.append(" ").append(uriString);
if (md.isOpen())
sb.append(" open");
if (md.isAutomatic())
sb.append(" automatic");
sb.append("\n");
// unqualified exports (sorted by package)
md.exports().stream()
.sorted(Comparator.comparing(Exports::source))
.filter(e -> !e.isQualified())
.forEach(e -> sb.append("exports ").append(e.source())
.append(toString(e.modifiers())).append("\n"));
// dependences
md.requires().stream().sorted()
.forEach(r -> sb.append("requires ").append(r.name())
.append(toString(r.modifiers())).append("\n"));
// service use and provides
md.uses().stream().sorted()
.forEach(s -> sb.append("uses ").append(s).append("\n"));
md.provides().stream()
.sorted(Comparator.comparing(Provides::service))
.forEach(p -> sb.append("provides ").append(p.service())
.append(" with")
.append(toString(p.providers()))
.append("\n"));
// qualified exports
md.exports().stream()
.sorted(Comparator.comparing(Exports::source))
.filter(Exports::isQualified)
.forEach(e -> sb.append("qualified exports ").append(e.source())
.append(" to").append(toString(e.targets()))
.append("\n"));
// open packages
md.opens().stream()
.sorted(Comparator.comparing(Opens::source))
.filter(o -> !o.isQualified())
.forEach(o -> sb.append("opens ").append(o.source())
.append(toString(o.modifiers()))
.append("\n"));
md.opens().stream()
.sorted(Comparator.comparing(Opens::source))
.filter(Opens::isQualified)
.forEach(o -> sb.append("qualified opens ").append(o.source())
.append(toString(o.modifiers()))
.append(" to").append(toString(o.targets()))
.append("\n"));
// non-exported/non-open packages
Set<String> concealed = new TreeSet<>(md.packages());
md.exports().stream().map(Exports::source).forEach(concealed::remove);
md.opens().stream().map(Opens::source).forEach(concealed::remove);
concealed.forEach(p -> sb.append("contains ").append(p).append("\n"));
md.mainClass().ifPresent(v -> sb.append("main-class ").append(v).append("\n"));
if (target != null) {
String targetPlatform = target.targetPlatform();
if (!targetPlatform.isEmpty())
sb.append("platform ").append(targetPlatform).append("\n");
}
if (hashes != null) {
hashes.names().stream().sorted().forEach(
mod -> sb.append("hashes ").append(mod).append(" ")
.append(hashes.algorithm()).append(" ")
.append(toHex(hashes.hashFor(mod)))
.append("\n"));
}
output(sb.toString());
}
void exportsModifiers(Set<Exports.Modifier> mods) {
exportsModifiersSets.computeIfAbsent(mods, s ->
new EnumSetBuilder<>(s, EXPORTS_MODIFIER_CLASSNAME,
enumSetVar, localVarSupplier)
).increment();
}
int indexOfExportsModifiers(Set<Exports.Modifier> mods) {
return exportsModifiersSets.get(mods).build();
}