最新章節

• Summary
• Wrapping up
• Integrating with JUnit
• Testing a Java 9 module
• Unit testing modules with Java 9
• Understanding the exec plugin's module path

• Summary 更新時間：2021-07-02 18:38:52
• Wrapping up
• Integrating with JUnit
• Testing a Java 9 module
• Unit testing modules with Java 9
• Understanding the exec plugin's module path
• Executing the multi-module project
• Building the multi-module project
• Working on a multi-module Java 9 Maven project
• Using Maven with Java 9 modules
• A Maven refresher
• Integrating with Apache Maven
• Using Build Tools and Testing Java Modules
• Summary
• Building libraries for multiple Java versions
• Using jdeps to create module descriptors
• Reserving library names
• Migrating libraries
• Handling larger codebases
• Refactoring into smaller modules
• Using jdeps to outline module relationships
• Migrating with automatic modules
• Automatic module definition
• Automatic module naming
• Automatic modules
• Beginning the migration
• Understanding the migration goal
• Migrating Your Code to Java 9
• Summary
• Recommended strategy
• Understanding the impact
• Overriding module behavior
• The jdeps tool
• Handling non-standard access
• The unnamed module
• Using the Java 9 compiler and runtime
• Introducing the sample Java 8 application
• Beginning Java 9 migration
• Preparing Your Code for Java 9
• Summary
• Example
• Pattern 11 - Aggregator and facade modules
• Pattern 10 - Protect against dependency leakage
• Pattern 9 - Design for changes
• Pattern 8 - Use tooling for version control
• Example
• Pattern 7 - Open modules for reflection
• Pattern 6 - Bundle model classes as separate sharable modules
• Example
• Pattern 4 - Optional dependencies using services
• Example
• Pattern 3 - Optional dependencies
• Example
• Pattern 2 - Services for multiple dynamic implementations
• Example
• Pattern 1 - Public interface private implementation and factory class
• Java modules coding patterns and strategies
• Designing API
• Modularizing by change patterns
• Modularizing by layers
• Modularizing by concerns
• Reusability
• Team structure
• Scoping
• Designing modules
• Module Design Patterns and Strategies
• Summary
• Building a modular JAR file
• Link phase optimizations and jlink plugins
• The jlink command
• Linking using jlink
• Revisiting the state of the JDK
• Examining module resolution in action
• Module resolution steps
• Module resolution process
• Understanding Linking and Using jlink
• Summary
• Services and the module system goals
• Selective service instantiation
• Service interface provider lookup
• Implementing service priorities
• Supporting singleton and factory providers
• Advanced services
• Drawing the module graph
• Implementing sorting services
• Creating and using services
• The service registry
• Understanding services
• The problem of coupling
• Introducing Services
• Summary
• Optimizing module exports
• Optimizing module imports
• Creating a custom aggregator module
• Applying the concepts to address book viewer
• Qualified exports
• Java platform aggregator modules
• Aggregator modules
• Implied readability
• Tweaking modularity
• Split packages
• Interface and implementation accessibility
• Accessibility
• Readability
• Module Resolution Readability and Accessibility
• Summary
• Creating the module
• Adding UI with Java FX
• Consuming the new module
• Dependency leakage
• Shared classes
• Coding the ContactLoader class
• Coding the XmlUtil class
• Creating the module
• Removing the hard-coded contact list
• Reading contacts from an XML file
• Using an alternative compiler command
• Adding logging ability
• Using Platform APIs
• Summary
• Solving the API encapsulation problem
• Solving the monolithic runtime
• Revisiting the two problems
• Observable modules
• Examining platform file structure
• Module types
• Browsing modules
• The java.base module
• Module graph
• The impact of platform modularity
• Platform modularity
• Enter Project Jigsaw
• The attempted solution - Deprecation warnings and documentation
• The problem with this model
• Understanding internal APIs
• The state of API encapsulation
• The attempted solution - Compact profiles
• The problem with this model
• Understanding rt.jar
• The JRE structure
• Examining the legacy JDK
• Introducing the Modular JDK
• Summary
• Revisiting the classpath problems
• Revisiting classpath
• Understanding module path arguments
• Rethinking package structure
• Module versioning
• Configuring module dependency
• Compiling two modules
• Creating the second module
• Handling Inter-Module Dependencies
• Summary
• Handling possible errors
• The address book viewer application
• Creating a module using NetBeans
• Executing your module
• Compiling your module
• Creating your first Java module
• Creating a module
• What is a module?
• Traditional Java code structure
• Java 9 modules
• Setting up the NetBeans IDE
• Switching between JDKs
• Setting up the JDK
• Creating Your First Java Module
• Summary
• Project Jigsaw
• Java Platform Module System
• Internal APIs
• Legacy classes
• Java - the 20-year-old code base
• The classpath problem
• The impossible task of a deployment engineer
• The unfortunate tale of a library developer
• Rethinking Java development with packages
• Modularity in Java
• Introducing Java 9 Modularity
• Questions
• Piracy
• Errata
• Downloading the example code
• Customer support
• Reader feedback
• Conventions
• Who this book is for
• What you need for this book
• What this book covers
• Preface
• Customer Feedback
• Why subscribe?
• www.PacktPub.com
• About the Reviewers
• About the Author
• Credits
• Modular Programming in Java 9
• Copyright
• Title Page
• cover

• cover
• 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 更新時間：2021-07-02 18:38:52