Brainscape's Knowledge GenomeTM

Browse over 1 million classes created by top students, professors, publishers, and experts.


See full index

J17 notes > Chapter 11 Modules Notes > Flashcards

Chapter 11 Modules Notes Flashcards

Modules

1
Q

Introducing Modules

A
  • The Java Platform Module System (JPMS) was introduced in Java 9
  • The main purpose of a module is to provide groups of related packages to offer a particular set of functionality to developers.

The Java Platform Module System includes the following:
* A format for module JAR files
* Partitioning of the JDK into modules
* Additional command-line options for Java tools

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
2
Q

EXPLORING A MODULE

A

A module is a group of one or more packages plus a special file called module-info.java.

dependencies where one module relies on code in another

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
3
Q

BENEFITS OF MODULES

A
  • Better Access Control
    • a fifth level of access control.
    • They can expose packages within the modular JAR to specific other packages.
    • This stronger form of encapsulation really does create internal packages.
  • Clearer Dependency Management
    specify their dependencies in the module-info.java file.
  • Custom Java Builds
    • allows developers to specify what modules they actually need.
    • A tool called jlink is used to create this runtime image.
  • Improved Performance
    improves startup time and requires less memory to run.
  • Unique Package Enforcement
    A package is only allowed to be supplied by one module.
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
4
Q

Better Access Control

A

what if we wrote some complex logic that we wanted to restrict to just some packages?

  • Modules solve this problem by acting as a fifth level of access control.
  • They can expose packages within the modular JAR to specific other packages.
  • This stronger form of encapsulation really does create internal packages.
  • You’ll see how to code it when we talk about the module-info.java file later in this chapter.
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
5
Q

Clearer Dependency Management

A

In a fully modular environment, each of the open source projects would specify their dependencies in the module-info.java file.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
6
Q

Custom Java Builds

A
  • The Java Platform Module System allows developers to specify what modules they actually need.
  • This makes it possible to create a smaller runtime image that is customized to what the application needs and nothing more.
  • Users can run that image without having Java installed at all.
  • A tool called jlink is used to create this runtime image. Luckily, you only need to know that custom smaller runtimes are possible. How to create them is out of scope for the exam.

In addition to the smaller scale package, this approach improves security. If you don’t use AWT and a security vulnerability is reported for AWT, applications that packaged a runtime image without AWT aren’t affected.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
7
Q

Improved Performance

A

Since Java now knows which modules are required, it only needs to look at those at class loading time. This improves startup time for big programs and requires less memory to run.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
8
Q

Unique Package Enforcement

A

Another manifestation of JAR hell is when the same package is in two JARs. There are a number of causes of this problem including renaming JARs, clever developers using a package name that is already taken, and having two versions of the same JAR on the classpath.

The Java Platform Module System prevents this scenario. A package is only allowed to be supplied by one module. No more unpleasant surprises about a package at runtime.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
9
Q

MODULES FOR EXISTING CODE

A

test

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
10
Q

Creating and Running a Modular Program

A
  • CREATING THE FILES
    • class file
      • Java classes should be in packages.
    • module-info.java
      • module keyward
      • the root directory of your module.
  • The next step is to make sure the files are in the right directory structure.
  • COMPILING OUR FIRST MODULE
    • javac --module-path mods -d feeding feeding/zoo/animal/feeding/*.java feeding/module-info.java
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
11
Q

CREATING THE FILES

A

Create a class file:

package zoo.animal.feeding;
public class Task {
    public static void main(String... args) {
        System.out.println("All fed!");
    }
}

module-info.java file. This is the simplest possible one.

module zoo.animal.feeding {
}
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
12
Q

There are a few key differences between a module-info file and a regular Java class:

A
  • The module-info file must be in the root directory of your module. Regular Java classes should be in packages.
  • The module-info file must use the keyword module instead of class, interface, or enum.
  • The module name follows the naming rules for package names. It often includes periods (.) in its name. Regular class and package names are not allowed to have dashes (-). Module names follow the same rule.

That’s a lot of rules for the simplest possible file. There will be many more rules when we flesh out this file later in the chapter.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
13
Q

CAN A MODULE-INFO.JAVA FILE BE EMPTY?

A

Yes. As a bit of trivia,

it was legal to compile any empty file with a .java extension even before modules.

The compiler sees there isn’t a class in there and exits without creating a .class file.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
14
Q

COMPILING OUR FIRST MODULE

A

> [!NOTE]
When you’re entering commands at the command line, they should be typed all on one line.

javac --module-path mods -d feeding feeding/zoo/animal/feeding/*.java feeding/module-info.java
  • the -d option specifies the directory to place the class files in.
  • The end of the command is a list of the .java files to compile. You can list the files individually or use a wildcard for all .java files in a subdirectory.
  • --module-path option indicates the location of any custom module files.
  • The syntax --module-path and -p are equivalent.

The following four commands show the -p option:

javac -p mods -d feeding feeding/zoo/animal/feeding/*.java feeding/*.java

javac -p mods -d feeding feeding/zoo/animal/feeding/*.java feeding/module-info.java

javac -p mods -d feeding feeding/zoo/animal/feeding/Task.java feeding/module-info.java

javac -p mods -d feeding feeding/zoo/animal/feeding/Task.java feeding/*.java
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
15
Q

Options you need to know for using modules with javac

A
  1. Directory for class files, -d <dir>
  2. Module path, -p <path>, --module-path <path>
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
16
Q

WHAT HAPPENED TO THE CLASSPATH?

A

You can still use these options in Java 11. In fact, it is common to do so when writing nonmodular programs.

-cp, --class-path, and -classpath

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
17
Q

BUILDING MODULES

A

Do be sure to memorize the module command syntax. You will be tested on it on the exam. We will be sure to give you lots of practice questions on the syntax to reinforce it.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
18
Q

RUNNING OUR FIRST MODULE

A

Pay special attention to the book.module/com.sybex.OCP part. It is important to remember that you specify the module name followed by a slash (/) followed by the fully qualified class name.

java --module-path mods --module book.module/com.sybex.OCP
  1. Location of modules, --module-path, -p
  2. Module name, --module, -m
  3. Module/package separator
  4. Package name
  5. Class name
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
19
Q 
java --module-path feeding --module zoo.animal.feeding/zoo.animal.feeding.Task

java -p feeding -m zoo.animal.feeding/zoo.animal.feeding.Task
A
  • --module-path uses the short form of -p
  • --module short option is -m
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
20
Q

Options you need to know for using modules with java

A
  1. Module name, -m <name>, --module <name>
  2. Module path, -p <path>, --module-path <path>
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
21
Q

PACKAGING OUR FIRST MODULE

A

Be sure to create a mods directory before running this command:

jar -cvf mods/zoo.animal.feeding.jar -C feeding/ .

  • We are packaging everything under the feeding directory
  • and storing it in a JAR file named zoo.animal.feeding.jar under the mods folder.

run the program again, but this time using the mods directory instead of the loose classes:

java -p mods -m zoo.animal.feeding/zoo.animal.feeding.Task

Since the module path is used, a module JAR is being run.

22
Q

> [!NOTE]
It is possible to version your module using the –module-version option.
This isn’t on the exam but is good to do when you are ready to share your module with others.

A

version your module using the –module-version option.

23
Q

Updating Our Example for Multiple Modules

A

test

24
Q

UPDATING THE FEEDING MODULE

A

other modules call code in the zoo.animal.feeding package, we need to declare this intent in the module-info file.

The exports keyword is used to indicate that a module intends for those packages to be used by Java code outside the module. As you might expect, without an exports keyword, the module is only available to be run from the command line on its own. In

module zoo.animal.feeding {
    exports zoo.animal.feeding;
}

Recompiling and repackaging the module will update the module-info inside our zoo.animal.feeding.jar file. These are the same javac and jar commands you ran previously.

javac -p mods -d feeding feeding/zoo/animal/feeding/*.java feeding/module-info.java

jar -cvf mods/zoo.animal.feeding.jar -C feeding/ .

25
Q

CREATING A CARE MODULE

A

Have two packages. The zoo.animal.care.medical package will have the classes and methods that are intended for use by other modules. The zoo.animal.care.details package is only going to be used by this module. It will not be exported from the module.

The module contains two basic packages and classes in addition to the module-info.java file:

// HippoBirthday.java
package zoo.animal.care.details;
import zoo.animal.feeding.*;
public class HippoBirthday {
    private Task task;
}
// Diet.java
package zoo.animal.care.medical;
public class Diet { }

This time the module-info.java file specifies three things.

1: module zoo.animal.care {
2: exports zoo.animal.care.medical;
3: requires zoo.animal.feeding;
4: }
  • Line 1 specifies the name of the module.
  • Line 2 lists the package we are exporting so it can be used by other modules. So far, this is similar to the zoo.animal.feeding module.
  • On line 3, we see a new keyword. The requires statement specifies that a module is needed. The zoo.animal.care module depends on the zoo.animal.feeding module.

javac -p mods -d care care/zoo/animal/care/details/*.java care/zoo/animal/care/medical/*.java care/module-info.java

26
Q

This time the module-info.java file specifies three things.

1: module zoo.animal.care {
2: exports zoo.animal.care.medical;
3: requires zoo.animal.feeding;
4: }
A
  • Line 1 specifies the name of the module.
  • Line 2 lists the package we are exporting so it can be used by other modules. So far, this is similar to the zoo.animal.feeding module.
  • On line 3, we see a new keyword. The requires statement specifies that a module is needed. The zoo.animal.care module depends on the zoo.animal.feeding module.
27
Q

ORDER MATTERS!

A

Order matters when compiling a module.

javac -p mods -d care care/module-info.java care/zoo/animal/care/details/*.java care/zoo/animal/care/medical/*.java

The compiler complains that it doesn’t know anything about the package zoo.animal.care.medical.

care/module-info.java:3: error: package is empty or does not exist:
zoo.animal.care.medical
exports zoo.animal.care.medical;
  • A package must have at least one class in it in order to be exported.
  • Since we haven’t yet compiled zoo.animal.care.medical.Diet, the compiler acts as if it doesn’t exist.
  • If you get this error message, you can reorder the javac statement.
  • Alternatively, you can compile the packages in a separate javac command, before compiling the module-info file.

jar -cvf mods/zoo.animal.care.jar -C care/ .

28
Q

CREATING THE TALKS MODULE

A

the module-info.java file for zoo.animal.talks:

1: module zoo.animal.talks {
2: exports zoo.animal.talks.content;
3: exports zoo.animal.talks.media;
4: exports zoo.animal.talks.schedule;
5:
6: requires zoo.animal.feeding;
7: requires zoo.animal.care;
8: }
  • Line 1 shows the module name.
  • Lines 2–4 allow other modules to reference all three packages.
  • Lines 6–7 specify the two modules that this module depends on.

javac -p mods -d talks talks/zoo/animal/talks/content/*.java talks/zoo/animal/talks/media/*.java talks/zoo/animal/talks/schedule/*.java talks/module-info.java

jar -cvf mods/zoo.animal.talks.jar -C talks/ .

29
Q

CREATING THE STAFF MODULE

A 
module zoo.staff {
requires zoo.animal.feeding;
requires zoo.animal.care;
requires zoo.animal.talks;
}

javac -p mods -d staff staff/zoo/staff/*.java staff/module-info.java

jar -cvf mods/zoo.staff.jar -C staff/ .

30
Q

Diving into the module-info File

A

these are not Java keywords they are directives, can appear in any order in the module-info file.

  • exports,
  • requires,
  • provides,
  • uses,
  • and opens.
31
Q

ARE EXPORTS AND REQUIRES KEYWORDS?

A

These special keywords are called directives.

  • exports,
  • requires,
  • provides,
  • uses,
  • and opens.
32
Q

EXPORTS

A
  • exports packageName exports a package to other modules.
  • It’s also possible to export a package to a specific module. 
module zoo.animal.talks {
exports zoo.animal.talks.content to zoo.staff;
exports zoo.animal.talks.media;
exports zoo.animal.talks.schedule;
requires zoo.animal.feeding;
requires zoo.animal.care;
}
33
Q

EXPORTED TYPES

A

Exporting a package

  • All public classes, interfaces, and enums are exported.
  • Further, any public and protected fields and methods in those files are visible.
  • Fields and methods that are private are not visible because they are not accessible outside the class.
  • Similarly, package-private fields and methods are not visible because they are not accessible outside the package.
34
Q

REQUIRES TRANSITIVE

A

requires moduleName specifies that the current module depends on moduleName.

There’s also a requires transitive moduleName, which means that any module that requires this module will also depend on moduleName.

module zoo.animal.feeding {
exports zoo.animal.feeding;
}

module zoo.animal.care {
exports zoo.animal.care.medical;
requires transitive zoo.animal.feeding;
}

module zoo.animal.talks {
exports zoo.animal.talks.content to zoo.staff;
exports zoo.animal.talks.media;
exports zoo.animal.talks.schedule;
// no longer needed requires zoo.animal.feeding;
// no longer needed requires zoo.animal.care;
requires transitive zoo.animal.care;
}

module zoo.staff {
// no longer needed requires zoo.animal.feeding;
// no longer needed requires zoo.animal.care;
requires zoo.animal.talks;
}
35
Q

Effects of requires transitive

A

test

36
Q

Duplicate requires Statements

module bad.module {
requires zoo.animal.talks;
requires transitive zoo.animal.talks;
}
A

Java doesn’t allow you to repeat the same module in a requires clause. It is redundant and most like an error in coding. Keep in mind that requires transitive is like requires plus some extra behavior.

37
Q

PROVIDES, USES, AND OPENS

A

The provides keyword specifies that a class provides an implementation of a service.
To use it, you supply the API and class name that implements the API:

provides zoo.staff.ZooApi with zoo.staff.ZooImpl

The uses keyword specifies that a module is relying on a service. To code
it, you supply the API you want to call:

uses zoo.staff.ZooApi
38
Q

Discovering Modules

A
  • “unjar” it and open the module-info file.
  • THE JAVA COMMAND
java -p mods -d zoo.animal.feeding
java -p mods --describe-module zoo.animal.feeding

*

39
Q

Discovering Modules

A

The java command now has an option to describe a module. The following two commands are equivalent:

java -p mods -d zoo.animal.feeding

java -p mods --describe-module zoo.animal.feeding

Each prints information about the module. For example, it might print this:

zoo.animal.feeding file:///absolutePath/mods/zoo.animal.feeding.jar
exports zoo.animal.feeding
requires java.base mandated
  • The first line is the module we asked about: zoo.animal.feeding.
  • The second line starts information about the module. In our case, it is the same package exports statement we had in the module-info file.
  • On the third line, we see requires java.base mandated. Now wait a minute. The module-info file very clearly does not specify any modules that zoo.animal.feeding has as dependencies.

The java.base module is special. It is automatically added as a dependency to all modules. This module has frequently used packages like java.util. That’s what the mandated is about. You get java.base whether you asked for it or not.

In classes, the java.lang package is automatically imported whether you type it or not. The java.base module works the same way. It is automatically available to all other modules.

40
Q 
zoo.animal.feeding file:///absolutePath/mods/zoo.animal.feeding.jar
exports zoo.animal.feeding
requires java.base mandated
A
  • The first line is the module we asked about: zoo.animal.feeding.
  • The second line starts information about the module. In our case, it is the same package exports statement we had in the module-info file.
  • On the third line, we see requires java.base mandated. Now wait a minute. The module-info file very clearly does not specify any modules that zoo.animal.feeding has as dependencies.
  • The java.base module is special. It is automatically added as a dependency to all modules. This module has frequently used packages like java.util. That’s what the mandated is about. You get java.base whether you asked for it or not.
  • In classes, the java.lang package is automatically imported whether you type it or not. The java.base module works the same way. It is automatically available to all other modules.
41
Q

module-info in zoo.animal.care:

module zoo.animal.care {
exports zoo.animal.care.medical to zoo.staff;
requires transitive zoo.animal.feeding;
}
A

Now we have the command to describe the module and the output.

java -p mods -d zoo.animal.care

zoo.animal.care file:///absolutePath/mods/zoo.animal.care.jar
requires zoo.animal.feeding transitive
requires java.base mandated
qualified exports zoo.animal.care.medical to zoo.staff
contains zoo.animal.care.details
  • The first line of the output is the absolute path of the module file.
  • The two requires lines should look familiar as well.
  • The first is in the module-info, and the other is added to all modules.
  • Next comes something new. The qualified exports is the full name of exporting to a specific module.
  • Finally, the contains means that there is a package in the module that is not exported at all. This is true. Our module has two packages, and one is available only to code inside the module.
42
Q

THE JAVA COMMAND

A

test

43
Q

Describing a Module

A

test

44
Q

MORE ABOUT DESCRIBING MODULES

A

As a reminder, the following are the contents of module-info in zoo.animal.care:

module zoo.animal.care {
exports zoo.animal.care.medical to zoo.staff;
requires transitive zoo.animal.feeding;
}

Now we have the command to describe the module and the output.

java -p mods -d zoo.animal.care

zoo.animal.care file:///absolutePath/mods/zoo.animal.care.jar
requires zoo.animal.feeding transitive
requires java.base mandated
qualified exports zoo.animal.care.medical to zoo.staff
contains zoo.animal.care.details

The first line of the output is the absolute path of the module file. The two requires lines should look familiar as well. The first is in the module-info, and the other is added to all modules. Next comes something new. The qualified exports is the full name of exporting to a specific module.

Finally, the contains means that there is a package in the module that is not exported at all. This is true. Our module has two packages, and one is available only to code inside the module.

45
Q

Listing Available Modules

A

you can use the java command to list the modules that are available. The simplest form lists the modules that are part of the JDK:

java --list-modules

When we ran it, the output went on for 70 lines and looked like this:

java.base@11.0.2
java.compiler@11.0.2
java.datatransfer@11.0.2

This is a listing of all the modules that come with Java and their version numbers. You can tell that we were using Java 11.0.2 when testing this example.

java -p mods --list-modules
zoo.animal.care file:///absolutePath/mods/zoo.animal.care.jar
zoo.animal.feeding file:///absolutePath/mods/zoo.animal.feeding.jar
zoo.animal.talks file:///absolutePath/mods/zoo.animal.talks.jar
zoo.staff file:///absolutePath/mods/zoo.staff.jar

Since these are custom modules, we get a location on the file system. If the project had a module version number, it would have both the version number and the file system path.

46
Q

Showing Module Resolution

A

In case listing the modules didn’t give you enough output, you can also use the –show-module-resolution option. You can think of it as a way of debugging modules. It spits out a lot of output when the program starts up.
Then it runs the program.

java --show-module-resolution -p feeding -m zoo.animal.feeding/zoo.animal.feeding.Task

Luckily you don’t need to understand this output. That said, having seen it will make it easier to remember. Here’s a snippet of the output:

root zoo.animal.feeding file:///absolutePath/feeding/
java.base binds java.desktop jrt:/java.desktop
java.base binds jdk.jartool jrt:/jdk.jartool
...
jdk.security.auth requires java.naming jrt:/java.naming
jdk.security.auth requires java.security.jgss jrt:/java.security.jgss
...

All fed!

It starts out by listing the root module. That’s the one we are running:
zoo.animal .feeding. Then it lists many lines of packages included by the mandatory java.base module. After a while, it lists modules that have dependencies. Finally, it outputs the result of the program All fed!. The total output of this command is 66 lines.

47
Q

THE JAR COMMAND

A

the jar command can describe a module. Both of these commands are equivalent:

jar -f mods/zoo.animal.feeding.jar -d
jar --file mods/zoo.animal.feeding.jar --describe-module

The output is slightly different from when we used the java command to describe the module. With jar, it outputs the following:

zoo.animal.feeding jar:file:///absolutePath/mods/zoo.animal.feeding.jar
/!module-info.class
exports zoo.animal.feeding
requires java.base mandated

The JAR version includes the module-info in the filename, which is not a particularly significant difference in the scheme of things. You don’t need to know this difference. You do need to know that both commands can describe a module.

48
Q

THE JDEPS COMMAND

A

The jdeps command gives you information about dependencies within a module.

it looks at the code in addition to the module-info file.

This tells you what dependencies are actually used rather than simply declared.

Let’s start with a simple example and ask for a summary of the dependencies in zoo.animal.feeding. Both of these commands give the same output:

jdeps -s mods/zoo.animal.feeding.jar
jdeps -summary mods/zoo.animal.feeding.jar

Notice that there is one dash (-) before -summary rather than two.

Regardless, the output tells you that there is only one package and it depends on the built-in java.base module.

zoo.animal.feeding -> java.base

Alternatively, you can call jdeps without the summary option and get the long form:

jdeps mods/zoo.animal.feeding.jar
[file:///absolutePath/mods/zoo.animal.feeding.jar]
requires mandated java.base (@11.0.2)
zoo.animal.feeding -> java.base
zoo.animal.feeding -> java.io
java.base
zoo.animal.feeding -> java.lang
java.base
  • The first part of the output shows the module filename and path.
  • The second part lists the required java.base dependency and version number.
  • This has the high-level summary that matches the previous example.
  • Finally, the last four lines of the output list the specific packages within the java.base modules that are used by zoo.animal.feeding.
49
Q 
jdeps -s --module-path mods mods/zoo.animal.care.jar

jdeps -summary --module-path mods mods/zoo.animal.care.jar
A

There is not a short form of –module-path in the jdeps command. The output is only two lines:

zoo.animal.care -> java.base
zoo.animal.care -> zoo.animal.feeding

We can see that the zoo.animal.care module depends on our custom zoo.animal.feeding module along with the built-in java.base.

In case you were worried the output was too short, we can run it in full mode:

jdeps --module-path mods mods/zoo.animal.care.jar

This time we get lots of output:

zoo.animal.care
[file:///absolutePath/mods/zoo.animal.care.jar]
requires mandated java.base (@11.0.2)
requires transitive zoo.animal.feeding
zoo.animal.care -> java.base
zoo.animal.care -> zoo.animal.feeding
zoo.animal.care.details -> java.lang
java.base
zoo.animal.care.details -> zoo.animal.feeding
zoo.animal.feeding
zoo.animal.care.medical -> java.lang
java.base

As before, there are three sections.
* The first section is the filename and required dependencies.
* The second section is the summary showing the two module dependencies with an arrow.
* The last six lines show the package-level dependencies.

50
Q

THE JMOD COMMAND

A

JMOD files are recommended only when you have native libraries or something that can’t go inside a JAR file. This is unlikely to affect you in the real world.

The most important thing to remember is that jmod is only for working with the JMOD files.

51
Q

Reviewing Command-Line Options

A

test

J17 notes (26 decks)

Brainscape helps you reach your goals faster, through stronger study habits.
© 2024 Bold Learning Solutions. Terms and Conditions