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>
