<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Simon Ritter on Medium]]></title>
        <description><![CDATA[Stories by Simon Ritter on Medium]]></description>
        <link>https://medium.com/@speakjava?source=rss-ff649d6e025a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*LNlfVRacCLYOxsy8</url>
            <title>Stories by Simon Ritter on Medium</title>
            <link>https://medium.com/@speakjava?source=rss-ff649d6e025a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 04:09:12 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@speakjava/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[JDK 11: Pitfalls for the Unwary]]></title>
            <link>https://medium.com/@speakjava/jdk-11-pitfalls-for-the-unwary-e08d864065c1?source=rss-ff649d6e025a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e08d864065c1</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[jdk]]></category>
            <category><![CDATA[jdk-11]]></category>
            <dc:creator><![CDATA[Simon Ritter]]></dc:creator>
            <pubDate>Mon, 10 Dec 2018 14:49:33 GMT</pubDate>
            <atom:updated>2018-12-10T14:49:33.842Z</atom:updated>
            <content:encoded><![CDATA[<p>I’m sure everyone now knows that the pace of change of the JDK has changed dramatically over the last year; we now have <a href="https://mreinhold.org/blog/forward-faster">two major releases every year</a>. One of the other substantial changes made to Java at the time JDK 9 was released was a different approach to compatibility. In the past, backward compatibility has been of paramount importance when delivering a new JDK. There’s nothing worse than taking tested, working code and having to modify and re-test the code just to get it working on a new version of the platform.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/944/1*Sx2X-lB7T-8u5cPhXdGrrQ.jpeg" /></figure><p>In the case of the JDK, this change was necessary because it was time to do some long overdue housekeeping and remove features that are of little or no use anymore. In addition, deprecation has been in the JDK right since JDK 1.1, but until JDK 9, no API elements had ever been removed, which rather defeated the whole purpose of having it.</p><p>The good news is that most applications will not be affected by these incompatibilities because, by definition, few applications are likely to be using these outdated features.</p><p>In previous blog posts, I’ve written about the changes in <a href="https://www.azul.com/jdk-9-pitfalls-for-the-unwary/">JDK 9</a> and <a href="https://www.azul.com/jdk-10-pitfalls-for-the-unwary/">JDK 10</a> that may affect migrating applications to these versions of Java. With <a href="https://openjdk.java.net/projects/jdk/11/">JDK 11</a>, a long-term support release, now having been out for a few weeks I figured it was time to catch up and list out things you should consider when migrating your applications.</p><p>Let’s break this down into the various areas of the JDK.</p><p>We can skip the Java language syntax, as there are no changes to this that will provide any issues (in fact, the only change at all is the very minor inclusion of the ability to use <a href="https://openjdk.java.net/jeps/323"><em>var</em> with Lambda expression parameters</a>).</p><h3>Core Libraries</h3><p>The biggest change in JDK 11 for libraries is the complete removal of the java.se.ee aggregator module. This includes the following modules:</p><ul><li><a href="https://docs.oracle.com/javase/10/docs/api/java.corba-summary.html"><strong>java.corba</strong></a>: <a href="https://en.wikipedia.org/wiki/Common_Object_Request_Broker_Architecture">Common Object Request Broker Architecture</a>. A very complicated (at least, in my opinion) way of developing distributed systems on heterogeneous platforms. Originally developed in the early 1990s, almost nobody I’ve spoken to uses this anymore, so it is unlikely to be missed.</li><li><a href="https://docs.oracle.com/javase/10/docs/api/java.transaction-summary.html"><strong>java.transaction</strong></a>: A subset of the Java Transaction API that is only provided to support CORBA. This only includes three exception types.</li><li><a href="https://docs.oracle.com/javase/10/docs/api/java.activation-summary.html"><strong>java.activation</strong></a>: The <a href="https://en.wikipedia.org/wiki/JavaBeans_Activation_Framework">Java Beans Activation Framework</a> (JAF). This is a way for developers to determine the type of an arbitrary piece of data, encapsulate access to it, discover the operations available on the piece of data and instantiate the appropriate bean to perform the operations. Again, this appears to be a very little used feature.</li><li><a href="https://docs.oracle.com/javase/10/docs/api/java.xml.bind-summary.html"><strong>java.xml.bind</strong></a>: Implementation of the <a href="https://en.wikipedia.org/wiki/Java_Architecture_for_XML_Binding">Java API for XML Binding (JAXB)</a>. This is an API that may cause more problems for migration than the previous ones, as I’ve met a number of developers who still use JAXB.</li><li><a href="https://docs.oracle.com/javase/10/docs/api/java.xml.ws-summary.html"><strong>java.xml.ws</strong></a>: <a href="https://en.wikipedia.org/wiki/Java_API_for_XML_Web_Services">Java API for XML-based Web Services (JAX-WS)</a>. Although pretty much everyone now uses <a href="https://en.wikipedia.org/wiki/Representational_state_transfer">RESTful web services</a>, there are still a lot of people who have code developed using <a href="https://en.wikipedia.org/wiki/SOAP">SOAP-based web services</a> that require JAX-WS support to work. This is also set of APIs whose removal may catch a number of applications.</li><li><a href="https://docs.oracle.com/javase/10/docs/api/java.xml.ws.annotation-summary.html"><strong>java.xml.ws.annotation</strong></a>: A subset of the common annotations API required for JAX-WS. Again, this is a very small module with only one enumeration and five annotations.</li></ul><p>The good news is that, with the exception of CORBA support, all these modules have freely available versions, either as a reference implementation of the relevant standard or through Maven Central.</p><p>Here’s a list of other API elements that have been removed in JDK 11.</p><ul><li><strong>javax.security.auth.Policy</strong>: This class has been deprecated since JDK 1.4 and there is a direct replacement in the form of java.security.Policy. I think the likelihood of this affecting any applications is pretty small.</li><li><strong>java.lang.Runtime.runFinalizersOnExit</strong>: <br> <strong>java.lang.System.runFinalizersOnExit</strong><br> Both these methods were deprecated for removal all the way back in JDK 1.2 and are classified as inherently unsafe. There is no direct replacement.</li><li><strong>java.lang.SecurityManager.checkAwtEventQueueAccess</strong>: Only recently deprecated in JDK 8, this method should be replaced by java.security.Permission.checkPermission with the AWTPermission(“accessEventQueue”) permission as a parameter. Since both methods throw a SecurityException if the permission is not accessible, this will require only a minor change.</li><li><strong>java.lang.SecurityManager.checkMemberAccess</strong>: Replace with java.security.Permission.checkPermission (as above) with RuntimePermission(“accessDeclaredMembers”).</li><li><strong>java.lang.SecurityManager.checkSystemClipboardAccess</strong>: Replace with java.security.Permission.checkPermission with AWTPermission(“accessClipboard”).</li><li><strong>java.lang.SecurityManager.checkTopLevelWindow</strong>: Replace with java.security.Permission.checkPermission with AWTPermission(“showWindowWithoutWarningBanner”).</li><li><strong>java.lang.Thread.destroy</strong>: Deprecated back in JDK 5.0, this method was, intriguingly, never implemented. If you’d used it all you would have got was a NoSuchMethodException.</li><li><strong>java.lang.Thread.stop(java.lang.Throwable)</strong>: This was deprecated all the way back in JDK 1.2. Note that there are two, overloaded versions of this method. This is the one that takes a Throwable as a parameter. The no-argument version is still available (although it is also deprecated and considered inherently unsafe).</li></ul><h3>JDK Changes</h3><p>JDK 11 contains some significant changes because of the <a href="https://blogs.oracle.com/java-platform-group/oracle-jdk-releases-for-java-11-and-later">convergence of the Oracle JDK binary functionality with that of the OpenJDK</a>. To achieve this, Oracle has removed the following major features from the Oracle JDK (which is most likely the one most people have been using up until now).</p><ul><li><strong>The Browser Plugin</strong>: This is essentially the end of Applets in Java. Although the Applet API remains in the java.desktop module, all of it is deprecated and I would expect to see this removed very soon. In addition to the plugin, the appletviewer tool has also been removed.<br> <br> If you are still using applets (there are a few die-hards out there), there is no migration path past JDK 8. If you want to continue getting security patches and bug fixes, you have no choice but to pay for an Oracle Java SE subscription. The browser plugin has not been released as open-source.</li><li><strong>Java Web Start</strong>: This was a somewhat popular choice for delivering desktop Java applications over a decade ago but, with the majority of front-end applications using a browser and HTML5/CSS/Javascript it is only used by legacy applications.<br> <br> As part of the removal of this feature, the javaws command has been removed. The jcontrol (Java Control Panel) has also been removed that was used to configure both Web Start and the browser plugin.<br> <br> As with the browser plugin, Java Web Start has not been released as open-source and there is no simple alternative to this. There are a couple of projects that had the goal of replicating this functionality, but none of them have been touched in years. Other alternatives like <a href="https://github.com/threerings/getdown">getdown</a> and <a href="https://www.ej-technologies.com/products/install4j/overview.html">install4j</a> could be used but will require work and may not provide all the features required.<br> <br> Again, there is no migration path for this beyond JDK 8 with the same implications as for the browser plugin regarding updates.</li><li><a href="https://en.wikipedia.org/wiki/JavaFX"><strong>JavaFX</strong></a>: This was never a part of the Java SE standard and, despite being an <a href="https://wiki.openjdk.java.net/display/OpenJFX/Main">open-source project (OpenJFX)</a> under the OpenJDK umbrella, is not part of the OpenJDK source for the JDK. Personally, I’m a big fan of JavaFX and have written a number of applications using this. There is also a small, but dedicated, group of users who build very impressive complex front-end applications for things like financial trading and scientific applications.<br> <br>The good news is that being a separate project, it is relatively straightforward to build binaries that can be added to a current JDK. Azul has recently released builds of the Zulu JDK that include JavaFX.<br> <br>In addition to the removal of the JavaFX modules, the javapackager (previously referred to as javafxpackager) command has been removed. JEP 343 has been proposed to provide a replacement packaging tool that is not tied to JavaFX.</li><li><strong>Removal of the java.se.ee aggregator module</strong>: In addition to removing the modules discussed earlier, a number of related tools have also been removed from the JDK:</li><li><strong>idlj </strong>(CORBA related)</li><li><strong>orbd </strong>(CORBA related)</li><li><strong>servertool</strong> (CORBA related)</li><li><strong>tnamesrv</strong> (CORBA related)</li><li><strong>schemagen </strong>(JAX-WS related)</li><li><strong>wsgen </strong>(JAX-WS related)</li><li><strong>wsimport </strong>(JAX-WS related)</li><li><strong>xjc </strong>(JAX-WS related)</li><li><strong>Java Mission Control</strong>: The jmc command was included as a commercial feature in the Oracle JDK prior to JDK 11. This has now been contributed by Oracle to the OpenJDK project and is available as a standalone package.</li></ul><h3>JVM Changes</h3><p>There have been a lot of changes recently to the -XX command line flags available to configure the JVM. Below is a list of the flags that have been removed.</p><ul><li>AttachListenerTimeout</li><li>CheckAssertionStatusDirectives</li><li>CheckEndorsedAndExtDirs</li><li>DeferPollingPageLoopCount</li><li>DeferThrSuspendLoopCount</li><li>EnableTracing</li><li>FastTLABRefill</li><li>G1RSBarrierRegionFilter</li><li>G1ScrubRemSets</li><li>G1SecondaryFreeListAppendLength</li><li>G1StressConcRegionFreeing</li><li>G1StressConcRegionFreeingDelayMillis</li><li>InlineNotify</li><li>MustCallLoadClassInternal</li><li>NativeMonitorFlags</li><li>NativeMonitorSpinLimit</li><li>NativeMonitorTimeout</li><li>PrintMalloc</li><li>PrintMallocFree</li><li>SafepointSpinBeforeYield</li><li>ShowSafepointMsgs</li><li>TraceScavenge</li><li>UnsyncloadClass</li><li>UseAppCDS</li><li>UseCGroupMemoryLimitForHeap</li><li>UseLockedTracing</li><li>UseUTCFileTimestamp</li></ul><p>If you’re using any of these flags, you’ll need to look at alternative ways of doing the same thing. The two flags that I notice are:</p><ul><li><em>UseAppCDS</em>, which was a commercial feature and is now part of OpenJDK.</li><li><em>UseCGroupMemoryLimitForHeap</em> The JVM is now properly CGroup aware so this is no longer required.</li></ul><h3>Summary</h3><p>The reality is that most applications will move from JDK 10 to JDK 11 without issue. The only tricky bits will be if you’ve used anything fromjava.se.ee or older deployment technologies like applets or Java Web Start.</p><p>Remember, though, if you’re planning to migrate from JDK 8 to JDK 11 there are a few other changes that you’ll need to consider.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e08d864065c1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Using jlink to Build Java Runtimes for non-Modular Applications]]></title>
            <link>https://medium.com/azulsystems/using-jlink-to-build-java-runtimes-for-non-modular-applications-9568c5e70ef4?source=rss-ff649d6e025a------2</link>
            <guid isPermaLink="false">https://medium.com/p/9568c5e70ef4</guid>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Simon Ritter]]></dc:creator>
            <pubDate>Wed, 10 Oct 2018 10:55:40 GMT</pubDate>
            <atom:updated>2018-12-20T13:36:16.100Z</atom:updated>
            <content:encoded><![CDATA[<p>The most important new feature of <a href="http://openjdk.java.net/projects/jdk9/">JDK 9</a> was the <a href="https://jcp.org/en/jsr/detail?id=376">Java Platform Module System (JPMS)</a> that divided the monolithic rt.jar and tools.jar files into 75 distinct modules (at least in the <a href="http://openjdk.java.net/">OpenJDK</a>, the <a href="https://www.oracle.com/technetwork/java/javase/downloads/java-archive-javase9-3934878.html">Oracle JDK</a> contained a few more).</p><p>JDK 9 also eliminated the distinction between the Java Development Kit (JDK) and the Java Runtime Environment (JRE). In the past, there was a sub-directory in the JDK (unsurprisingly called jre) which only contained things that were required to run a Java application. On Linux, the full JDK 8 was 364 Mb, the JRE just 197 Mb. Users who were concerned about disk space could install the JRE and happily run their applications.</p><p>In JDK 9 and later, the idea is to build Java runtimes that are tailored to the requirements of a specific application. Rather than including all 75 modules, you need only include the <a href="https://docs.oracle.com/javase/9/docs/api/java.base-summary.html">java.base</a> module (which all runtimes must include by definition) as well as any other modules the application references. All transitive module dependencies must also be included. JDK 9 and later provides the <a href="https://docs.oracle.com/javase/9/tools/jlink.htm#JSWOR-GUID-CECAC52B-CFEE-46CB-8166-F17A8E9280E9">jlink</a> command to assemble and optimize a set of modules and their dependencies into a custom runtime image.</p><p>Many people, when moving an application from JDK 8 or earlier to JDK 11, do not want to have to take on the additional work of migrating application code to use modules. Fortunately, application code and external libraries can all be left on the classpath and treated as part of the unnamed module. For simple applications, you can use the same command to start the application as before.</p><p>However, the assumption is that, because jlink only works with modules that it can’t be used to generate a runtime image for non-module based applications.</p><p>This article will take you through the steps necessary to build significantly smaller Java runtimes for applications that have not been converted to use modules. In addition, since <a href="https://en.wikipedia.org/wiki/JavaFX">JavaFX</a> has been removed from the Oracle JDK (and was never part of OpenJDK binaries), we’ll include that in our application to demonstrate another part of using this tool.</p><p>The application we’ll be using is a simple data-entry application that presents a form to the user and then stores the fields into a MySQL database. How the application works is immaterial to this post so I won’t bother sharing the code.</p><p>The application was built using <a href="https://netbeans.org/">NetBeans</a>, which generates a <em>dist</em> directory that contains all the compiled code required to run the application. Since the application uses some libraries the layout looks like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pUDE9y25LrOkz1Hi7fwGsw.jpeg" /></figure><h3>Using JavaFX with JDK 11</h3><p>To run the application on JDK 8, all that was required was</p><pre>java -jar FlightRecorder.jar</pre><p>If we run this application with JDK 9, we need to make no changes.</p><p>However, if we try this with JDK 11, we get the following error message:</p><pre>Error: Could not find or load main class flightrecorder.Main<br>Caused by: java.lang.NoClassDefFoundError: javafx/application/Application</pre><p>As I mentioned earlier, this is because neither the Oracle JDK nor OpenJDK binaries include JavaFX. Luckily, the nice people at <a href="https://gluonhq.com/products/javafx/">Gluon</a> provide free builds of the <a href="https://wiki.openjdk.java.net/display/OpenJFX/Main">OpenJFX</a> project, so it’s easy to resolve this issue.</p><p>To start, we need to download the <a href="https://gluonhq.com/products/javafx/">JavaFX SDK</a> and unzip it into a directory on our machine. For simplicity, we’ll put it in /opt. Next, we need a couple of extra command line flags:</p><pre>java --module-path /opt/javafx-sdk-11/lib --add-modules=javafx.controls -jar FlightRecorder.jar</pre><p>The two extra flags are:</p><ol><li>--module-path: Equivalent of the classpath, telling the JVM where to search for modules.</li><li>--add-modules: This specifies additional root modules to resolve. Because all the application code is on the classpath, we don’t have an initial module, so this option is required. We can specify this in two ways, either with an explicit list of modules as above, or we could indicate that everything on the module path is to be included by using the parameter ALL-MODULE-PATH.</li></ol><p>We now have an application that runs on JDK 11 using external JavaFX modules but with all application code still on the classpath.</p><h3>Building a Java Runtime</h3><p>In order to use jlink in this situation, we need to generate a list of the JDK modules that the application uses. To do this, we can use the <a href="https://docs.oracle.com/javase/9/tools/jdeps.htm#JSWOR690">jdeps</a> command that also comes with the JDK.</p><p>Interestingly, if we use the JDK 9 version of jdeps on the application we get this result:</p><pre>&gt; jdeps --list-deps FlightRecorder.jar<br>java.base<br>java.logging<br>java.sql<br>javafx.base<br>javafx.controls<br>javafx.graphics<br>not found<br>unnamed module: FlightRecorder.jar</pre><p>Most of this is fine but the ‘<em>not found</em>’ message is confusing and not very useful (what was not found?) Thankfully, jdeps was improved in JDK 10 so if we use the JDK 11 version we get the following:</p><pre>&gt; jdeps --list-deps FlightRecorder.jar<br>java.base<br>java.logging<br>java.sql</pre><p>Although this tells us which modules are used by the application, we’re missing some information. Remember, we’re providing the JavaFX modules separately so we need to analyse any JDK module dependencies they might have. The solution is to include the module details in the same way we did for the Java launcher:</p><pre>&gt; jdeps --module-path /opt/javafx-sdk-11/lib --add-modules=javafx.controls --list-deps FlightRecorder.jar<br>JDK removed internal API/com.sun.media.jfxmediaimpl.platform.ios<br>java.base<br>java.datatransfer<br>java.desktop/java.awt.dnd.peer<br>java.desktop/sun.awt<br>java.desktop/sun.awt.dnd<br>java.desktop/sun.swing<br>java.logging<br>java.scripting<br>java.sql<br>java.xml<br>jdk.jsobject<br>jdk.unsupported<br>jdk.unsupported.desktop<br>jdk.xml.dom</pre><p>I find this output a bit odd, as it includes more than just the module dependencies (which is what we asked for). In the case of (only) the java.desktop module we also get some extra information about the packages used. I also find the first message about the <em>JDK removed internal</em> somewhat confusing.</p><p>In theory, if we want an output that can be used directly in jlink, we can use the--print-module-deps flag instead of --list-dependencies. However, when I tried this on both MacOS X and Linux, I got a NullPointerException. Having posted a Tweet about this it has been <a href="https://bugs.openjdk.java.net/browse/JDK-8211887">submitted as a bug</a> and will hopefully be fixed soon (although it’s a P3 so it may be a while)</p><p>Now we are ready to use jlink to produce a runtime for the application.</p><pre>&gt; jlink --no-header-files --no-man-pages --compress=2 --strip-debug --add-modules java.datatransfer,java.desktop,java.logging,java.scripting,java.sql,java.xml,jdk.jsobject,jdk.unsupported,jdk.unsupported.desktop,jdk.xml.dom — output java-runtime</pre><p>To keep the size of the runtime as small as possible, we use command line flags to suppress the inclusion of header files and man pages as well as stripping the debug information and compressing to zip file format where relevant. The list of modules to include is the one generated by jdeps.</p><p>At this point, you would be forgiven for thinking that we can now run the application using our jlink generated runtime. However, if we try this here is the output:</p><pre>&gt; java-runtime/bin/java --module-path /opt/javafx-sdk-11/lib --add-modules=javafx.controls -jar FlightRecorder.jar<br>SEVERE: Error connecting to database<br>SEVERE: java.lang.NoClassDefFoundError: javax/naming/RefAddr</pre><p>This is because the application uses a MySQL JDBC driver packaged in the lib/mysql-connector-java-5.1.23-bin.jar file. Because this (and the two other jar files in the lib directory) are accessed via the classpath, they are not automatically analysed by jdeps. The jdeps command does allow you to specify a classpath via the -cp flag. Unfortunately, jdeps does not appear to use this to reference jar files that are required by the application. It is, therefore, necessary to make sure that all jar files used by the application are passed as arguments:</p><pre>&gt; jdeps --module-path /opt/javafx-sdk-11/lib --add-modules=javafx.controls --list-deps FlightRecorder.jar lib/*<br>JDK removed internal API/com.sun.media.jfxmediaimpl.platform.ios<br>java.base<br>java.datatransfer<br>java.desktop/java.awt.dnd.peer<br>java.desktop/sun.awt<br>java.desktop/sun.awt.dnd<br>java.desktop/sun.swing<br>java.logging<br>java.management<br>java.naming<br>java.rmi<br>java.scripting<br>java.sql<br>java.transaction.xa<br>java.xml<br>jdk.jsobject<br>jdk.unsupported<br>jdk.unsupported.desktop<br>jdk.xml.dom</pre><p>As you can see, we need to include a few more modules in our runtime. The command for jlink becomes:</p><pre>jlink --no-header-files --no-man-pages --add-modules java.datatransfer,java.desktop,java.logging,java.management,java.naming,java.rmi,java.scripting,java.sql,java.transaction.xa,java.xml,jdk.jsobject,jdk.unsupported,jdk.unsupported.desktop,jdk.xml.dom --output java-runtime</pre><p>The application now runs without any problems using the generated runtime. On my Mac, the java-runtime directory is a very respectable 39Mb, compared to 286Mb for the full JDK.</p><p>To simplify redistribution, we can copy the dist directory with the application jar files into the java-runtime directory, create a simple script to execute Java with all the appropriate command line flags and we are all good to go.</p><p>Why not try it with your applications?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9568c5e70ef4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/azulsystems/using-jlink-to-build-java-runtimes-for-non-modular-applications-9568c5e70ef4">Using jlink to Build Java Runtimes for non-Modular Applications</a> was originally published in <a href="https://medium.com/azulsystems">Azul Systems</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>