舉報 
會員
Modular Programming in Java 9
最新章節(jié)：
Summary
ThisbookiswrittenforJavadeveloperswhoareinterestedinlearningandunderstandingthetechniquesandbestpracticestobuildmodularapplicationsinJava.ThebookassumessomepreviousprogrammingexperienceinJava8orearlier,familiaritywiththebasicJavatypessuchasclassesandinterfaces,aswellasexperienceincompilingandexecutingJavaprograms.
最新章節(jié)
- Summary
- Wrapping up
- Integrating with JUnit
- Testing a Java 9 module
- Unit testing modules with Java 9
- Understanding the exec plugin's module path
品牌：中圖公司
上架時間：2021-07-02 18:14:48
出版社：Packt Publishing
本書數(shù)字版權(quán)由中圖公司提供，并由其授權(quán)上海閱文信息技術(shù)有限公司制作發(fā)行
- 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
