Java 9 Modularity
Patterns and Practices for Developing Maintainable Applications
Published on 7. September 2017
300 pages
978-1-4919-5413-3 (ISBN)
Description
The upcoming Java 9 module system will affect existing applications and offer new ways of creating modular and maintainable applications. With this hands-on book, Java developers will learn not only about the joys of modularity, but also about the patterns needed to create truly modular and reliable applications. Authors Sander Mak and Paul Bakker teach you the concepts behind the Java 9 module system, along with the new tools it offers. Youll also learn how to modularize existing code and how to build new Java applications in a modular way.Understand Java 9 module system conceptsMaster the patterns and practices for building truly modular applicationsMigrate existing applications and libraries to Java 9 modulesUse JDK 9 tools for modular development and migration
More details
Other editions
Additional editions
Content
- Intro
- Copyright
- Table of Contents
- Foreword
- Preface
- Who Should Read This Book
- Why We Wrote This Book
- Navigating This Book
- Using Code Examples
- Conventions Used in This Book
- O'Reilly Safari
- How to Contact Us
- Acknowledgments
- Part I. Introduction to the Java Module System
- Chapter 1. Modularity Matters
- What Is Modularity?
- Before Java 9
- JARs as Modules?
- Classpath Hell
- Java 9 Modules
- Chapter 2. Modules and the Modular JDK
- The Modular JDK
- Module Descriptors
- Readability
- Accessibility
- Implied Readability
- Qualified Exports
- Module Resolution and the Module Path
- Using the Modular JDK Without Modules
- Chapter 3. Working with Modules
- Your First Module
- Anatomy of a Module
- Naming Modules
- Compilation
- Packaging
- Running Modules
- Module Path
- Linking Modules
- No Module Is an Island
- Introducing the EasyText Example
- A Tale of Two Modules
- Working with Platform Modules
- Finding the Right Platform Module
- Creating a GUI Module
- The Limits of Encapsulation
- Interfaces and Instantiation
- Chapter 4. Services
- Factory Pattern
- Services for Implementation Hiding
- Providing Services
- Consuming Services
- Service Life Cycle
- Service Provider Methods
- Factory Pattern Revisited
- Default Service Implementations
- Service Implementation Selection
- Service Type Inspection and Lazy Instantiation
- Module Resolution with Service Binding
- Services and Linking
- Chapter 5. Modularity Patterns
- Determining Module Boundaries
- Lean Modules
- API Modules
- What Should Be in an API Module?
- Implied Readability
- API Module with a Default Implementation
- Aggregator Modules
- Building a Facade over Modules
- Safely Splitting a Module
- Avoiding Cyclic Dependencies
- Split Packages
- Breaking Cycles
- Optional Dependencies
- Compile-Time Dependencies
- Implementing Optional Dependencies with Services
- Versioned Modules
- Module Resolution and Versioning
- Resource Encapsulation
- Loading Resources from a Module
- Loading Resources Across Modules
- Working with ResourceBundles
- Chapter 6. Advanced Modularity Patterns
- Strong Encapsulation Revisited
- Deep Reflection
- Open Modules and Packages
- Dependency Injection
- Reflection on Modules
- Introspection
- Modifying Modules
- Annotations
- Container Application Patterns
- Layers and Configurations
- Classloading in Layers
- Plug-in Architectures
- Container Architectures
- Resolving Platform Modules in Containers
- Part II. Migration
- Chapter 7. Migration Without Modules
- The Classpath Is Dead, Long Live the Classpath
- Libraries, Strong Encapsulation, and the JDK 9 Classpath
- Compilation and Encapsulated APIs
- Removed Types
- Using JAXB and Other Java EE APIs
- The jdk.unsupported Module
- Other Changes
- Chapter 8. Migration to Modules
- Migration Strategies
- A Simple Example
- Mixing Classpath and Module Path
- Automatic Modules
- Open Packages
- Open Modules
- VM Arguments to Break Encapsulation
- Automatic Modules and the Classpath
- Using jdeps
- Loading Code Dynamically
- Split Packages
- Chapter 9. Migration Case Study: Spring and Hibernate
- Getting Familiar with the Application
- Running on the Classpath with Java 9
- Setting Up for Modules
- Using Automatic Modules
- Java Platform Dependencies and Automatic Modules
- Opening Packages for Reflection
- Fixing Illegal Access
- Refactor to Multiple Modules
- Chapter 10. Library Migration
- Before Modularization
- Choosing a Library Module Name
- Creating a Module Descriptor
- Updating a Library with a Module Descriptor
- Targeting Older Java Versions
- Library Module Dependencies
- Internal Dependencies
- External Dependencies
- Targeting Multiple Java Versions
- Multi-Release JARs
- Modular Multi-Release JARs
- Part III. Modular Development Tooling
- Chapter 11. Build Tools and IDEs
- Apache Maven
- Multimodule Projects
- EasyText with Apache Maven
- Running a Modular Application with Apache Maven
- Gradle
- IDEs
- Chapter 12. Testing Modules
- Blackbox Tests
- Blackbox Tests with JUnit
- Whitebox Tests
- Test Tooling
- Chapter 13. Scaling Down with Custom Runtime Images
- Static Versus Dynamic Linking
- Using jlink
- Finding the Right Service Provider Modules
- Module Resolution During Linking
- jlink for Classpath-Based Applications
- Reducing Size
- Improving Performance
- Cross-Targeting Runtime Images
- Chapter 14. A Modular Future
- OSGi
- Java EE
- Microservices
- Next Steps
- Index
- About the Authors
- Colophon
