Modular Programming in Java 9电子书

Title Page

Copyright

Modular Programming in Java 9

Credits

About the Author

About the Reviewers

www.PacktPub.com

Why subscribe?

Customer Feedback

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

Introducing Java 9 Modularity

Modularity in Java

Rethinking Java development with packages

The unfortunate tale of a library developer

The impossible task of a deployment engineer

The classpath problem

Java - the 20-year-old code base

Legacy classes

Internal APIs

Java Platform Module System

Project Jigsaw

Summary

Creating Your First Java Module

Setting up the JDK

Switching between JDKs

Setting up the NetBeans IDE

Java 9 modules

Traditional Java code structure

What is a module?

Creating a module

Creating your first Java module

Compiling your module

Executing your module

Creating a module using NetBeans

The address book viewer application

Handling possible errors

Summary

Handling Inter-Module Dependencies

Creating the second module

Compiling two modules

Configuring module dependency

Module versioning

Rethinking package structure

Understanding module path arguments

Revisiting classpath

Revisiting the classpath problems

Summary

Introducing the Modular JDK

Examining the legacy JDK

The JRE structure

Understanding rt.jar

The problem with this model

The attempted solution - Compact profiles

The state of API encapsulation

Understanding internal APIs

The problem with this model

The attempted solution - Deprecation, warnings, and documentation

Enter Project Jigsaw

Platform modularity

The impact of platform modularity

Module graph

The java.base module

Browsing modules

Module types

Examining platform file structure

Observable modules

Revisiting the two problems

Solving the monolithic runtime

Solving the API encapsulation problem

Summary

Using Platform APIs

Adding logging ability

Using an alternative compiler command

Reading contacts from an XML file

Removing the hard-coded contact list

Creating the module

Coding the XmlUtil class

Coding the ContactLoader class

Shared classes

Dependency leakage

Consuming the new module

Adding UI with Java FX

Creating the module

Summary

Module Resolution, Readability, and Accessibility

Readability

Accessibility

Interface and implementation accessibility

Split packages

Tweaking modularity

Implied readability

Aggregator modules

Java platform aggregator modules

Qualified exports

Applying the concepts to address book viewer

Creating a custom aggregator module

Optimizing module imports

Optimizing module exports

Summary

Introducing Services

The problem of coupling

Understanding services

The service registry

Creating and using services

Implementing sorting services

Drawing the module graph

Advanced services

Supporting singleton and factory providers

Implementing service priorities

Service interface provider lookup

Selective service instantiation

Services and the module system goals

Summary

Understanding Linking and Using jlink

Module resolution process

Module resolution steps

Examining module resolution in action

Revisiting the state of the JDK

Linking using jlink

The jlink command

Link phase optimizations and jlink plugins

Building a modular JAR file

Summary

Module Design Patterns and Strategies

Designing modules

Scoping

Team structure

Reusability

Modularizing by concerns

Modularizing by layers

Modularizing by change patterns

Designing API

Java modules coding patterns and strategies

Pattern 1 - Public interface, private implementation, and factory class

Example

Pattern 2 - Services for multiple dynamic implementations

Example

Pattern 3 - Optional dependencies

Example

Pattern 4 - Optional dependencies using services

Example

Pattern 6 - Bundle model classes as separate sharable modules

Pattern 7 - Open modules for reflection

Example

Pattern 8 - Use tooling for version control

Pattern 9 - Design for changes

Pattern 10 - Protect against dependency leakage

Pattern 11 - Aggregator and facade modules

Example

Summary

Preparing Your Code for Java 9

Beginning Java 9 migration

Introducing the sample Java 8 application

Using the Java 9 compiler and runtime

The unnamed module

Handling non-standard access

The jdeps tool

Overriding module behavior

Understanding the impact

Recommended strategy

Summary

Migrating Your Code to Java 9

Understanding the migration goal

Beginning the migration

Automatic modules

Automatic module naming

Automatic module definition

Migrating with automatic modules

Using jdeps to outline module relationships

Refactoring into smaller modules

Handling larger codebases

Migrating libraries

Reserving library names

Using jdeps to create module descriptors

Building libraries for multiple Java versions

Summary

Using Build Tools and Testing Java Modules

Integrating with Apache Maven

A Maven refresher

Using Maven with Java 9 modules

Working on a multi-module Java 9 Maven project

Building the multi-module project

Executing the multi-module project

Understanding the exec plugin's module path

Unit testing modules with Java 9

Testing a Java 9 module

Integrating with JUnit

Wrapping up

Summary