Introduction
Welcome to our deep dive into the powerful enhancements and tools introduced in JDK versions 17 through 21. The evolution of the Java Development Kit (JDK) continues to provide developers with a robust and efficient environment for building and maintaining Java applications. From new capabilities in the javac compiler to improvements in garbage collection, these updates significantly enhance performance, security, and usability.
Enhanced Development Tools in JDK 17+
JDK 17 and beyond have introduced several significant updates to the tools that Java developers use daily. Let’s explore these enhancements in detail.
javac Compiler Enhancements
The javac compiler, a cornerstone of Java development, has seen substantial improvements post-JDK 17. In JDK 18, the serial lint warning was enhanced to ensure that a properly declared serialVersionUID field is present in serializable classes. This improvement helps maintain compatibility and avoid serialization issues.
Example: Enhanced serial lint warning
javaCopy codeimport java.io.Serializable;
public class MyClass implements Serializable {
private static final long serialVersionUID = 1L;
private void writeObject(java.io.ObjectOutputStream out) throws IOException {
// custom serialization logic
}
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
// custom deserialization logic
}
}
Additionally, JDK 20 introduced a warning for potential lossy conversions in compound assignments involving different data types, helping developers catch and correct subtle bugs in their code.
Example: Lossy conversion warning
javaCopy codepublic class TypeConversion {
public static void main(String[] args) {
long l = 10L;
double d = 2.5;
// Warning: potential lossy conversion
l += d;
}
}
javadoc Improvements
Documentation is a critical part of software development, and the javadoc tool has been significantly enhanced. The introduction of the {@snippet ...} tag in JDK 18 simplifies the inclusion of example source code in API documentation. This tag offers better control over indentation and allows for the use of regions to display targeted code examples more effectively.
Example: Using the {@snippet} tag
javaC code/**
* This method adds two numbers.
*
* {@snippet :
* public int add(int a, int b) {
* return a + b;
* }
* }
*/
public int add(int a, int b) {
return a + b;
}
Moreover, the --add-script option enables the inclusion of interactive scripts in the generated documentation, enhancing its usability and interactivity.
jshell for Interactive Coding
Introduced in JDK 9, jshell allows for quick experimentation with Java code. JDK 19 added the ability to highlight deprecated elements, helping developers avoid using outdated features.
Example: Using jshell
shellCopy codejshell> int x = 5;
x ==> 5
jshell> int y = 10;
y ==> 10
jshell> int sum = x + y;
sum ==> 15
jwebserver for Lightweight Web Development
JDK 18 introduced jwebserver, a minimal HTTP static file server perfect for web development testing, application testing, and informal file sharing. Its simplicity and ease of setup make it an invaluable tool for developers.
Example: Starting jwebserver
shellCopy code$ jwebserver
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...
jpackage for Application Packaging
jpackage, available since JDK 14, is a command-line tool for creating native installers and packages for Java applications. JDK 19 enhanced jpackage to support user-specific startup parameters, making it more flexible and user-friendly.
Example: Creating a package with jpackage
shellCopy code$ jpackage --input input-dir --name MyApp --main-jar myapp.jar --type dmg
jmod for Modular Development
The jmod tool facilitates the creation of module files that encapsulate compiled Java classes, resources, and other related files. JDK 21 introduced a --compress option for jmod, allowing developers to specify compression levels and optimize module file sizes.
Example: Creating a JMOD file
shellCopy code$ jmod create --class-path classes --module-version 1.0 --compress zip-9 mymodule.jmod
Security Enhancements
Security is paramount in software development, and JDK 21 brings several critical updates to its security tools.
keytool Enhancements
keytool now warns users when using weak or disabled encryption algorithms, helping to maintain strong security practices. JDK 21 also updated the -genseckey and -importpass commands to issue warnings for weak password-based encryption algorithms.
Example: Generating a secret key with keytool
shellCopy code$ keytool -genseckey -keyalg AES -keysize 256 -keystore mykeystore.jks -storepass changeit
jarsigner Improvements
jarsigner has been enhanced to more accurately detect and warn about the use of disabled or weak algorithms in signed JAR files, ensuring that applications remain secure and compliant with modern cryptographic standards.
Example: Signing a JAR file with jarsigner
shellCopy code$ jarsigner -keystore mykeystore.jks -signedjar signedMyApp.jar myApp.jar myalias
Monitoring and Performance Tools
Effective monitoring and performance tuning are crucial for high-performing applications. JDK 21 introduces notable enhancements to JDK Flight Recorder (JFR) and JDK Mission Control (JMC).
JDK Flight Recorder (JFR)
JDK 21 introduces the jfr view command, which displays aggregated event data directly in the shell. This allows developers to analyze application performance without the need to dump recording files or open JMC.
Example: Using jfr view command
shellCopy code$ jfr start --name myRecording
$ jfr view --name myRecording
JDK Mission Control (JMC)
JMC has been updated to support Apple M1 machines and now includes advanced stack trace graph views such as Flame, Heat map, and Dependency. These visualizations help developers identify performance bottlenecks and optimize their code more effectively.
Example: Starting JDK Mission Control
shellCopy code$ jmc
JVM and Garbage Collection Improvements
Garbage collection (GC) is a critical aspect of Java application performance. JDK 21 brings several improvements to the JVM and its garbage collectors.
Generational Z Garbage Collector (ZGC)
One of the most significant updates in JDK 21 is the introduction of a generational mode for the Z Garbage Collector (ZGC). This enhancement improves the efficiency of memory management by separating the heap into young and old generations. Generational ZGC is particularly beneficial for applications with high allocation rates and long-lived objects.
Example: Enabling Generational ZGC
shellCopy code$ java -XX:+UseZGC -XX:+ZGenerational
G1 Garbage Collector Updates
The G1 garbage collector has received several updates, including support for larger region sizes and improved throughput calculations. These changes enhance G1’s performance, making it more suitable for applications with large memory footprints.
Example: Enabling G1GC with updated settings
shellCopy code$ java -XX:+UseG1GC -XX:G1HeapRegionSize=512M
Parallel and Serial Garbage Collectors
While the parallel and serial garbage collectors are mature and in maintenance mode, JDK 21 introduces string deduplication to these collectors, improving memory efficiency by reducing duplicate string instances.
Example: Enabling string deduplication
shellCopy code$ java -XX:+UseStringDeduplication
References
Conclusion
The enhancements and tools introduced in JDK 17 through 21 significantly improve the Java development experience. From advanced compiler warnings and interactive documentation to enhanced security and garbage collection, these updates provide developers with the tools they need to build robust, efficient, and secure applications.
If you found this overview helpful, be sure to stay tuned for more in-depth articles on each of these topics on Nashtech Blogs. Happy coding!