ebook img

Java 9 Revealed for early Adoption and Migration PDF

527 Pages·2017·4.56 MB·English
Save to my drive
Quick download
Download
Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.

Preview Java 9 Revealed for early Adoption and Migration

Java 9 Revealed For Early Adoption and Migration Kishori Sharan Java 9 Revealed: For Early Adoption and Migration Kishori Sharan Montgomery, Alabama, USA ISBN-13 (pbk): 978-1-4842-2591-2 ISBN-13 (electronic): 978-1-4842-2592-9 DOI 10.1007/978-1-4842-2592-9 Library of Congress Control Number: 2017939348 Copyright © 2017 by Kishori Sharan Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book's product page, located at www.apress.com/9781484225912. For more detailed information, please visit http://www.apress.com/source-code. Contents at a Glance About the Author ����������������������������������������������������������������������������������������������������xix About the Technical Reviewer ��������������������������������������������������������������������������������xxi Acknowledgments ������������������������������������������������������������������������������������������������xxiii Introduction �����������������������������������������������������������������������������������������������������������xxv ■ Chapter 1: Introduction �����������������������������������������������������������������������������������������1 ■ Chapter 2: The Module System ������������������������������������������������������������������������������7 ■ Chapter 3: Creating Your First Module ����������������������������������������������������������������31 ■ Chapter 4: Module Dependency ���������������������������������������������������������������������������57 ■ Chapter 5: Implementing Services ��������������������������������������������������������������������105 ■ Chapter 6: Packaging Modules ��������������������������������������������������������������������������127 ■ Chapter 7: Creating Custom Runtime Images����������������������������������������������������147 ■ Chapter 8: Breaking Changes in JDK 9 ��������������������������������������������������������������159 ■ Chapter 9: Breaking Module Encapsulation ������������������������������������������������������197 ■ Chapter 10: The Module API ������������������������������������������������������������������������������211 ■ Chapter 11: The Java Shell ��������������������������������������������������������������������������������249 ■ Chapter 12: Process API Updates ����������������������������������������������������������������������313 ■ Chapter 13: Collection API Updates �������������������������������������������������������������������333 ■ Chapter 14: The HTTP/2 Client API ��������������������������������������������������������������������347 ■ Chapter 15: Enhanced Deprecation �������������������������������������������������������������������377 ■ Chapter 16: Stack Walking ��������������������������������������������������������������������������������391 ■ Chapter 17: Reactive Streams ���������������������������������������������������������������������������411 ■ Chapter 18: Streams API Updates ���������������������������������������������������������������������429 ■ Chapter 19: Platform and JVM Logging �������������������������������������������������������������441 ■ Chapter 20: Other Changes in JDK 9 �����������������������������������������������������������������461 Index ���������������������������������������������������������������������������������������������������������������������515 Contents About the Author ����������������������������������������������������������������������������������������������������xix About the Technical Reviewer ��������������������������������������������������������������������������������xxi Acknowledgments ������������������������������������������������������������������������������������������������xxiii Introduction �����������������������������������������������������������������������������������������������������������xxv ■ Chapter 1: Introduction �����������������������������������������������������������������������������������������1 Introduction to JDK 9 ��������������������������������������������������������������������������������������������������������1 How to Read This Book ����������������������������������������������������������������������������������������������������2 System Requirements ������������������������������������������������������������������������������������������������������3 Installing the NetBeans IDE ����������������������������������������������������������������������������������������������4 Downloading the Source Code �����������������������������������������������������������������������������������������5 ■ Chapter 2: The Module System ������������������������������������������������������������������������������7 Life Before Java 9 ������������������������������������������������������������������������������������������������������������7 The New Module System��������������������������������������������������������������������������������������������������9 What Is a Module? ����������������������������������������������������������������������������������������������������������10 Module Dependencies ����������������������������������������������������������������������������������������������������11 Module Graph ���������������������������������������������������������������������������������������������������������������������������������������13 Aggregator Modules �������������������������������������������������������������������������������������������������������17 Declaring Modules ���������������������������������������������������������������������������������������������������������17 Module Names ��������������������������������������������������������������������������������������������������������������������������������������19 Controlling Access to Modules �������������������������������������������������������������������������������������������������������������20 Declaring Dependency ��������������������������������������������������������������������������������������������������������������������������21 Configuring Services ����������������������������������������������������������������������������������������������������������������������������21 Module Descriptors ��������������������������������������������������������������������������������������������������������22 Compiling Module Declarations ������������������������������������������������������������������������������������������������������������22 Module Version �������������������������������������������������������������������������������������������������������������������������������������23 Module Source Files Structure �������������������������������������������������������������������������������������������������������������23 Packaging Modules ��������������������������������������������������������������������������������������������������������24 A Module in a Directory ������������������������������������������������������������������������������������������������������������������������24 A Module in a Modular JAR ������������������������������������������������������������������������������������������������������������������24 A Module in a JMOD File�����������������������������������������������������������������������������������������������������������������������25 Module Path �������������������������������������������������������������������������������������������������������������������25 Observable Modules �������������������������������������������������������������������������������������������������������28 Summary ������������������������������������������������������������������������������������������������������������������������29 ■ Chapter 3: Creating Your First Module ����������������������������������������������������������������31 Using the Command Prompt ������������������������������������������������������������������������������������������31 Setting Up the Directories���������������������������������������������������������������������������������������������������������������������31 Writing the Source Code �����������������������������������������������������������������������������������������������������������������������32 Compiling the Source Code ������������������������������������������������������������������������������������������������������������������33 Packaging the Module Code �����������������������������������������������������������������������������������������������������������������35 Running the Program ����������������������������������������������������������������������������������������������������������������������������36 Using the NetBeans IDE ��������������������������������������������������������������������������������������������������39 Configuring the IDE �������������������������������������������������������������������������������������������������������������������������������39 Creating the Java Project ���������������������������������������������������������������������������������������������������������������������43 Setting the Project Properties ���������������������������������������������������������������������������������������������������������������45 Adding the Module Declaration ������������������������������������������������������������������������������������������������������������47 Viewing Module Graph ��������������������������������������������������������������������������������������������������������������������������50 Writing the Source Code �����������������������������������������������������������������������������������������������������������������������50 Compiling the Source Code ������������������������������������������������������������������������������������������������������������������52 Packaging the Module Code �����������������������������������������������������������������������������������������������������������������52 Running the Program ����������������������������������������������������������������������������������������������������������������������������53 Summary ������������������������������������������������������������������������������������������������������������������������55 ■ Chapter 4: Module Dependency ���������������������������������������������������������������������������57 Declaring Module Dependency ���������������������������������������������������������������������������������������57 Troubleshooting the Example �����������������������������������������������������������������������������������������65 Empty Package Error ����������������������������������������������������������������������������������������������������������������������������65 Module Not Found Error������������������������������������������������������������������������������������������������������������������������66 Package Does Not Exist Error ���������������������������������������������������������������������������������������������������������������66 Module Resolution Exception ���������������������������������������������������������������������������������������������������������������66 Implicit Readability ���������������������������������������������������������������������������������������������������������67 Qualified Exports ������������������������������������������������������������������������������������������������������������72 Optional Dependency �����������������������������������������������������������������������������������������������������73 Accessing Modules Using Reflection �����������������������������������������������������������������������������74 Open Modules ���������������������������������������������������������������������������������������������������������������������������������������75 Opening Packages ��������������������������������������������������������������������������������������������������������������������������������75 Using Deep Reflection ��������������������������������������������������������������������������������������������������������������������������76 Type Accessibility �����������������������������������������������������������������������������������������������������������85 Splitting Packages Across Modules �������������������������������������������������������������������������������85 Restrictions in Module Declarations �������������������������������������������������������������������������������86 Types of Modules �����������������������������������������������������������������������������������������������������������86 Normal Modules �����������������������������������������������������������������������������������������������������������������������������������88 Open Modules ���������������������������������������������������������������������������������������������������������������������������������������88 Automatic Modules �������������������������������������������������������������������������������������������������������������������������������88 Unnamed Modules ��������������������������������������������������������������������������������������������������������������������������������92 Migration Path to JDK 9 �������������������������������������������������������������������������������������������������98 Dissembling Module Definitions �������������������������������������������������������������������������������������99 Summary ����������������������������������������������������������������������������������������������������������������������103 ■ Chapter 5: Implementing Services ��������������������������������������������������������������������105 What Is a Service? ��������������������������������������������������������������������������������������������������������105 Discovering Services ����������������������������������������������������������������������������������������������������107 Providing Service Implementations ������������������������������������������������������������������������������108 Defining the Service Interface ��������������������������������������������������������������������������������������110 Defining Service Providers �������������������������������������������������������������������������������������������113 Defining a Generic Prime Service Provider �����������������������������������������������������������������������������������������113 Defining a Faster Prime Service Provider �������������������������������������������������������������������������������������������115 Defining a Fastest Prime Service Provider �����������������������������������������������������������������������������������������117 Testing the Prime Service ��������������������������������������������������������������������������������������������118 Selecting and Filtering Providers ���������������������������������������������������������������������������������121 Testing Prime Service in Legacy Mode ������������������������������������������������������������������������123 Summary ����������������������������������������������������������������������������������������������������������������������125 ■ Chapter 6: Packaging Modules ��������������������������������������������������������������������������127 The JAR Format ������������������������������������������������������������������������������������������������������������127 What Is a Multi-Release JAR? ������������������������������������������������������������������������������������������������������������128 Creating Multi-Release JARs ��������������������������������������������������������������������������������������������������������������129 Rules for Multi-Release JARs �������������������������������������������������������������������������������������������������������������136 Multi-Release JARs and JAR URL �������������������������������������������������������������������������������������������������������137 Multi-Release Manifest Attribute ��������������������������������������������������������������������������������������������������������138 The JMOD Format ��������������������������������������������������������������������������������������������������������138 Using the jmod Tool ����������������������������������������������������������������������������������������������������������������������������138 Summary ����������������������������������������������������������������������������������������������������������������������145 ■ Chapter 7: Creating Custom Runtime Images����������������������������������������������������147 What Is a Custom Runtime Image? ������������������������������������������������������������������������������147 Creating Custom Runtime Images ��������������������������������������������������������������������������������148 Binding Services ����������������������������������������������������������������������������������������������������������151 Using Plugins with the jlink Tool �����������������������������������������������������������������������������������153 The jimage Tool ������������������������������������������������������������������������������������������������������������156 Summary ����������������������������������������������������������������������������������������������������������������������158 ■ Chapter 8: Breaking Changes in JDK 9 ��������������������������������������������������������������159 The New JDK Versioning Scheme ��������������������������������������������������������������������������������159 Version Number ����������������������������������������������������������������������������������������������������������������������������������160 Prerelease Information �����������������������������������������������������������������������������������������������������������������������161 Build Information ��������������������������������������������������������������������������������������������������������������������������������161 Additional Information ������������������������������������������������������������������������������������������������������������������������161 Parsing Old and New Version Strings �������������������������������������������������������������������������������������������������162 Version Changes to System Properties �����������������������������������������������������������������������������������������������162 Using the Runtime�Version Class ��������������������������������������������������������������������������������������������������������162 Changes to the JDK and JRE ����������������������������������������������������������������������������������������165 Layout Changes in JDK and JRE ���������������������������������������������������������������������������������������������������������166 Behavioral Changes ����������������������������������������������������������������������������������������������������������������������������168 Changes in Class Loaders�������������������������������������������������������������������������������������������������������������������169 Accessing Resources ���������������������������������������������������������������������������������������������������173 Accessing Resources Before JDK 9 ����������������������������������������������������������������������������������������������������173 Accessing Resources in JDK 9 �����������������������������������������������������������������������������������������������������������177 Using JDK Internal APIs ������������������������������������������������������������������������������������������������191 Patching Module Contents �������������������������������������������������������������������������������������������193 Summary ����������������������������������������������������������������������������������������������������������������������195 ■ Chapter 9: Breaking Module Encapsulation ������������������������������������������������������197 What Is Breaking Module Encapsulation? ��������������������������������������������������������������������197 Command-Line Options ������������������������������������������������������������������������������������������������198 The --add-exports Option �������������������������������������������������������������������������������������������������������������������198 The --add-opens Option ���������������������������������������������������������������������������������������������������������������������199 The --add-reads Option ����������������������������������������������������������������������������������������������������������������������200 The --permit-illegal-access Option ����������������������������������������������������������������������������������������������������200 An Example ������������������������������������������������������������������������������������������������������������������201 Using Manifest Attributes of a JAR �������������������������������������������������������������������������������207 Summary ����������������������������������������������������������������������������������������������������������������������210 ■ Chapter 10: The Module API ������������������������������������������������������������������������������211 What Is the Module API?�����������������������������������������������������������������������������������������������211 Representing Modules �������������������������������������������������������������������������������������������������213 Describing Modules ������������������������������������������������������������������������������������������������������213 Representing Module Statements ������������������������������������������������������������������������������������������������������214 Representing a Module Version ����������������������������������������������������������������������������������������������������������216 Other Properties of Modules ���������������������������������������������������������������������������������������������������������������217 Knowing Module Basic Info ����������������������������������������������������������������������������������������������������������������218 Querying Modules ��������������������������������������������������������������������������������������������������������221 Updating Modules ��������������������������������������������������������������������������������������������������������223 Accessing Module Resources ��������������������������������������������������������������������������������������226 Annotation on Modules�������������������������������������������������������������������������������������������������226 Loading Classes �����������������������������������������������������������������������������������������������������������228 Working with Module Layers ����������������������������������������������������������������������������������������231 Finding Modules ���������������������������������������������������������������������������������������������������������������������������������233 Reading Module Contents �������������������������������������������������������������������������������������������������������������������235 Creating Configurations ����������������������������������������������������������������������������������������������������������������������237 Creating Module Layers ����������������������������������������������������������������������������������������������������������������������238 Summary ����������������������������������������������������������������������������������������������������������������������246 ■ Chapter 11: The Java Shell ��������������������������������������������������������������������������������249 What Is the Java Shell? ������������������������������������������������������������������������������������������������249 The JShell Architecture ������������������������������������������������������������������������������������������������251 Starting the JShell Tool ������������������������������������������������������������������������������������������������252 Exiting the JShell Tool ��������������������������������������������������������������������������������������������������254 What Are Snippets and Commands? ����������������������������������������������������������������������������254 Evaluating Expressions ������������������������������������������������������������������������������������������������256 Listing Snippets ������������������������������������������������������������������������������������������������������������258 Editing Snippets �����������������������������������������������������������������������������������������������������������262 Rerunning Previous Snippets ���������������������������������������������������������������������������������������265

See more

The list of books you might like

Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.