The Well-Grounded. Java Developer. Vital techniques of Java 7 and Polyglot Programming BENJAMIN J. EVANS MARTIJN VERBURG MANNING.

Transcription

1 The Well-Grounded Java Developer Vital techniques of Java 7 and Polyglot Programming BENJAMIN J. EVANS MARTIJN VERBURG II MANNING Shelter Island

2 contents foreword xvii preface xix acknowledgments xxi about this book xxiv about the authors xxix about the cover illustration xxx Part 1 Developing with Java 7 1 Introducingjava The language and the platform Small is beautiful Project Coin The changes in Project Coin 9 Strings in switch 9 Enhanced syntaxfor numeric literals 10 Improved exception handling 12 Try-with-^esources (TWR) 13 Diamond syntax 16 Simplified varargs method invocation Summary 19 New I/O Java I/O a history 22 Java 1.0 to Java 1.4 andnio 23 Introducing NIO vii

3 2.2 Path a foundation of file-based I/O 24 Creating a Path 27 * Retrieving information from Removing redundancies 28 * ConvertingPaths 29 NIO. 2 Path and fava's existing File class Dealing with directories and directory trees 30 Findingfiles in a directory 30 * Walking the directory 2.4 Filesystem I/O with NIO.2 33 a Path 27 tree 31 Creating and deletingfiles 34 Copying and moving files 35 File attributes 36 * Reading and writing data quickly 40 File change notification 41 SeekableByteChannel Asynchronous I/O operations 43 Future style 44 * Callback style Tidying up Socket-Channel functionality 47 NetworkChannel 48 * MulticastChannel Summary 50 JP^AJE^JC 2 "\^FF.AL 'A.'JhjCIIISfl^^UES **a«««o*a*»««««a«««a*c**««e*««dependency Injection Inject some knowledge understanding IoC and DI 54 Inversion of Control 54 Dependency Injection 55 Transitioning to DI Standardized DI injava 61 annotation 62 * The Qualifier annotation 64 annotation 65 annotation 65 The Singleton annotation 66* TheProvider<T> interface Guice 3 the reference implementation for DI in Java 67 Getting started with Guice 68 * Sailor's knots the various bindings of Guice with Guice Summary 75 70* Scoping your injected objects Modern concurrency Concurrency theory a primer 77 ExplainingJava's threading model 77 Design concepts 79 How and why do the forces conflict? 80 Sources ofoverhead 81 A transaction processor example 81

4 4.2 Block-structured concurrency (pre-java 5) 83 Synchronization and locks 83 * The state model a for thread 84 Fully synchronized objects 85 * Deadlocks 86 Why synchronized! 88 * The volatile keyword 89 Immutability Building blocks for modern concurrent applications 91 Atomic classes -Java, util. concurrent, atomic 92 Locks -java.util.concurrent.locks 93 * CountDownLatch 96 ConcurrentHashMap 97 * CopyOnWriteArrayLisl 99 Queues Controlling execution 108 Modeling tasks 108 * ScheduledThreadPoolExecutor The fork/join framework 111 A simplefork/join example 112 * ForkJoinTask and work stealing 114 * Parallelizingproblems The Java Memory Model (JMM) Summary 118 Classfiles and bytecode Classloading and class objects 120 Overview loading and linking 120* Verification 121 Class objects 122 * Classloaders 122 Example classloaders in Dependency Injection Using method handles 125 * MethodHandle 126 MethodType 127 * Looking up method handles 127 * Example reflection vs. proxies vs. MethodHandles 128* Why choose MethodHandles? Examining class files 132 Introducingjavap 132 * Internal form for method signatures 132 * The constant pool Bytecode 136 Example disassembling a class 137 * The runtime environment 138 * Introduction to opcodes 140 Load and store opcodes 141 * Arithmetic opcodes 141 Execution control opcodes 142 * Invocation opcodes 143 Platform operation opcodes 143* Shortcut opcode forms 144 Example string concatenation 144

5 5.5 Invokedynamic 146 How invokedynamic works 146 Example disassembling an invokedynamic call Summary 149 Understanding performance tuning Performance terminology some basic definitions 152 Latency 152 * Throughput 152 * Utilization 153 Efficiency 153 Capacity 153 * Scalability 154 Degradation A pragmatic approach to performance analysis 154 Know what you're measuring 155 * Know how to take measurements 156* Know what your performance goals are 157 * Know when to stop optimizing 157 Know the cost ofhigherperformance 158 * danger ofpremature optimization 158 Know the 6.3 What went wrong? Why we have to care 159 Moore's Law historic and future performance trends 160 Understanding the memory latency hierarchy 161 Why is Java performance tuning hard? A question of time from the hardware up Garbage Hardware clocks 163 " The trouble with nanotime() 164 The rok of time in performance tuning understanding cache misses 167 collection * A case study Basics 170 * Mark and sweep 170 * jmap 172 UsefulJVM parameters 176 * Reading the GC logs 177 Visualizing memory usage with VisualVM 178 Escape analysis 181 * Concurrent Mark-Sweep 182 Gl Java's new collector JIT compilation with HotSpot 184 Introduction to HotSpot 186 * Inlining methods 187 Dynamic compilation and monomorphic calls 188 Reading the compilation logs Summary 190

6 xi Part 3 Polyglot programming on the JVM 191 Alternative JVM languages Java too clumsy? Them's fighting words! 194 The reconciliation system 194* Conceptual basics of functional programming 196* Map and filter idioms Language zoology 198 Interpreted vs. compiled languages 199 * Dynamic vs. static typing 199 * Imperative vs. functional languages 200 Reimplementation vs. original Polyglot programming on the JVM 202 Why use a non-java language? 203 Up-and-coming languages How to choose a nonjava language for your project 205 Is the project area low-risk? 205 * Does the language intemperate well withjava? 206 Is there good tooling and test supportfor the language? 207 * How hard is the language to learn? 207 Are there lots of developers using this language? How the JVM supports alternative languages 208 Runtime environments for non-java languages 209 Compiler fictions Summary 211 Groovy:Java's dynamicfriend Getting started with Groovy 215 Compiling and running 216* Groovy console Groovy 101 syntax and semantics 217 Default imports 219 * Numeric handling 219 Variables, dynamic versus static types, and scoping 220 Syntax for lists and maps Differences from Java traps for new players 223 Optional semicolons and return statements 224 Optional parentheses for method parameters 224 Access modifiers 225 * Exception handling 225 Equality in Groovy 225 * Inner classes Groovy features not (yet) in Java 226 GroovyBeans 227 * The safe-dereference operator 228 The Elvis operator 228 * Enhanced strings 229

7 Function literals 230 First-class supportfor manipulating collections 231 First-class support for regular expressions 233 Simple XML handling Interoperating between Groovy andjava 236 CallingJava from Groovy 236 Calling Groovy fromjava Summary 240 Scala: powerful and concise A quick tour of Scala 242 Scala as a concise language 243 " Match expressions 245 Case classes 247 Actors Is Scala right for my project? 249 Comparing Scala and Java 250 When and how to start using Scala 250 Signs that Scala may not be rightfor your current project Making code beautiful again with Scala 251 Using the compiler and the REPL 252 * Type inference 252 Methods 254 * Imports 255 * Loops and control structures 256 Functionalprogramming m in Scala Scala's object model similar but different 258 Everything is an object 258 * Constructors 259 Traits 260 Singleton and companion objects 262 Case classes and match expressions 264 A cautionary tale Data structures and collections 267 List 268 Map 271 Generic types Introduction to actors 275 All the code's a stage 276 Communicating with actors via the mailbox Summary 278 Clojure: safer programming Introducing Clojure 280 Hello World in Clojure 281 * Getting started with the REPL Making a mistake 282 Learning to love the brackets Looking for Clojure syntax and semantics 284 Specialforms bootcamp 284 * Lists, vectors, maps, Arithmetic, equality, and other operations 287 and sets 285

8 10.3 Working with functions and loops in Clojure 288 Some simple Clojurefunctions 289 Loops in Clojure 291 Reader macros and dispatch 292 Functional programming and closures Introducing Clojure sequences 295 Lazy sequences 297 Sequences and variable-arity functions Interoperating between Clojure and Java 299 CallingJava from Clojure 299 " TheJava type of Clojure values 300 * Using Clojure proxies 301 Exploratory programming with the REPL 302 Using Clojure fromjava Concurrent Clojure 303 Futures and pcalls 304 * Refs 306 * Agents Summary 310 Part 4 Crafting the polyglot project, 11 Test-driven development TDD in a nutshell 315 A TDD example with a single use case 316 * A TDD example with multiple use cases 320 * Further on thinking the red-green-refactor lifecycle 322 JUnit Test doubles 325 Dummy object 326 * Stub object 328 Fake object 331 Mock object Introducing 11.4 Summary 340 ScalaTest Build and continuous integration Getting started with Maven Maven 3 a quick-start project Maven 3 the Java7developer build 348 The POM 348 * Running the examples Jenkins serving your CI needs 357 Basic configuration 359 * Setting up a job 360 Executing a job 364

9 12.5 Code metrics with Maven and Jenkins 365 InstallingJenkins plugins 366 " Making code consistent with Checkstyle 367 Setting the quality barwithfindbugs Leiningen 372 Getting started with Leiningen 372 Leiningen's architecture 373 " Example Hello Lein 373 REPL-oriented TDD with Leiningen 376 Packaging and deploying with Leiningen Summary 379 Rapid web development The problem with Java-based web frameworks 381 WhyJava compilation is bad for rapid web development 382 Why static typing is bad for rapid web development Criteria in selecting a web framework Getting started with Grails Grails quick-start project 386 Domain object creation 387 * Test-driven development 388 Domain object persistence 390 * Test data creation 391 Controllers GSP/JSP views 393 Scaffolding and automatic UI creation 395 Rapid turnaround development Further Grails exploration 396 Logging 396 * GORM object-relational mapping 397 Grails plugins Getting started with Compojure 399 Hello World with Compojure 399 Ring and routes 401 Hiccup A sample Compojure project "Am I an Otter or Not?" 403 Setting up "Am I an Otter" 404 * Corefunctions in "Am I an Otter" Summary 409 Staying well-grounded What to expect in Java Lambdas (a.k.a. closures) 411 Modularization (a.k.a. Jigsaw) 413

10 xv 14.2 Polyglot programming 414 Language interoperability and metaobject protocols 415 Multilanguage modularity Future concurrency trends 416 The many-core world 417 * Runtime-managed concurrency New directions in the JVM 418 VM convergence 418* Coroutines 419* Tuples Summary 423 appendix A Java1/7developer source code installation 424 appendix B Glob pattern syntax and examples 432 appendix C Installing alternativejvm languages 434 appendix D Downloading and installingjenkins 441 appendix E Java7developer themavenpom 444 index 450