ebook img

Exploring Java 9. Build Modularized Applications in Java PDF

175 Pages·2018·2.128 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 Exploring Java 9. Build Modularized Applications in Java

Exploring Java 9 Build Modularized Applications in Java Fu Cheng Exploring Java 9 Fu Cheng Auckland, New Zealand ISBN-13 (pbk): 978-1-4842-3329-0 ISBN-13 (electronic): 978-1-4842-3330-6 https://doi.org/10.1007/978-1-4842-3330-6 Library of Congress Control Number: 2017962328 Copyright © 2018 by Fu Cheng 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/978-1-4842-3329-0. For more detailed information, please visit http://www.apress.com/source-code. Contents ■ Chapter 1: Introduction �����������������������������������������������������������������������������������������1 Installation ������������������������������������������������������������������������������������������������������������������������1 IDE ������������������������������������������������������������������������������������������������������������������������������������2 Intellij IDEA ���������������������������������������������������������������������������������������������������������������������������������������������2 Eclipse ����������������������������������������������������������������������������������������������������������������������������������������������������2 Build Tools ������������������������������������������������������������������������������������������������������������������������4 Gradle �����������������������������������������������������������������������������������������������������������������������������������������������������4 Apache Maven ����������������������������������������������������������������������������������������������������������������������������������������4 javac and java �����������������������������������������������������������������������������������������������������������������������������������������4 Docker ������������������������������������������������������������������������������������������������������������������������������5 CI Builds ���������������������������������������������������������������������������������������������������������������������������6 Summary ��������������������������������������������������������������������������������������������������������������������������6 ■ Chapter 2: The Module System ������������������������������������������������������������������������������7 Module Introduction ���������������������������������������������������������������������������������������������������������8 Sample Application �����������������������������������������������������������������������������������������������������������8 Module Declaration ����������������������������������������������������������������������������������������������������������9 requires and exports �������������������������������������������������������������������������������������������������������������������������������9 Transitive Dependencies �������������������������������������������������������������������������������������������������������������������������9 Static Dependencies �����������������������������������������������������������������������������������������������������������������������������12 Services ������������������������������������������������������������������������������������������������������������������������������������������������12 Qualified Exports ����������������������������������������������������������������������������������������������������������������������������������14 Opening Modules and Packages ����������������������������������������������������������������������������������������������������������14 Working with Existing Code ��������������������������������������������������������������������������������������������15 Unnamed Modules ��������������������������������������������������������������������������������������������������������������������������������15 Automatic Modules �������������������������������������������������������������������������������������������������������������������������������16 JDK Tools ������������������������������������������������������������������������������������������������������������������������17 Module Paths ����������������������������������������������������������������������������������������������������������������������������������������17 Module Version �������������������������������������������������������������������������������������������������������������������������������������18 The Main Module ����������������������������������������������������������������������������������������������������������������������������������18 Root Modules ����������������������������������������������������������������������������������������������������������������������������������������18 Limiting the Observable Modules ���������������������������������������������������������������������������������������������������������19 Upgrading the Module Path ������������������������������������������������������������������������������������������������������������������19 Increasing Readability and Breaking Encapsulation�����������������������������������������������������������������������������19 javac �����������������������������������������������������������������������������������������������������������������������������������������������������20 jlink �������������������������������������������������������������������������������������������������������������������������������������������������������21 java �������������������������������������������������������������������������������������������������������������������������������������������������������24 jdeps �����������������������������������������������������������������������������������������������������������������������������������������������������24 Module Java API �������������������������������������������������������������������������������������������������������������27 ModuleFinder ����������������������������������������������������������������������������������������������������������������������������������������27 ModuleDescriptor ���������������������������������������������������������������������������������������������������������������������������������28 Configuration ����������������������������������������������������������������������������������������������������������������������������������������31 The Module Layers �������������������������������������������������������������������������������������������������������������������������������34 Class Loaders ���������������������������������������������������������������������������������������������������������������������������������������39 Class �����������������������������������������������������������������������������������������������������������������������������������������������������42 Reflection ���������������������������������������������������������������������������������������������������������������������������������������������43 Automatic Module Names ��������������������������������������������������������������������������������������������������������������������43 Module Artifacts �������������������������������������������������������������������������������������������������������������46 JAR Files �����������������������������������������������������������������������������������������������������������������������������������������������46 JMOD Files ��������������������������������������������������������������������������������������������������������������������������������������������47 JDK Modules �����������������������������������������������������������������������������������������������������������������������������������������49 Common Issues ��������������������������������������������������������������������������������������������������������������49 Migration in Action ���������������������������������������������������������������������������������������������������������51 Building the Project Using Java 9 ���������������������������������������������������������������������������������������������������������51 The Migration Path �������������������������������������������������������������������������������������������������������������������������������51 BioJava �������������������������������������������������������������������������������������������������������������������������������������������������52 Summary ������������������������������������������������������������������������������������������������������������������������56 ■ Chapter 3: jshell ��������������������������������������������������������������������������������������������������57 Code Completion ������������������������������������������������������������������������������������������������������������58 Classes ���������������������������������������������������������������������������������������������������������������������������58 Methods �������������������������������������������������������������������������������������������������������������������������59 Commands ���������������������������������������������������������������������������������������������������������������������59 /list��������������������������������������������������������������������������������������������������������������������������������������������������������59 /edit ������������������������������������������������������������������������������������������������������������������������������������������������������60 /drop �����������������������������������������������������������������������������������������������������������������������������������������������������61 /save �����������������������������������������������������������������������������������������������������������������������������������������������������61 /open ����������������������������������������������������������������������������������������������������������������������������������������������������61 /imports ������������������������������������������������������������������������������������������������������������������������������������������������62 /vars ������������������������������������������������������������������������������������������������������������������������������������������������������62 /types ����������������������������������������������������������������������������������������������������������������������������������������������������62 /methods ����������������������������������������������������������������������������������������������������������������������������������������������63 /history �������������������������������������������������������������������������������������������������������������������������������������������������63 /env �������������������������������������������������������������������������������������������������������������������������������������������������������63 /set �������������������������������������������������������������������������������������������������������������������������������������������������������64 /reset ����������������������������������������������������������������������������������������������������������������������������������������������������64 /reload ��������������������������������������������������������������������������������������������������������������������������������������������������64 /! �����������������������������������������������������������������������������������������������������������������������������������������������������������65 /<id> ����������������������������������������������������������������������������������������������������������������������������������������������������65 /-<n> ����������������������������������������������������������������������������������������������������������������������������������������������������65 /exit �������������������������������������������������������������������������������������������������������������������������������������������������������65 Summary ������������������������������������������������������������������������������������������������������������������������65 ■ Chapter 4: Collections, Stream, and Optional ������������������������������������������������������67 Factory Methods for Collections �������������������������������������������������������������������������������������67 The List�of() Method ������������������������������������������������������������������������������������������������������������������������������67 The Set�of() Method ������������������������������������������������������������������������������������������������������������������������������67 The Map�of() and Map�ofEntries() Methods �������������������������������������������������������������������������������������������68 Arrays �����������������������������������������������������������������������������������������������������������������������������68 Mismatch() Methods �����������������������������������������������������������������������������������������������������������������������������68 Compare() Methods ������������������������������������������������������������������������������������������������������������������������������69 Equals() Methods ����������������������������������������������������������������������������������������������������������������������������������69 Stream ����������������������������������������������������������������������������������������������������������������������������69 The ofNullable() Method �����������������������������������������������������������������������������������������������������������������������69 The dropWhile() Method �����������������������������������������������������������������������������������������������������������������������70 The takeWhile() Method ������������������������������������������������������������������������������������������������������������������������70 The iterate() Method �����������������������������������������������������������������������������������������������������������������������������71 IntStream, LongStream, and DoubleStream �����������������������������������������������������������������������������������������71 Collectors �����������������������������������������������������������������������������������������������������������������������71 The filtering() Method ���������������������������������������������������������������������������������������������������������������������������71 The flatMapping() Method ��������������������������������������������������������������������������������������������������������������������72 Optional ��������������������������������������������������������������������������������������������������������������������������73 The ifPresentOrElse() Method ���������������������������������������������������������������������������������������������������������������73 The Optional�or() Method ����������������������������������������������������������������������������������������������������������������������73 The stream() Method ����������������������������������������������������������������������������������������������������������������������������74 Summary ������������������������������������������������������������������������������������������������������������������������74 ■ Chapter 5: The Process API ���������������������������������������������������������������������������������75 The ProcessHandle Interface �����������������������������������������������������������������������������������������75 Process ���������������������������������������������������������������������������������������������������������������������������77 Managing Long-Running Processes �������������������������������������������������������������������������������78 Summary ������������������������������������������������������������������������������������������������������������������������79 ■ Chapter 6: The Platform Logging API and Service �����������������������������������������������81 Default LoggerFinder Implementation ����������������������������������������������������������������������������82 Creating Custom LoggerFinder Implementations �����������������������������������������������������������83 Summary ������������������������������������������������������������������������������������������������������������������������86 ■ Chapter 7: Reactive Streams �������������������������������������������������������������������������������87 Core Interfaces ���������������������������������������������������������������������������������������������������������������87 Flow�Publisher<T> �������������������������������������������������������������������������������������������������������������������������������87 Flow�Subscriber<T> �����������������������������������������������������������������������������������������������������������������������������87 Flow�Subscription ���������������������������������������������������������������������������������������������������������������������������������88 Flow�Processor<T,R> ���������������������������������������������������������������������������������������������������������������������������88 SubmissionPublisher ������������������������������������������������������������������������������������������������������88 Third-Party Libraries ������������������������������������������������������������������������������������������������������95 RxJava 2 �����������������������������������������������������������������������������������������������������������������������������������������������95 Reactor �������������������������������������������������������������������������������������������������������������������������������������������������96 Interoperability �������������������������������������������������������������������������������������������������������������������������������������97 Summary ������������������������������������������������������������������������������������������������������������������������97 ■ Chapter 8: Variable Handles ��������������������������������������������������������������������������������99 Creating Variable Handles ����������������������������������������������������������������������������������������������99 findStaticVarHandle ������������������������������������������������������������������������������������������������������������������������������99 findVarHandle ���������������������������������������������������������������������������������������������������������������������������������������99 unreflectVarHandle �����������������������������������������������������������������������������������������������������������������������������100 Access Modes ��������������������������������������������������������������������������������������������������������������100 Memory Ordering ��������������������������������������������������������������������������������������������������������������������������������100 VarHandle Methods ����������������������������������������������������������������������������������������������������������������������������101 Arrays �������������������������������������������������������������������������������������������������������������������������������������������������105 byte[] and ByteBuffer Views ���������������������������������������������������������������������������������������������������������������106 Memory Fence �������������������������������������������������������������������������������������������������������������107 Summary ����������������������������������������������������������������������������������������������������������������������107 ■ Chapter 9: Enhanced Method Handles ���������������������������������������������������������������109 arrayConstructor ����������������������������������������������������������������������������������������������������������109 arrayLength ������������������������������������������������������������������������������������������������������������������109 varHandleInvoker and varHandleExactInvoker �������������������������������������������������������������110 zero ������������������������������������������������������������������������������������������������������������������������������110 empty ���������������������������������������������������������������������������������������������������������������������������111 Loops ����������������������������������������������������������������������������������������������������������������������������111 loop �����������������������������������������������������������������������������������������������������������������������������������������������������111 countedLoop ���������������������������������������������������������������������������������������������������������������������������������������113 iteratedLoop����������������������������������������������������������������������������������������������������������������������������������������114 whileLoop and doWhileLoop ���������������������������������������������������������������������������������������������������������������115 Try-finally ���������������������������������������������������������������������������������������������������������������������116 Summary ����������������������������������������������������������������������������������������������������������������������117 ■ Chapter 10: Concurrency �����������������������������������������������������������������������������������119 CompletableFuture �������������������������������������������������������������������������������������������������������119 Async ��������������������������������������������������������������������������������������������������������������������������������������������������119 Timeout �����������������������������������������������������������������������������������������������������������������������������������������������119 Utilities ������������������������������������������������������������������������������������������������������������������������������������������������120 TimeUnit and ChronoUnit ��������������������������������������������������������������������������������������������������������������������120 Queues �������������������������������������������������������������������������������������������������������������������������121 Atomic Classes �������������������������������������������������������������������������������������������������������������122 Thread�onSpinWait �������������������������������������������������������������������������������������������������������123 Summary ����������������������������������������������������������������������������������������������������������������������124 ■ Chapter 11: Nashorn ������������������������������������������������������������������������������������������125 Getting the Nashorn Engine �����������������������������������������������������������������������������������������125 ECMAScript 6 Features �������������������������������������������������������������������������������������������������126 Template Strings ���������������������������������������������������������������������������������������������������������������������������������126 Binary and Octal Literals ��������������������������������������������������������������������������������������������������������������������126 Iterators and for��of Loops �������������������������������������������������������������������������������������������������������������������126 Functions ��������������������������������������������������������������������������������������������������������������������������������������������127 Parser API ���������������������������������������������������������������������������������������������������������������������128 Basic Parsing ��������������������������������������������������������������������������������������������������������������������������������������128 Parsing Error ���������������������������������������������������������������������������������������������������������������������������������������129 Analyzing Function Complexity ������������������������������������������������������������������������������������130 Summary ����������������������������������������������������������������������������������������������������������������������131 ■ Chapter 12: I/O ��������������������������������������������������������������������������������������������������133 InputStream ������������������������������������������������������������������������������������������������������������������133 The ObjectInputStream Filter ���������������������������������������������������������������������������������������134 Summary ����������������������������������������������������������������������������������������������������������������������137 ■ Chapter 13: Security ������������������������������������������������������������������������������������������139 SHA-3 Hash Algorithms ������������������������������������������������������������������������������������������������139 SecureRandom �������������������������������������������������������������������������������������������������������������139 Using PKCS12 as the Default Keystore �������������������������������������������������������������������������141 Summary ����������������������������������������������������������������������������������������������������������������������141 ■ Chapter 14: User Interface ��������������������������������������������������������������������������������143 Desktop ������������������������������������������������������������������������������������������������������������������������143 Application Events ������������������������������������������������������������������������������������������������������������������������������143 About Window �������������������������������������������������������������������������������������������������������������������������������������144 Preferences Window ���������������������������������������������������������������������������������������������������������������������������144 Open Files �������������������������������������������������������������������������������������������������������������������������������������������145 Print Files ��������������������������������������������������������������������������������������������������������������������������������������������146 Open URI ���������������������������������������������������������������������������������������������������������������������������������������������146 Application Exit �����������������������������������������������������������������������������������������������������������������������������������146 Other Functionalities ��������������������������������������������������������������������������������������������������������������������������148 Multiresolution Images �������������������������������������������������������������������������������������������������148 TIFF Image Format �������������������������������������������������������������������������������������������������������150 Deprecating the Applet API �������������������������������������������������������������������������������������������150 Summary ����������������������������������������������������������������������������������������������������������������������150 ■ Chapter 15: JVM ������������������������������������������������������������������������������������������������151 Unified Logging ������������������������������������������������������������������������������������������������������������151 Tags, Levels, Decorations, and Output ������������������������������������������������������������������������������������������������151 Logging Configuration ������������������������������������������������������������������������������������������������������������������������152 The Diagnostic Command VM�log �������������������������������������������������������������������������������������������������������153 Remove GC Combinations ��������������������������������������������������������������������������������������������154 Making G1 the Default Garbage Collector ��������������������������������������������������������������������154 Deprecating the Concurrent Mark Sweep (CMS) Garbage Collector ����������������������������154 Removing Launch-Time JRE Version Selection ������������������������������������������������������������154 More Diagnostic Commands ����������������������������������������������������������������������������������������155 Removal of the JVM TI hprof Agent ������������������������������������������������������������������������������157 Removal of the jhat Tool ���������������������������������������������������������������������������������������������������������������������157 Removal of Demos and Samples ��������������������������������������������������������������������������������������������������������157 Javadoc ������������������������������������������������������������������������������������������������������������������������157 Summary ����������������������������������������������������������������������������������������������������������������������159 ■ Chapter 16: Miscellaneous ��������������������������������������������������������������������������������161 Small Language Changes ���������������������������������������������������������������������������������������������161 Private Interface Methods ������������������������������������������������������������������������������������������������������������������161 Resource References in try-with-resources ���������������������������������������������������������������������������������������161 Other Changes ������������������������������������������������������������������������������������������������������������������������������������162 The Stack-Walking API �������������������������������������������������������������������������������������������������162 Objects �������������������������������������������������������������������������������������������������������������������������164 Unicode 8�0 ������������������������������������������������������������������������������������������������������������������165 UTF-8 Property Resource Bundles �������������������������������������������������������������������������������166 Enhanced Deprecation �������������������������������������������������������������������������������������������������166 NetworkInterface ����������������������������������������������������������������������������������������������������������167 Summary ����������������������������������������������������������������������������������������������������������������������168 Index ���������������������������������������������������������������������������������������������������������������������169

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.