Java/Java SE 6: What's New, Release History & Support Lifecycle

What Is New in Java 6

What scripting support was added?

Java SE 6 integrated scripting languages directly into the platform through JSR 223. This lets you call engines like JavaScript (Mozilla Rhino), Ruby, or Groovy from your Java code. You use the ScriptEngineManager to get a ScriptEngine instance and execute scripts.

In practice, this was huge for embedding configuration logic or rules engines without building a custom interpreter. You could pass Java objects into the script context and get results back, making the JVM a true polyglot environment.

ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
Object result = engine.eval("function greet() { return 'Hello, World!'; }; greet();");

How did web services get better?

The platform gained first-class support for publishing and consuming web services. You could annotate a plain Java class with @WebService and use the new Endpoint.publish() method to expose it as a SOAP service instantly.

On the client side, the new javax.xml.ws.Service API provided a much cleaner way to consume services compared to the older, more cumbersome approaches. This matters because it finally made web services feel like a native part of Java SE, not just an EE add-on.

What changed in JDBC 4.0?

JDBC 4.0 was a major quality-of-life update for database work. The biggest win was automatic driver loading - you no longer needed to call Class.forName() to register the driver. Just drop the JAR and the DriverManager finds it.

It also added support for SQLXML data type and better exception handling with chained exceptions. For developers, this meant less boilerplate code and more robust database applications.

How was monitoring improved?

JConsole became a fully supported, out-of-the-box monitoring tool. It could attach to any local or remote Java 6 JVM to visualize memory usage, thread states, and JMX bean attributes in real-time.

This was a game-changer for troubleshooting production issues. Instead of guessing why an app was slow, you could fire up JConsole and see exactly which locks were causing thread contention or how heap memory was behaving.

What is pluggable annotation processing?

This feature, defined by JSR 269, allowed compiler-independent processing of annotations. You could write annotation processors that ran during the compilation phase to generate code, validate constraints, or create metadata files.

In practice, this is what enabled modern libraries like Lombok and MapStruct to work their magic. It opened the door for powerful metaprogramming techniques directly within the standard javac compiler.