Hardware and software I/O is advancing rapidly, and Java 7 is well-placed to take maximum advantage of the new capabilities with the new APIs introduced as part of NIO.2. The new libraries in Java 7 allow you to manipulate locations (Path) and perform operations on the filesystem, such as manipulating files, directories, symbolic links, and more. In particular, navigating through filesystems with full support for platform-specific behavior is now a breeze, and large directory structures can now be dealt with.
NIO.2 has been focused on giving you one-stop methods for performing tasks that would normally have taken large amounts of code to solve. In particular, the new Files utility class is full of helper methods that make writing file I/O code a good deal faster and simpler than the old java.io.File based I/O.
Asynchronous I/O is a powerful new feature for dealing with large files without drastically reducing performance. It’s also useful for applications that have heavy traffic on their network sockets and channels.
NIO.2 also eats Java 7’s own dog food, with features from Project Coin (chapter 1) retrofitted to it. This makes dealing with I/O much safer in Java 7 than previously, as well as allowing you to write less verbose code.
Now it’s time to step up a gear and challenge the brain muscles with a look at some advanced modern Java in part 2 of this book, including dependency injection, modern concurrency, and tuning a Java-based software system. We suggest you grab a coffee in your favorite Duke mug,[10] and jump in when you’re ready!
IoC can be a difficult concept to get your head around. But by exploring the concepts of Factory and Service Locator patterns, you can see how a basic IoC implementation works. The Factory pattern can be seen as an intermediate step toward understanding DI and the benefits it can bring your codebase. Even if you’re struggling with the DI paradigm, it’s worth sticking with it, because it enables you to write loosely coupled code that’s easy to test and clearer to read.
JSR-330 isn’t only an important standard that unifies common DI functionality, it also provides behind-the-scenes rules and limitations that you should be aware of. By studying the standard set of DI annotations, you can gain a much greater appreciation for how the various DI frameworks implement the specification, and therefore how you can use them most effectively.
Guice is the reference implementation for JSR-330 and it’s also a popular, lightweight way to start using DI in your code. Indeed, for many applications, using Guice and the JSR-330 compatible set of annotations is probably enough for most of your DI needs.
If you’ve been reading this book from the start, we think you deserve a break! Go and inject some nonreading activity into your day and come back refreshed for a topic that every well-grounded Java developer needs to master, that of concurrency.
Concurrency is one of the most important features of the Java platform, and a good developer will increasingly need a solid understanding of it. We’ve reviewed the underpinnings of Java’s concurrency and the design forces that occur in multithreaded systems. We’ve discussed the Java Memory Model and low-level details of how the platform implements concurrency.
More important to the modern Java developer, we’ve addressed the classes in java.util.concurrent, which should be your preferred toolkit for all new multithreaded Java code. We’ve updated you with details of some of the brand new classes in Java 7, such asLinkedTransferQueue and the fork/join framework.
We hope we’ve prepared the ground for you to begin using the classes of java.util.concurrent in your own code. This is the single most important takeaway from this chapter. Although we’ve looked at some great theory, the most important part is the practical examples. Even if you just start with ConcurrentHashMap and the Atomic classes, you’ll be using well-tested classes that can immediately provide real benefit to your code.
It’s time to move on to the next big topic that will help you stand out as a Java developer. In the next chapter, you’ll gain a firm grounding in another fundamental area of the platform—classloading and bytecode. This topic is at the heart of many of the platform’s security and performance features, and it underpins many of the advanced techniques in the ecosystem. This makes it an ideal subject of study for the developer who wishes to gain an edge.
In this chapter, we’ve taken a quick first look into bytecode and classloading. We’ve dissected the class file format and taken a brief tour through the runtime environment that the JVM provides. By learning more about the internals of the platform, you’ll become a better developer.
These are some of the things that we hope you’ve learned from this chapter:
The class file format and classloading are central to the operation of the JVM. They’re essential for any language that wants to run on the VM.
The various phases of classloading enable both security and performance features at runtime.
Method handles are a major new API with Java 7—an alternative to reflection.
JVM bytecode is organized into families with related functionality.
Java 7 introduces invokedynamic—a new way of calling methods.
It’s time to move on to the next big topic that will help you stand out as a well-grounded Java developer. By reading the next chapter, you’ll get a firm grounding in the often-misunderstood subject of performance analysis. You’ll learn how to measure and tune for performance and how to get the most out of some of the powerful technology at the heart of the JVM, such as the JIT compiler, which turns bytecode into super-fast machine code.
Performance tuning isn’t about staring at your code and praying for enlightenment, or applying canned quick fixes. Instead, it’s about meticulous measurement, attention to detail, and patience. It’s about persistent reduction of sources of error in your tests, so that the true sources of performance problems emerge.
Let’s look at some of the key points that you’ve learned about performance optimization in the dynamic environment provided by the JVM:
The JVM is an incredibly powerful and sophisticated runtime environment.
The JVM’s nature can make it sometimes challenging to optimize code within.
You have to measure to get an accurate idea of where the problems really are.
Pay particular attention to the garbage collection subsystem and the JIT compiler.
Monitoring and other tools can really help.
Learn to read the logs and other indicators of the platform—tools aren’t always available.
You must measure and set goals (this is so important we’re saying it twice).
You should now have the basic grounding needed to explore and experiment with the platform’s advanced performance features, and to understand how the performance mechanisms will affect your own code. Hopefully, you’ve also started to gain the confidence and experience to analyze all of this data with an open mind and to apply that insight to solving your own performance problems.
In the next chapter, we’ll start to look beyond the Java language to alternatives on the JVM, but many of the performance features of the platform will be very useful in the wider context—especially what you’ve learned about JIT compilation and GC.
Alternative languages on the JVM have come a long way. They can now offer better solutions than Java for certain problems while retaining compatibility with existing systems and investments made in Java technology. This means that even for Java shops, Java isn’t always the automatic choice for every programming task.
Understanding the different ways languages can be classified (static versus dynamic, imperative versus functional, and compiled versus interpreted) gives you the foundation for being able to pick the right language for the right task.
For the polyglot programmer, languages fall roughly into three programming layers: stable, dynamic, and domain-specific. Languages such as Java and Scala are best used for the stable layer of software development, whereas others, such as Groovy and Clojure, are more suited to tasks in the dynamic or domain-specific realms.
Certain programming challenges fit well into particular layers, such as rapid web development in the dynamic layer or modeling enterprise messaging in the domain-specific layer.
Groovy has several compelling features that make it a great language to use alongside Java. You can write syntax that’s very similar to that of Java, but you also have the choice of writing the same logical code in a more concise manner. Readability isn’t sacrificed with this conciseness, and Java developers will have no trouble in picking up the new shortened syntax related to collections, null reference handling, and GroovyBeans. There are a few traps awaiting the Java developer in Groovy, but you’ve now worked through most of the common cases, and you’ll hopefully be able to pass this newfound knowledge on to your colleagues.
发帖
雷达卡
[11 Ratings] Subscriber Reviews
京公网安备 11010802022788号
