JavaFX provides a lot of interesting capabilities for developing rich client applications in Java, but what if you are working
on an existing Swing application
and you want to take advantage of these new features? Maybe you want to use one or two controls like the LineChart or a MediaView. Maybe you want to embed a large Scene Graph as an initial step in porting your application to FX. A hybrid Swing/FX application might just be the answer.
Developing a hybrid Swing +
JavaFX application is not terribly difficult, but until recently the deployment of hybrid applications has not simple as a "pure"
JavaFX application. The existing tools focused
on packaging FX Applications, or Swing applications - they did not account for hybrid applications.
But with
JavaFX 2.2 the tools include support for this hybrid application use case.
Solution
In
JavaFX 2.2 we extended the packaging ant tasks to greatly simplify deploying hybrid applications. You now use the same deployment approach as you would for pure
JavaFX applications. Just bundle your main application jar with the fx:jar ant task
and then generate html/jnlp files using fx:deploy. The only difference is setting toolkit attribute for the fx:application tag as shown below:
<fx:application id="swingFXApp" mainClass="${main.class}" toolkit="swing"/>
The value of ${main.class} in the example above is your application class which has a main method. It does not need to extend
JavaFX Application class.
The resulting package provides support for the same set of execution modes as a package for a
JavaFX application, although the packages which are created are not identical to the packages created for a pure FX application. You will see two JNLP files generated in the case of a hybrid application - one for use from Swing applet
and another for the webstart launch.
Note that these improvements do not alter the set of features available to Swing applications. The packaging tools just make it easier to use the advanced features of
JavaFX in your Swing application. The same limits still apply, for example a Swing application can not use JavaFX Preloaders and code changes are necessary to support HTML splash screens.
Why should I use the
JavaFX ant tasks for packaging my Swing application?
While using FX packaging tool for a Swing application may seem like a mismatch at face value, there are some really good reasons to use this approach. The primary justification for our packaging tools is to simplify the creation of your application artifacts,
and to reduce manual errors. Plus, no one should have to write JNLP by hand.
Some specific benefits include:
Your application jar will include a launcher program. This improves your standalone launch by:
checking for the
JavaFX runtime
guiding the user through any necessary installations
setting the system proxy for Java
The ant tasks will generate JNLP
and HTML files for your swing app:
avoids learning unnecessary details about JNLP,
and eliminates the error-prone hand editing of JNLP files
simplifies using advanced features like embedding JNLP and signing jars as BLOBs to improve launch performance.you can also embed the signing certificate details to improve the user's experience
allows the use of web page templates to inject the generated code directly into your actual web page instead of being forced to copy/paste the generated code snippets.
What about native packing?
Absolutely! The very same ant task can generate a native bundle for a Swing application with
JavaFX content. Try running one of these sample native bundles for the "SwingInterop" FX example: exe and dmg. I also used another feature
on these examples: a click-through license agreement for .exe installers
and OS X DMG drag installers.
Small Caveat
This packaging procedure is optimized around using the
JavaFX packaging tools for your entire Swing application. If you are trying to embed
JavaFX content into existing project (with an existing build/packing process) then you may need to experiment in order to find the best way to integrate the
JavaFX packaging steps into your existing build procedure.
As long as you can use ant in your build process this should be a workable approach.
It some cases solution could be less than ideal. For example, you need to use fx:jar to package your main jar file in order to produce a double-clickable jar or a native bundle. The jar will be created from scratch, but you may already be creating the main jar file with a custom manifest. This may lead to some redundant steps in your build process. Hopefully the benefits will outweigh the problems.
This is an area of ongoing development for the team,
and we will continue to refine
and improve both the tools
and the process. Please share your experiences
and suggestions with us. You can comment here
on the blog or file issues to JIRA.
Sample code
Here is the full ant code used to package SwingInterop. You can grab latest
JavaFX samples
and try it yourself:
<target name="-post-jar">
<taskdef resource="com/sun/javafx/tools/ant/antlib.xml"
uri="javafx:com.sun.
javafx.tools.ant"
classpath="${javafx.tools.ant.jar}"/>
<!-- Mark application as Swing-based -->
<fx:application id="swingFXApp" mainClass="${main.class}" toolkit="swing"/>
<!-- Create doubleclickable jar file with embedded launcher -->
<fx:jar destfile="${dist.jar}">
<fileset dir="${build.classes.dir}"/>
<fx:application refid="swingFXApp" name="SwingInterop"/>
<manifest>
<attribute name="Implementation-Vendor" value="${application.vendor}"/>
<attribute name="Implementation-Title" value="${application.title}"/>
<attribute name="Implementation-Version" value="1.0"/>
</manifest>
</fx:jar>
<!-- sign application jar. Use new self signed certificate -->
<delete file="${build.dir}/test.keystore"/>
<genkey alias="TestAlias"
storepass="xyz123" keystore="${build.dir}/test.keystore"
dname="CN=Samples, OU=JavaFX Dev, O=Oracle, C=US"/>
<fx:signjar keystore="${build.dir}/test.keystore"
alias="TestAlias" storepass="xyz123">
<fileset file="${dist.jar}"/>
</fx:signjar>
<!-- generate JNLPs, HTML
and native bundles -->
<fx:deploy width="960" height="720" includeDT="true"
nativeBundles="all"
outdir="${basedir}/${dist.dir}" embedJNLP="true"
outfile="${application.title}">
<fx:application refId="swingFXApp"/>
<fx:resources>
<fx:fileset dir="${basedir}/${dist.dir}" includes="SwingInterop.jar"/>
</fx:resources>
<fx:permissions/>
<info title="Sample app: ${application.title}"
vendor="${application.vendor}"/>
</fx:deploy>
</target>
