JavaWorld's Daily Brew

JavaFX 2 Animation: Path Transitions

2012-02-06T23:41:00-05:00

One of the flashiest aspects of JavaFX 2 is its animation support. The insightful Creating Transitions and Timeline Animation in JavaFX covers using both Transitions and Timelines in JavaFX 2. In this blog post, I adapt an example provided in that tutorial to specifically demonstrate Path Transitions.

Example 2 ("Path Transition") shown in Creating Transitions and Timeline Animation in JavaFX demonstrates creating a Path with classes from the JavaFX 2 "shapes" package: javafx.scene.shape.Path, javafx.scene.shape.MoveTo, and javafx.scene.shape.CubicCurve. That example then demonstrates instantiation of a javafx.animation.PathTransition and applying an instantiated javafx.scene.shape.Rectangle to move along the created Path.

In my code listing below, I've made some slight changes to Example 2 in Creating Transitions and Timeline Animation in JavaFX. I have specifically changed the moving shape from a rectangle to a Circle, added two "end knobs" to the path as two separate circles, and added the ability to change the opacity of the path along with the animated circle moves. The nice side effect of using a zero opacity is that the path itself does not appear and it instead looks like the circle is moving along freely. I tried to break each major piece of this up into its own private method to make it easier to see the "chunks" of functionality.

JavaFxAnimations.java

package dustin.examples;

import java.util.List;
import javafx.animation.PathTransition;
import javafx.animation.Timeline;
import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.paint.Color;
import javafx.scene.shape.*;
import javafx.stage.Stage;
import javafx.util.Duration;

/**
 * Simple example demonstrating JavaFX animations.
 * 
 * Slightly adapted from Example 2 ("Path Transition") which is provided in
 * "Creating Transitions and Timeline Animation in JavaFX"
 * (http://docs.oracle.com/javafx/2.0/animations/jfxpub-animations.htm).
 * 
 * @author Dustin
 */
public class JavaFxAnimations extends Application
{
   /**
    * Generate Path upon which animation will occur.
    * 
    * @param pathOpacity The opacity of the path representation.
    * @return Generated path.
    */
   private Path generateCurvyPath(final double pathOpacity)
   {
      final Path path = new Path();
      path.getElements().add(new MoveTo(20,20));
      path.getElements().add(new CubicCurveTo(380, 0, 380, 120, 200, 120));
      path.getElements().add(new CubicCurveTo(0, 120, 0, 240, 380, 240));
      path.setOpacity(pathOpacity);
      return path;
   }

   /**
    * Generate the path transition.
    * 
    * @param shape Shape to travel along path.
    * @param path Path to be traveled upon.
    * @return PathTransition.
    */
   private PathTransition generatePathTransition(final Shape shape, final Path path)
   {
      final PathTransition pathTransition = new PathTransition();
      pathTransition.setDuration(Duration.seconds(8.0));
      pathTransition.setDelay(Duration.seconds(2.0));
      pathTransition.setPath(path);
      pathTransition.setNode(shape);
      pathTransition.setOrientation(PathTransition.OrientationType.ORTHOGONAL_TO_TANGENT);
      pathTransition.setCycleCount(Timeline.INDEFINITE);
      pathTransition.setAutoReverse(true);
      return pathTransition;
   }

   /**
    * Determine the path's opacity based on command-line argument if supplied
    * or zero by default if no numeric value provided.
    * 
    * @return Opacity to use for path.
    */
   private double determinePathOpacity()
   {
      final Parameters params = getParameters();
      final List parameters = params.getRaw();
      double pathOpacity = 0.0;
      if (!parameters.isEmpty())
      {
         try
         {
            pathOpacity = Double.valueOf(parameters.get(0));
         }
         catch (NumberFormatException nfe)
         {
            pathOpacity = 0.0;
         }
      }
      return pathOpacity;
   }

   /**
    * Apply animation, the subject of this class.
    * 
    * @param group Group to which animation is applied.
    */
   private void applyAnimation(final Group group)
   {
      final Circle circle = new Circle(20, 20, 15);
      circle.setFill(Color.DARKRED);
      final Path path = generateCurvyPath(determinePathOpacity());
      group.getChildren().add(path);
      group.getChildren().add(circle);
      group.getChildren().add(new Circle(20, 20, 5));
      group.getChildren().add(new Circle(380, 240, 5));
      final PathTransition transition = generatePathTransition(circle, path);
      transition.play(); 
   }

   /**
    * Start the JavaFX application
    * 
    * @param stage Primary stage.
    * @throws Exception Exception thrown during application.
    */
   @Override
   public void start(final Stage stage) throws Exception
   {
      final Group rootGroup = new Group();
      final Scene scene = new Scene(rootGroup, 600, 400, Color.GHOSTWHITE);
      stage.setScene(scene);
      stage.setTitle("JavaFX 2 Animations");
      stage.show();
      applyAnimation(rootGroup);
   }

   /**
    * Main function for running JavaFX application.
    * 
    * @param arguments Command-line arguments; optional first argument is the
    *    opacity of the path to be displayed (0 effectively renders path
    *    invisible).
    */
   public static void main(final String[] arguments)
   {
      Application.launch(arguments);
   }
}

The following series of screen snapshots show this simple JavaFX animation example in action. They are listed in order of descending opacity (from 1.0 to 0.0).

Demonstration of Adapted PathTransition Example (Opacity 1.0)

Demonstration of Adapted PathTransition Example (Opacity 0.2)

Demonstration of Adapted PathTransition Example (Opacity 0.05)

Demonstration of Adapted PathTransition Example (Opacity 0.0)

Each of the above screen snapshots was taken after running the application with the specified command-line argument (1, 0.2, 0.05, and 0).

This adapted example has demonstrated using PathTransition to animate a node's movement along the prescribed path (I have blogged on use of Path and some of its alternatives before). Developers can implement their own derivative of Transition and there are other supplied transitions supported as well (such as FadeTransition, ParallelTransition, and SequentialTransition).

It is a straightforward process to quickly begin applying JavaFX 2 animation using the provided Transition classes.

The Passage of Time

2012-02-06T13:21:57-05:00

I introduced my Java Tutor blog last February, to teach about various Java technologies. Starting in July, I suspended this blog for several months to focus exclusively on Beginning Java 7, a beginner-oriented book on Java 7 that I wrote for Apress. This book’s cover appears in Figure 1.

Figure 1: Visit http://tutortutor.ca/cgi-bin/makepage.cgi?/books/bj7 to learn about Beginning Java 7.

Beginning Java 7 consists of twelve chapters and four appendixes (the appendixes are not included in the print version). Now that I’ve finished the print version, I’m resuming this blog by excerpting the Clock application from this book’s Appendix D (Applications Gallery).

Note: I recently refactored Java Tutor to focus only on Java 7 and successor versions of the Java standard edition, as well as on JavaFX 2.0 and successor versions. I eliminated my four-part series on Android Gingerbread because Android isn’t relevant to my new focus. I also revisited each post to ensure that code and content are compliant with JDK 7u2. Regarding my two-part Rebooting JavaFX series, I made sure that code and content are compliant with JDK 7u2 and JavaFX 2.0.2.

Analog Clock

A clock displays the current time in digital or analog format. Creating a digital clock application is trivial, but creating an application that presents an analog clock with moving hour/minute/second hands isn’t so easy. Listing 1 presents the source code to a Clock application that reveals one way to simulate an analog clock.

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Stroke;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import java.util.Calendar;

import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.Timer;

class Clock extends JFrame
{
   Clock()
   {
      super("Clock");
      setDefaultCloseOperation(EXIT_ON_CLOSE);
      setContentPane(new SwingCanvas());
      pack();
      setVisible(true);
   }
   public static void main(String[] args)
   {
      Runnable r = new Runnable()
                   {
                      @Override
                      public void run()
                      {
                         new Clock();
                      }
                   };
      EventQueue.invokeLater(r);
   }
}
class SwingCanvas extends JComponent
{
   private final static int BORDER_WIDTH = 10;
   private BasicStroke bs;
   private Calendar cal;
   private Dimension d;
   private Font font;
   private int width;
   SwingCanvas()
   {
      bs = new BasicStroke(2.5f);
      cal = Calendar.getInstance();
      d = new Dimension(300, 300);
      font = new Font("Arial", Font.BOLD, 14);
      width = d.width-2*BORDER_WIDTH;
      ActionListener al;
      al = new ActionListener()
           {
              @Override
              public void actionPerformed(ActionEvent ae)
              {
                 cal.setTimeInMillis(System.currentTimeMillis());
                 repaint();
              }
           };
      new Timer(50, al).start();
   }
   @Override
   public Dimension getPreferredSize()
   {
      return d;
   }
   @Override
   public void paint(Graphics g)
   {
      Graphics2D g2d = (Graphics2D) g;
      g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                           RenderingHints.VALUE_ANTIALIAS_ON);
      g2d.translate(BORDER_WIDTH, BORDER_WIDTH);
      Stroke stroke = g2d.getStroke();
      // Paint oval.
      g2d.setStroke(bs);
      g2d.drawOval(0, 0, width, width);
      g2d.setStroke(stroke);
      // Paint tick marks.
      int tickEnd = width/2;
      for (int second = 0; second < 60; second++)
      {
         int tickStart;
         if (second%5 == 0)
            tickStart = tickEnd-26; // long tick
         else
            tickStart = tickEnd-13;  // short tick
         drawSegment(g2d, second/60.0, tickStart, tickEnd);
      }
      // Paint hour labels.
      g2d.setFont(font);
      for (int hour = 1; hour <= 12; hour++)
      {
         double angle = (hour-3)*2*Math.PI/12;
         int x = (int) (Math.cos(angle)*(width/2-35))+width/2-5;
         int y = (int) (Math.sin(angle)*(width/2-35))+width/2+5;
         g2d.drawString(""+hour, x, y);
      }
      // Paint hands.
      int hour = cal.get(Calendar.HOUR);
      int min = cal.get(Calendar.MINUTE);
      int sec = cal.get(Calendar.SECOND);
      int ms = cal.get(Calendar.MILLISECOND);
      int secHandMaxRad = width/2-5;
      double fracSec = (sec+ms/1000.0)/60.0;
      g2d.setColor(Color.RED);
      drawSegment(g2d, fracSec, 0, secHandMaxRad);
      g2d.setColor(Color.BLACK);
      int minHandMaxRad = width/3-10;
      double fracMin = (min+fracSec)/60.0;
      drawSegment(g2d, fracMin, 0, minHandMaxRad);
      int hrHandMaxRad = width/4;
      drawSegment(g2d, (hour+fracMin)/12.0, 0, hrHandMaxRad);
   }
   private void drawSegment(Graphics2D g2d, double fraction, int start, int end)
   {
      double angle = fraction*Math.PI*2-Math.PI/2.0;
      double _cos = Math.cos(angle);
      double _sin = Math.sin(angle);
      double minx = width/2+_cos*start;
      double miny = width/2+_sin*start;
      double maxx = width/2+_cos*end;
      double maxy = width/2+_sin*end;
      g2d.drawLine((int) minx, (int) miny, (int) maxx, (int) maxy);
   }
}

Listing 1: Simulating an analog clock

Listing 1 consists of Clock and SwingCanvas classes. Clock serves as this application’s main class and trivially constructs a GUI consisting of a single SwingCanvas instance. SwingCanvas describes a specialized Swing component for displaying a clock face with moving hands, and also contains animation logic for animating this clock to constantly display the current time.

SwingCanvas first declares the following fields:

BORDER_WIDTH: an integer constant that describes the number of pixels to reserve as a border around the clock face. The border gives the clock a nicer appearance.

bs: A java.awt.BasicStroke instance that determines the thickness of the clock face’s round outline. (Chapter 7 introduces BasicStroke.)

cal: A java.util.Calendar instance that’s used to extract the current time in terms of hour, minute, second, and millisecond. (Appendix C introduces Calendar.)

d: A java.awt.Dimension instance that stores the SwingCanvas component’s preferred size. (Chapter 7 introduces Dimension.)

font: A java.awt.Font instance that identifies the font used to display the clock face’s text. (Chapter 7 introduces Font.)

width: An integer that specifies the width of the SwingCanvas component’s drawing area less its border.

These fields are followed by a SwingCanvas() constructor that initializes them to appropriate values. This constructor then creates and starts a Swing timer that fires action events after an initial 50-millisecond delay and at 50-millisecond intervals. Each time an event is fired, the registered action listener initializes the Calendar instance to the current time via cal.setTimeInMillis(System.currentTimeMillis());, and then invokes repaint() to redraw the clock face to reflect this value.

The overriding getPreferredSize() method returns the component’s preferred size and the overriding paint() method redraws the clock face.

paint() first performs initial graphics setup by activating antialiasing (see Chapter 7), which ensures that the clock face looks smooth (no jagged edges), and by translating the drawing area’s (0, 0) origin to (BORDER_WIDTH, BORDER_WIDTH), to facilitate drawing.

Next, paint() saves the current stroke attribute value, installs the custom stroke that was created in the constructor, draws the clock face’s circular outline using the custom stroke, and resets the stroke attribute to its previously saved value.

At this point, paint() draws sixty tick marks (line segments) around the clock face. Each tick mark is a drawn segment of the invisible radius line (at a particular angle) that extends from the circle’s center to its circumference. Its start and end limits are stored in local variables tickStart and tickEnd.

paint() continues by installing the previously created font, and then drawing the hour labels around the clock face and closer to the circle’s center than the tick marks. For each hour from 1 to 12, it first calculates an angle (in radians) for where the hour’s textual label should appear. Because angles are relative to the 3 o’clock position, hour label 0 would appear at this position if it existed, hour label 1 would appear at the 4 o’clock position, and so on unless 3 was subtracted from the hour value before calculating the angle.

After the angle has been calculated, the java.lang.Math class’s double cos(double angle) and double sin(double angle) class methods are invoked to calculate the (x, y) location on the circumference of a unit circle that corresponds to the angle. These values are multiplied by the circle’s radius less a value so that they appear inside the tick marks perimeter; an offset is added to the result so that the location is relative to the center of the component drawing area and not the translated origin. A small offset is subtracted from the x location and added to the y location so that the label is roughly centered below its long tick mark.

paint()’s final task is to paint the second, minute, and hour hands. It first invokes Calendar methods to obtain the current hour, minute, second, and millisecond values – the millisecond value enables the hands to move smoothly in an analog fashion rather than jump forward in a digital fashion.

Each hand is drawn starting from the circle’s center, but not all the way to the circumference. For example, the second hand is drawn to 5 pixels short of the circumference (width/2-5). To distinguish the second hand from the minute and hour hands, the second hand is drawn in red whereas the other hands are drawn in black (the hour hand is shorter to distinguish it from the minute hand).

The paint() method relies on the drawSegment() method to draw tick marks and clock hands. The first argument passed to this method is the graphics context, the second argument is a fraction between 0.0 and 1.0 that represents the amount of clockwise angular movement from the 3 o’clock position, and the third and fourth arguments define the start and end of the visible portion of the radius to display.

This method first calculates the angle via expression fraction*Math.PI*2-Math.PI/2.0. It subtracts Math.PI/2 from fraction*Math.PI*2 to make the angle relative to the 12 o’clock position.

It next calculates the angle’s cosine and sine, and uses these values with the start and end arguments and the width field variable’s value to calculate the starting and ending positions of the line segment to draw.

Compile Listing 1 (javac Clock.java) and run this application (java Clock). You should see output similar to that shown in Figure 2.

Figure 2: Clock presents the current time in analog format.

Moving Forward

Future posts will introduce you to more Java-oriented topics. Along with tutorials on language, API, and other Java features, I’ll cover various aspects of JavaFX (including a detailed study of binding). Many of the posts will focus on various projects, including projects related to compiler construction and other tools. Not everything will be exclusively about Java, but Java will be involved in some fashion.

I won’t be posting regularly, but will post at least once or twice a month.

Exercises

Digital clocks present an AM/PM indicator, but Clock does not have this capability. Modify Clock to indicate whether the specified time reflects AM or PM (e.g., 3AM or 5PM).

Code

You can download this post's code and answers here. Code was developed and tested with JDK 7u2 on a Windows XP SP3 platform.

* * *

I welcome your input to this blog, and will write about relevant topics that you suggest. While waiting for the next blog post, check out my TutorTutor website to learn more about Java and other computer technologies (and that's just the beginning).

Properties with Spring

2012-02-06T09:42:43-05:00

Spring has always tried to be as transparent as possible when it comes to working with properties. Before Spring 3.1 however, the mechanism of both adding new sources of properties into Spring as well as actually using the properties wasn’t as flexible and as robust as it could be.

Starting with Spring 3.1, the new Environment and PropertySource abstractions simplify working with properties. The default Spring Environment now contains two property sources: the System properties and the JVM properties, with the System properties having precedence.

For more information on the unified property management in Spring 3.1, see this official article.

Registering Properties via the XML namespace

In an XML configuration, new property files can be made accessible to Spring via the following namespace element:

Registering Properties via Java Annotations

Spring 3.1 also introduces the new @PropertySource annotation, as a convenient mechanism of adding property sources to the environment. This annotation is to be used in conjunction with Java based configuration and the @Configuration annotation:

As opposed to using XML namespace element, the Java @PropertySource annotation does not automatically register a PropertySourcesPlaceholderConfigurer with Spring. Instead, the bean must be explicitly defined in the configuration to get the property resolution mechanism working. The reasoning behind this unexpected behavior is by design and documented on this issue.

Behind the Scenes – the Spring Configuration

Before Spring 3.1

Since the convenience of defining property sources with annotations was introduced in the recently released Spring 3.1, XML based configuration was necessary in the previous versions.

Defining a XML element automatically registers a new PropertyPlaceholderConfigurer bean in the Spring Context. This is also the case in Spring 3.1 if, for backwards compatibility purposes, the XSD schemas are not updated to the 3.1 versions.

In Spring 3.1

From Spring 3.1 onward, the XML will no longer register the old PropertyPlaceholderConfigurer but the newly introduced PropertySourcesPlaceholderConfigurer. This replacement class was created be more flexible and to better interact with the newly introduced Environment and PropertySource mechanism; it should be considered the standard for 3.1 applications.

Properties by hand in Spring 3.0 – PropertyPlaceholderConfigurer

Besides the convenient methods of getting properties into Spring – annotations and the XML namespace – the property configuration bean can also be defined and registered manually. Working with the PropertyPlaceholderConfigurer gives us full control over the configuration, with the downside of being more verbose and most of the time, unnecessary.

Java configuration

XML configuration

Properties by hand in Spring 3.1 – PropertySourcesPlaceholderConfigurer

Similarly, in Spring 3.1, the new PropertySourcesPlaceholderConfigurer can also be configured manually:

Java configuration

XML configuration

Using properties in Spring

Both the older PropertyPlaceholderConfigurer and the new PropertySourcesPlaceholderConfigurer added in Spring 3.1 resolve ${…} placeholders within bean definition property values and @Value annotations.

For example, to inject a property using the @Value annotation:

Using properties in Spring XML configuration:

And lastly, obtaining properties via the new Environment APIs:

Properties Search Precedence

By default, in Spring 3.1, local properties are search last, after all environment property sources, including property files. This behavior can be overridden via the localOverride property of the PropertySourcesPlaceholderConfigurer, which can be set to true to allow local properties to override file properties.

In Spring 3.0 and before, the old PropertyPlaceholderConfigurer also attempted to look for properties both in the manually defined sources as well as in the System properties. The lookup precedence was also customizable via the systemPropertiesMode property of the configurer:

never – Never check system properties
fallback (default) – Check system properties if not resolvable in the specified properties files
override – Check system properties first, before trying the specified properties files. This allows system properties to override any other property source.

Conclusion

This article covered the various ways to work with Properties in Spring, discussing both the older Spring 3.0 and below and the new support for properties, introduced in Spring 3.1. For a project making heavy use of properties, check out the github project.

If you read this far, you should follow me on twitter here.

Book Review: JBoss AS 7: Configuration, Deployment, and Administration

2012-01-31T22:04:00-05:00

I eagerly accepted Packt Publishing's invitation to review JBoss AS 7: Configuration, Deployment, and Administration because it has been several years since I last used JBoss and I was curious to learn more about JBoss AS 7. I have already written about my First Impressions of Book 'JBoss AS 7 Configuration, Deployment and Administration' and in this post I review the book in greater detail while attempting to minimize how much I repeat from that post. My review is based on an electronic (PDF) copy of JBoss AS 7: Configuration, Deployment, and Administration.

General Features

JBoss AS 7: Configuration, Deployment, and Administration highlights particularly important notes and warnings within boxing that makes them obvious and with an icon representing a pencil and paper. Similarly, tips and tricks also attract special attention with similar boxing and with a light bulb icon. It is helpful to have the most important notes and tips and tricks highlighted like this.

It didn't take much reading of this book to realize how significantly new JBoss AS 7's architecture is. One of the strengths of JBoss AS 7: Configuration, Deployment, and Administration is its comparisons of previous versions of JBoss AS to JBoss AS 7. These comparisons help to understand how changed JBoss AS 7 is and should be especially helpful to anyone migrating to JBoss AS 7 from a previous version.

This book provides several tables of various configuration options and their descriptions. These tables provide easy reference for various configuration options. Although I mostly just skimmed these as I read this book, I noted their existence for future reference when configuring various parts of JBoss AS 7.

Command line interfaces and script-based configuration and administration are emphasized throughout the book. I appreciate this because I tend to use command line approaches far more frequently than I use graphical tools, but some books focus almost exclusively on the graphical tools.

Perhaps the greatest strength of JBoss AS 7: Configuration, Deployment, and Administration is its focus on what its title promises: configuration, deployment, and administration. Although this book does provide brief introductory details about Java EE, the book assumes that the reader will look to focused books or tutorials for detailed information on Java EE. This allows the book to focus on administration and configuration of and deployment to JBoss AS 7.

Although examples in the book specifically use Eclipse, MySQL, and Windows, the descriptions and explanations are broad enough to cover other choices of IDE, database, and operating system respectively. The illustrations assuming one of these are relatively rare and most of the discussion is more general to JBoss AS 7 rather than to any of these supporting products. In many of these cases, alternatives (and how to use those alternatives) are mentioned. The final chapter (cloud computing with OpenShift) and the Appendix (common commands and operations) provide Linux-based examples.

There is a small number of typos and a few instances of questionable sentence structure, but the author's writing style generally flows easily and is easy to follow. There are numerous drawings, tables, and screen snapshots to illustrate points and highlight the more important details. I like the significant white space and the call outs for special notes and observations.

Chapter 1: Installing JBoss AS 7

Because I have not used JBoss for several years, I needed to install JBoss AS 7 and this chapter provides an easy guide to doing that. The chapter begins with brief coverage of the usefulness of Java EE application servers and of JBoss AS 7's high-level design. It then moves into the practical steps necessary for installing JBoss AS 7. The author recommends in one of the "important notes" that readers download and use the Java 6 SDK, but does acknowledge that Java SE 7 SDK is available and should work fine with JBoss AS 7. The chapter discusses installation on Windows and Linux/Unix and even includes a "tip/trick" highlighting of installation on Windows Vista. The chapter goes beyond basic installation (which amounts to uncompressing archive files) to discuss starting and stopping JBoss AS 7 and using Command Line Interface (CLI) to connect to it locally and remotely.

The initial chapter also discusses installation of Eclipse ("the development environment used in this book"). Besides downloading and installing Eclipse (Indigo), the chapter also discusses installation of the JBoss AS plugins (part of JBoss Tools) for Eclipse.

One of my favorite parts of this initial chapter is its coverage of the application server's directory structure and differentiation of JBoss AS 7's "standalone servers and domain servers." This was an important distinction for me coming back to JBoss after such a long period of time, but was an easy one to grasp because of my familiarity with GlassFish. After differentiating between the types of servers supported in JBoss AS 7, the section concludes with coverage of several significant directories/folders in the JBoss AS 7 installation.

Chapter 2: Configuring the Application Server

With JBoss AS 7 and tools (Eclipse) installed, it is natural to move onto configuring the JBoss AS 7 instance. This chapter had some surprises for me, including starting with this: "The application configuration has also been renewed, moving from a large set of XML files to a single monolithic file." The chapter discusses this single file and covers its default names (depending on server configuration). It goes through the configuration file one major section at a time, detailing how to configure the server in each area. There is quite a bit in this chapter on configuring logging. Another thing I learned here that has changed in JBoss in recent years is default use of its own logging framework.

Chapter 3: Configuring Enterprise Services

The third chapter is on configuring enterprise services. This chapter specifically focuses on configuring database connectivity, EJB container, messaging service, and transaction service.

The section of Chapter 3 on configuring database connectivity mentions that JBoss AS 7 comes with the H2 open source database server built in, but then uses MySQL for its examples. I liked how this chapter compared and contrasted how database configuration was performed in previous versions of JBoss AS to how it is now done in JBoss AS 7. The chapter demonstrates XML-based configuration of a data source (and how it was similar to that used in previous versions of the JBoss application server), but then also shows how to use the Java EE 6 annotation @DataSourceDefinition to programmatically configure the data source in conjunction with an EJB 3.1 Singleton EJB.

Chapter 3's section on configuring the EJB container starts by introducing the basics of EJBs with specific introductory focus on the "new EJB 3.1 variants introduced by Java EE 6": Singleton EJB, No-Interface EJB, and Asynchronous EJB. The chapter discusses in detail how to configure the different types of EJBs. It also points out the built-in JMS support in JBoss AS 7 provided by HornetQ. It also covers configuration related to JBoss AS 7's/HornetQ's use of Netty.

The section of Chapter 3 on configuring transactions introduces the Java Transaction API. It then explains how to configure the JTA support for timeouts and statistics gathering.

Chapter 4: JBoss Web Server Configuration

The focus of the fourth chapter of JBoss AS 7: Configuration, Deployment, and Administration is on configuration of the JBoss web server (JBoss Web), which is based on a fork of Tomcat 7. The chapter discusses HTTP connectors, including JBoss Web's built-in Coyote HTTP 1.1 connector and the Apache Portable Runtime (APR) connector. The chapter shows how to separately download and use the ARP connector with JBoss AS 7.

The chapter of JBoss Web server covers configuration of static (HTML/images) and dynamic (JSP) resources and then moves onto discussion of deploying JavaServer Faces (JSF)-based applications on JBoss AS 7. The author points out: "Currently, JBoss AS 7 supports the JSF release 2.1 using the Mojarra implementation,
although there are plans for supporting MyFaces implementation too." The chapter then demonstrates using Eclipse to create a JSF project and adding an EJB layer to that application. The chapter also demonstrates adding JPA-based persistence (including how to switch the JPA provider from default Hibernate 4), setting a custom web context, and deploying the web application.

Chapter 5: Configuring a JBoss AS Domain

The fifth chapter concludes the chapters on configuration by providing a more detailed look at configuring JBoss AS 7 domains. Of particular interest to me is the sections on configuring the JVM and providing JVM options. I also found the author's use of VisualVM to be helpful. This detailed chapter introduces domain terminology, explains what a domain is, and explains why a domain does not provide the same functionality or purpose as node clustering. It provides thorough detail on configuring domains.

Chapter 6: Deploying Applications on JBoss AS 7

Deployment to JBoss AS 7 is the focus of Chapter 6. The chapter begins with an introduction to JAR, WAR, EAR, RAR, and SAR files and then goes onto more detailed (but still thankfully brief) coverage of the first three types of archive files.

After covering JAR, WAR, and EAR, the chapter moves onto coverage of manual and automatic deployments to JBoss AS 7. I was happy to see coverage of using CLI to deploy from the command line, but fans of deploying via web page will be happy to know that there is also coverage of deploying from the web administration console. The chapter also demonstrates deploying from the Eclipse IDE.

The most significant bane of my Java development experience has probably been classloaders, which become tricky when application servers, IDEs, and frameworks like Spring are involved. With this in mind, I was happy to see a section in the sixth chapter called "JBoss AS 7 classloading explained." Several pages are devoted to using JBoss's provided mechanism for appropriately dealing with classes used by the application server as well as the deployed applications. The chapter also talks about using Java EE's standard approach of specifying Class-Path in the MANIFEST.MF file.

Chapter 7: Managing the Application Server

The seventh chapter focuses on managing JBoss AS 7 via the command line-based CLI tool and the web-based Web admin console. Differentiation is made between CLI commands and CLI operations. I find the sections "Executing CLI scripts in batch" and "Executing scripts in a file" to be particularly interesting from a CLI perspective. The first section talks about CLI support for a group of commands as an atomic unit and the second section talks about writing file-based administration scripts. The book further peaks my interest in CLI by explaining how to take snapshots in CLI and how to display CLI history.

Although I find that I use command line-based tools for configuration, administration, and deployment of an application server in the long-run, web-based or other graphically-oriented tools are often nice when first using an application server or when trying to figure new things out. In other words, I prefer command line scripting for routine tasks and prefer graphically-oriented administrative tools for new or unusual tasks. The second half of Chapter 7 covers using "The new Web admin console."

Chapter 7's coverage of the history of JBoss's web administrative consoles is a good example of how the overall book does a nice job of comparing and contrasting different versions of JBoss tools. The chapter points out the advantages and limitations of the jmx-console approach (versions of JBoss up to JBoss 4.x) and the Seam-based Web admin console (JBoss 5.x and 6.x) before covering JBoss AS 7's GWT-based Web admin console. As one would expect, the section on Web admin console is filled with screen snapshots demonstrating the Web admin console in action.

Chapter 8: Clustering

One of the things many of us want from our application server is clustering functionality, which is the theme of Chapter 8 (load balancing of web applications is covered in the next chapter). The chapter points out several facets of clustering that have changed in JBoss AS 7. It also covers how JGroups and Infinispan are used to implement JBoss clustering. This is an information--packed chapter that I will be sure to read again before using JBoss AS 7 clustering.

Chapter 9: Load-balancing Web Applications

Chapter 9 covers load-balancing of web applications. The chapter only briefly covers installation of Tomcat's mod_jk and Apache's mod_proxy to connect the Apache web server to JBoss AS 7 because "the installation of either mod_jk or mod_proxy does not differ from earlier AS releases." The remainder of the chapter focused on load balancing covers mod_cluster (new to JBoss AS 7). The chapter concludes by returning to discussion of clustering. The author references the JBoss AS 7.1 High Availability Guide for continuing developments related to JBoss AS 7's clustering support.

Chapter 10: Securing JBoss AS 7

Chapter 10 of JBoss AS 7: Configuration, Deployment, and Administration is focused on security, an increasingly popular topic. Reading about security is often my best cure for insomnia, but there were some interesting nuggets in this chapter that kept my attention.

The chapter introduces PicketBox (formerly known as JBoss Security), the security framework upon which JBoss AS 7's security is built. It then provides a basic overview of Java's security API and provide definitions of key security terms in a Java EE context. This thorough chapter covers a wide range of security-related topics as they pertain to JBoss AS 7.

Chapter 11: Taking JBoss AS 7 in the Cloud

The final chapter is devoted to the trendiest topic of them all: cloud computing. The central focus of this chapter is Red Hat's OpenShift (PaaS). The author does as good a job as I have seen of describing cloud computing and I particularly liked the contrasting of cloud computing to grid computing. The majority of the chapter discusses starting with OpenShift Express and then transitioning to OpenShift Flex.

Appendix

The Appendix is six pages of "common commands and operations" that provides an easy access reference. Although the shown commands use Linux script jboss-admin.sh, the alternative for Windows (jboss-admin.bat) is shown at the beginning of the appendix. The subsections of the appendix are Startup Options, General Commands, Domain Mode, JMS, Data sources, mod_cluster, Batch, and Snapshots.

Conclusion

JBoss AS 7: Configuration, Deployment, and Administration delivers what it's title promises: an introduction and in-depth coverage of configuring and administrating and deploying to JBoss AS 7. Along the way, the book manages to provide differences in JBoss AS 7 from previous versions and to provide introductory details about aspects of Java EE supported in JBoss AS 7. This is not the book one would learn how to write JavaServer Pages, JavaServer Faces applications, EJBs, or other Java EE code from. However, it is the book one would learn how to deploy a Java EE application to JBoss AS 7 and how to maintain and configure JBoss AS 7 to most efficiently support Java EE applications.

Other Reviews

Other reviews of JBoss AS 7: Configuration, Deployment, and Administration are available. These include Markus Eisele's Review: "JBoss AS7 Configuration, Deployment and Administration" by Francesco Marchioni, Rick Wagner's Book Review for "JBoss AS 7 Configuration Deployment and Administration" (unfinished version of the book), Maksim Sorokin's [PACKT] JBoss AS 7 Configuration, Deployment and Administration (announcing review coming), and David Salter's Forthcoming Book Review (announcing review coming).

Original posting available at http://marxsoftware.blogspot.com/ (Inspired by Actual Events)

the case for pre-built EJB components

2012-01-30T16:07:09-05:00

The case is simple, and it has a history: build functional applications that are cross-platform, and revive the model of Java to be write-once-run across multiple platforms. This was done, in some form, by Theory Center before they were acquired by BEA in 1999, and it allowed WebLogic to take the early lead, that ultimately led to their sizable cash-out, in the form of the Oracle acquisition. Nothing made IT managers happier than to see something actually working on top of these Internet operating systems, that were to be known as application servers. They could see what they were investing in, if Theory Center worked, then their own development efforts could also work. I was working on iPlanet's competitor to WL, and never once did I see a deployment of Theory Center, yet many of the largest financial services firms and teleco's, deployed WebLogic in their environments. Some will say that application servers never lived up to their promise of integrating all of Java, in to one common platform, that could rival Microsoft's datacenter offerings. But that is what is available today: a belief that cloud computing will re-orient the data-center like no other offering brought forth by enterprise vendors in the last twenty years. It is the Internet taken to its natural destination, and it is custom-made for application server vendors to take their offerings in to the cloud. The vendors, themselves, are coming at from different angles. JBoss is the lead environment for Red Hat Linux, and OS that desires to see the market go cloud, it is Oracle that will lead with applications for intra-environment deployment, and IBM will offer up some customization to argue for their own tools to be deployed as cloud infrastructure. Even Spring Source is in the cloud game with VMWare having invented the enterprise cloud architecture. What do all of these have in common?

They all are lacking the Theory Center moment, when you can walk in to a customer and visibly demonstrate what is being explained in technical terms. The promise of pre-built functionality has always been on the minds of the vendors, and customers have their own in-house set of components that run certain functionality, and that can be re-used across multiple projects. What is needed is a firm, a coalition of firms, or a series of start-up moves to re-kindle the fire originally set by the promise of the EJB component model. Pre-built EJBs are what would give the cloud that discernible advantage over the Azure promise of integration across the platform. Windows Server is acquiring the enterprise, slowly but surely, with 50% of deployments worldwide having gone to WS, and 20% with Linux, and 30% other. In order for the remaining non-Windows 50% to compete, it needs these pre-built components to show the power of Java's development model, and work across the vendors to prove the deployment model. Whether that be IBM Global Services, or Oracle's Support Network, or JBoss consultants, worldwide, the component model needs a new life. This can be done in basic steps toward a full-fledged platform, that would deliver shopping cart, credit card transactions, other shopping features for consumers, B2B transactions like supply chain management, integration with all sorts of data sources are ready for pre-built functionality, and beyond.

The best way to deliver this is on top of Glassfish, as the Reference Implementation for JEE 6 and 7, it can showcase the advanced cloud features of Enterprise Java. Pre-built components would give customers something to work with as they investigate the business model of going with Java over Azure in the cloud build-out. Microsoft will be forced to retaliate, but they do not have an industry that has committed to delivering specification after another, with partners, that compete for the same accounts. The Microsoft components will be more centered at Google, anyway, their Great Plains product-set has been focused on ERP and other large functionality efforts, not micro-enough to be componentized in time for Java components to build a user base that will set them off on the cloud projects, that are certain to spring up, as IT managers look to new models to improve delivery of their respective employers' web offerings. Get EJBs back in the discussion, and integrate with other non-EJB models through JAX, and see the application server vendors regain the argument that has been eroded by years of over-hype, now is the time to deliver on the hype of Java on the server-side. Right now, it is all a process of upgrades and maintenance decisions, make it about the cloud and see new models and new opportunities rise to the surface.

This cause has been called for before, it has been dis-credited, and to be honest, is like kryptonite to IT everywhere. The promise of pre-buuilt components, a long-time Holy Grail in development, is a real possibility in deployment, today, with the clouds becoming the leading selling point of vendors, and the leading interest area of customers. How to make these clouds work? Microsoft has it figured out with their complete package of development and integration among a wide-swath of products. All Java needs is a development environment, pre-built components, and application servers to compliment the data sources and integration efforts already in place across the enterprise. There is no need to sell new platforms, or new models, the app servers are the cloud OS, always have been, they were just disguised as dot-com enablers, in their earlies incarnation, but they power the Internet. Where would IT be without enterprise Java, it would be stuck in non-standard, non-compatible environments, without any hope of achieving acquisition or other-wise integration, it would be much costlier to run an IT environment, without application servers. Re-charge the debate around Java with pre-built EJBs, that work across cloud environments, make it a competitive marketplace for selecting components, that can work together, and turn the power back to developers within enterprises. The cloud will shake out from there. Without it, there is no functionality to sell on, and allows Microsoft and Azure all the advantages of integration without standards. All of the Java vendors would benefit, and Glassfish would have a standing chance of becoming one of those deployment environments ready for the cloud. This is Oracle's best opportunity for the cloud, beyond whatever WebLogic does to become Fusion for the Oracle Cloud, a pre-built set of Java specific functionality would be a major starting point for how Java vendors are to approach the cloud. It would translate to benefits across the Java ecosystem.

JavaFX 2 Presents the Quadratic Formula

2012-01-30T09:58:00-05:00

I recently needed to check some homework answers related to use of the quadratic formula. After realizing that it was getting tedious to do these by hand, I thought of using my calculator to solve them. However, I realized that I could write a simple application using JavaFX to calculate the results and that approach seemed more interesting than using the calculator. This post demonstrates that simple application and provides the relatively straightforward code required to make it happen.

The next couple of screen snapshots demonstrate the simple application in example. They include the initial appearance of the application followed by a couple images showing different values calculated by the application.

The last screen snapshot shows the output when one of the coefficients provided does not allow the quadratic formula to be applied. To provide this application slightly broader application than solely quadratic equation solving, I have added code to detect when the 'a' coefficient is zero and the 'b' coefficient is non-zero. This is a linear equation and the simple application solves it as well as the quadratic equations provided. The next screen snapshot demonstrates the output when coefficients for a linear equation are provided.

The first code listing has nothing to do with the JavaFX presentation layer, but is instead a simple call that provides the basic back-end quadratic formula calculations. I include it here because it is use by the JavaFX example application. It is somewhat interesting in its own right because there are so many ways to calculate a square root in Java. The best-known approach is to use Math.sqrt(double), but the choices are often more varied when using BigDecimal instead of double. Because the purpose of my post is to focus on the JavaFX aspect of this and because my chosen approach is accurate enough for its purposes, I've taken the "easy way" out here and simply use Math.sqrt(double).

SimplisticQuadraticFormula.java

package dustin.examples;

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;

/**
* Class encapsulating quadratic formula implementation.
*
* @author Dustin
*/
public class SimplisticQuadraticFormula
{
/** Default precision used for specifying scale. */
private static final int DEFAULT_PRECISION = MathContext.DECIMAL64.getPrecision();

/** Convenient representation of zero as BigDecimal. */
private static final BigDecimal ZERO = new BigDecimal("0");

/** Convenient representation of two as BigDecimal. */
private static final BigDecimal TWO = new BigDecimal("2");

/** Convenient representation of four as BigDecimal. */
private static final BigDecimal FOUR = new BigDecimal("4");

/**
* Calculate intercepts with x-axis.
*
* @param a Coefficient 'a' from a quadratic equation to be solved.
* @param b Coefficient 'b' from a quadratic equation to be solved.
* @param c Coefficient 'c' from a quadratic equation to be solved.
* @return The x-intercepts or solutions to the quadratic equation (two values)
* or a single value if solution to a linear equation. Note that two
* solutions are always provided for quadratic equations even if they are
* the same.
* @throws NumberFormatException Thrown when x-intercepts cannot be calculated.
*/
public static List calculateXIntercepts(
final BigDecimal a, final BigDecimal b, final BigDecimal c)
{
final List intercepts = new ArrayList();
if (a.compareTo(ZERO) == 0 && b.compareTo(ZERO) == 0)
{
// neither quadratic nor linear
throw new NumberFormatException("Must have coefficient for one of x terms.");
}
else if (a.compareTo(ZERO) == 0) // linear equation
{
intercepts.add(c.setScale(DEFAULT_PRECISION).negate().divide(b, RoundingMode.HALF_UP));
}
else
{
final BigDecimal intercept1 =
calculateNumeratorWithAddition(a, b, c)
.divide(calculateDenominator(a), RoundingMode.HALF_UP);
intercepts.add(intercept1);
final BigDecimal intercept2 =
calculateNumeratorWithSubtraction(a, b, c)
.divide(calculateDenominator(a), RoundingMode.HALF_DOWN);
intercepts.add(intercept2);
}
return intercepts;
}

/**
* Calculate axis of symmetry, if applicable.
*
* @param a Coefficient 'a' from a quadratic equation to be solved.
* @param b Coefficient 'b' from a quadratic equation to be solved.
* @return The "x" axis of symmetry.
* @throws NumberFormatException Thrown if the provided 'a' coefficient is
* zero because cannot divide by zero.
*/
public static BigDecimal calculateAxisOfSymmetry(final BigDecimal a, final BigDecimal b)
{
if (a.compareTo(ZERO) == 0)
{
throw new NumberFormatException(
"Cannot calculate axis of symmetry based on x-intercepts when a is zero.");
}
return b.setScale(DEFAULT_PRECISION).negate().divide(a.multiply(TWO), RoundingMode.HALF_UP);
}

/**
* Calculate numerator of quadratic formula where the terms are added.
*
* @param a Coefficient 'a' from a quadratic equation to be solved.
* @param b Coefficient 'b' from a quadratic equation to be solved.
* @param c Coefficient 'c' from a quadratic equation to be solved.
* @return Value of numerator in quadratic formula where terms are added.
* @throws NumberFormatException Thrown if no real solution is available.
*/
private static BigDecimal calculateNumeratorWithAddition(
final BigDecimal a, final BigDecimal b, final BigDecimal c)
{
return b.negate().add(calculateSquareRootPortion(a, b, c));
}

/**
* Calculate numerator of quadratic formula where the terms are subtracted.
*
* @param a Coefficient 'a' from a quadratic equation to be solved.
* @param b Coefficient 'b' from a quadratic equation to be solved.
* @param c Coefficient 'c' from a quadratic equation to be solved.
* @return Value of numerator in quadratic formula where terms are subtracted.
* @throws NumberFormatException Thrown if no real solution is available.
*/
private static BigDecimal calculateNumeratorWithSubtraction(
final BigDecimal a, final BigDecimal b, final BigDecimal c)
{
return b.negate().subtract(calculateSquareRootPortion(a, b, c));
}

/**
* Calculate denominator of quadratic formula.
*
* @param a Coefficient of 'a' from a quadratic equation to be solved.
* @return Value of denominator in quadratic formula.
* @throws NumberFormatException Thrown in 0 is provided for coefficient 'a'
* because denominator cannot be zero.
*/
private static BigDecimal calculateDenominator(final BigDecimal a)
{
if (a.compareTo(ZERO) == 0)
{
throw new NumberFormatException("Denominator cannot be zero.");
}
return a.multiply(TWO);
}

/**
* Calculates value of square root portion of quadratic formula.
*
* @param a Coefficient 'a' from a quadratic equation to be solved.
* @param b Coefficient 'b' from a quadratic equation to be solved.
* @param c Coefficient 'c' from a quadratic equation to be solved.
* @return The square root portion of the quadratic formula applied with
* the three provided co-efficients.
* @throws NumberFormatException Thrown if there is no solution (no
* intersection of the x-axis) or if a number is encountered that cannot
* be handled with BigDecmal return type.
*/
private static BigDecimal calculateSquareRootPortion(
final BigDecimal a, final BigDecimal b, final BigDecimal c)
{
BigDecimal sqrt;
final BigDecimal subtrahend = a.multiply(c).multiply(FOUR);
final BigDecimal insideSqrt = b.pow(2).subtract(subtrahend);
if (insideSqrt.compareTo(ZERO) < 0)
{
throw new NumberFormatException("Cannot be solved: no x-intercepts.");
}
else
{
final double value = insideSqrt.doubleValue();
final double sqrtDouble = Math.sqrt(value);
sqrt = new BigDecimal(sqrtDouble); // may throw NumberFormatException
}
return sqrt;
}
}

With the calculations portion in place, it is time to move to the focus of this post (the presentation via JavaFX 2). The following code listing provides the JavaFX 2 class (written in pure Java) used for the application. Note that much of this presentation layer code could have been written using FXML.

QuadraticCalculator.java

package dustin.examples;

import java.math.BigDecimal;
import java.util.List;
import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Pos;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.control.TextFieldBuilder;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.scene.paint.Color;
import javafx.stage.Stage;

/**
* JavaFX-based application for solving quadratic equations.
*
* @author Dustin
*/
public class QuadraticCalculator extends Application
{
/** Coefficient A used in quadratic formula. */
private TextField coefficientA =
TextFieldBuilder.create().promptText("Enter Coefficient A").build();

/** Coeffecient B used in quadratic forumal. */
private TextField coefficientB =
TextFieldBuilder.create().promptText("Enter Coefficient B").build();

/** Coeffecient C (constant) used in quadratic formula. */
private TextField coefficientC =
TextFieldBuilder.create().promptText("Enter Coefficient C").build();

/** First x-intercept. */
private TextField xIntercept1 =
TextFieldBuilder.create().disable(true).editable(false).build();

/** Second x-intercept. */
private TextField xIntercept2 =
TextFieldBuilder.create().disable(true).editable(false).build();

/** Axis of symmetry. */
private TextField symmetryAxis =
TextFieldBuilder.create().disable(true).editable(false).build();

/**
* Extract Image with provided name.
*
* @param imageName Name of image to be provided.
* @return Loaded image.
*/
private Image getImage(final String imageName)
{
final String jarFileUrl =
this.getClass().getProtectionDomain().getCodeSource().getLocation().toString();
final String url = "jar:" + jarFileUrl + "!/" + imageName;
System.out.println(url);
return new Image(url, true);
}

/**
* Provide a read-only horizontal box with quadratic equation and quadratic
* formula and with a button that can be clicked to calculate solution to
* quadration equation with provided coefficients.
*
* @return Horizontal box with quadratic equation and quadratic formula.
*/
private HBox buildEquationsBox()
{
final HBox equationsBox = new HBox();
equationsBox.setAlignment(Pos.CENTER);
equationsBox.setSpacing(50);
final Image quadraticEquation = getImage("quadraticEquation-transparent.png");
final ImageView equationView = new ImageView(quadraticEquation);
equationsBox.getChildren().add(equationView);
final Image quadraticFormula = getImage("quadraticFormula-transparent.png");
final ImageView formulaView = new ImageView(quadraticFormula);
equationsBox.getChildren().add(formulaView);
final Button calculateButton = new Button("Calculate");
calculateButton.setOnAction(
new EventHandler()
{
public void handle(ActionEvent t)
{
final BigDecimal a = extractBigDecimal(coefficientA.getText());
final BigDecimal b = extractBigDecimal(coefficientB.getText());
final BigDecimal c = extractBigDecimal(coefficientC.getText());
try
{
final List intercepts =
SimplisticQuadraticFormula.calculateXIntercepts(a, b, c);
xIntercept1.setText(intercepts.get(0).toPlainString());
xIntercept1.setDisable(false);
if (intercepts.size() > 1)
{
xIntercept2.setText(intercepts.get(1).toEngineeringString());
xIntercept2.setDisable(false);
}
else
{
xIntercept2.setText("-");
xIntercept2.setDisable(true);
}
if (a.compareTo(new BigDecimal("0")) != 0)
{
final BigDecimal axis =
SimplisticQuadraticFormula.calculateAxisOfSymmetry(a, b);
symmetryAxis.setText(axis.toPlainString());
symmetryAxis.setDisable(false);
}
else
{
symmetryAxis.setText("-");
symmetryAxis.setDisable(true);
}
}
catch (NumberFormatException nfe)
{
xIntercept1.setText("-");
xIntercept1.setDisable(true);
xIntercept2.setText("-");
xIntercept2.setDisable(true);
symmetryAxis.setText("-");
symmetryAxis.setDisable(true);
}
}
});
equationsBox.getChildren().add(calculateButton);
return equationsBox;
}

/**
* Converts provided String to BigDecimal.
*
* @param possibleNumber String to be converted to an instance of BigDecimal.
* @return The BigDecimal corresponding to the provided String or Double.NaN
* if the conversion cannot be performed.
*/
private BigDecimal extractBigDecimal(final String possibleNumber)
{
BigDecimal extractedNumber;
try
{
extractedNumber = new BigDecimal(possibleNumber);
}
catch (NumberFormatException nfe)
{
extractedNumber = null;
}
return extractedNumber;
}

/**
* Provide horizontal box with labels of coefficients and fields to enter
* coefficient values.
*
* @return Horizontal box for entering coefficients.
*/
private HBox buildEntryBox()
{
final HBox entryBox = new HBox();
entryBox.setSpacing(10);
final Label aCoeff = new Label("a = ");
entryBox.getChildren().add(aCoeff);
entryBox.getChildren().add(this.coefficientA);
final Label bCoeff = new Label("b = ");
entryBox.getChildren().add(bCoeff);
entryBox.getChildren().add(this.coefficientB);
final Label cCoeff = new Label("c = ");
entryBox.getChildren().add(cCoeff);
entryBox.getChildren().add(this.coefficientC);
return entryBox;
}

/**
* Construct the output box with solutions based on quadratic formula.
*
* @return Output box with solutions of applying quadratic formula given
* provided input coefficients.
*/
private HBox buildOutputBox()
{
final HBox outputBox = new HBox();
outputBox.setSpacing(10);
final Label x1 = new Label("x1 = ");
outputBox.getChildren().add(x1);
outputBox.getChildren().add(this.xIntercept1);
final Label x2 = new Label("x2 = ");
outputBox.getChildren().add(x2);
outputBox.getChildren().add(this.xIntercept2);
final Label axis = new Label("axis = ");
outputBox.getChildren().add(axis);
outputBox.getChildren().add(this.symmetryAxis);
return outputBox;
}

/**
* Build overall presentation of application.
*
* @return Vertical box representing input and output of application.
*/
private VBox buildOverallVerticalLayout()
{
final VBox vbox = new VBox();
vbox.setSpacing(25);
vbox.getChildren().add(buildEquationsBox());
vbox.getChildren().add(buildEntryBox());
vbox.getChildren().add(buildOutputBox());
vbox.setAlignment(Pos.CENTER);
return vbox;
}

/**
* Start the JavaFX application for solving quadratic equations.
*
* @param stage Primary stage.
* @throws Exception JavaFX-related exception.
*/
@Override
public void start(final Stage stage) throws Exception
{
final Group groupRoot = new Group();
groupRoot.getChildren().add(buildOverallVerticalLayout());
final Scene scene = new Scene(groupRoot, 600, 150, Color.LIGHTGRAY);
stage.setTitle("Quadratic Formula: JavaFX Style");
stage.setScene(scene);
stage.show();
}

/**
* Main function for running the JavaFX-based quadratic equation solver.
*
* @param arguments
*/
public static void main(final String[] arguments)
{
Application.launch(arguments);
}
}

The JavaFX 2 code above loads two images with transparent backgrounds to display the standard form of a quadratic equation and to display the quadratic formula. In a previous post, I loaded these images from an external URL, but I loaded them from the application's JAR in this example. These images are shown next independent of the application.

quadraticEquation-transparent.png

quadraticFormula-transparent.png

There are several ways this simplistic application could be improved. One improvement would be to make sizes adjustable and bound to one another so the window could be dragged larger or smaller and still look good. Another improvement would be to provide some type of status message on the interface, especially for situations where solutions could not be calculated. A third improvement that would be to present a graph of the quadratic equation specified with the provided coefficients to visually indicate the x-intercepts and axis of symmetry.

JavaFX 2 makes it fairly straight-forward to write simple, user-friendly applications.

Original posting available at http://marxsoftware.blogspot.com/ (Inspired by Actual Events)

JavaFX 2.1: JavaFX 2's @DefaultProperty Annotation

2012-01-27T01:56:00-05:00

The JavaLobby/DZone syndicated version of my blog post Focus on JavaFX 2 FXML with NetBeans 7.1 was recently published and Mihai Dinca-panaitescu (author of DZone article Tuning Your Java VM) added an interesting and useful feedback comment. Specifically, he stated:
I needed to put <children> tag in JavaFx2Menus.fxml

before MenuBar tag.

otherwise an Exception is raised:

javafx.fxml.LoadException: javafx.scene.layout.VBox does not have a default property.

I'm glad that Mihai posted this response for several reasons. First, it will help anyone else reading my post to be aware of that issue. Second, it has allowed me to speculate on the cause of this message in this blog post.

My first thought at reading Mihai's comment was that perhaps the difference was that I was using JavaFX 2.1 (still beta) when I ran the example and perhaps Mihai was using production-ready JavaFX 2.0. Assuming this is the case, the next question was, "What changed in JavaFX 2.1 to make this example work without the children element? Feeling that I need to balance out recent cogitations on my blog with rampant speculation, I decided to do some of that speculation in this post. I speculate that JavaFX 2.1 has applied @DefaultProperty to more controls than in JavaFX 2.0 and that VBox was one of these which now has it applied.

The Javadoc description of the DefaultProperty annotation states, "Specifies a property to which child elements will be added or set when an explicit property is not given." The "Default Properties" section of the highly useful Introducing FXML adds:

A class may define a "default property" using the @DefaultProperty annotation defined in the javafx.fxml package. If present, the sub-element representing the default property can be omitted from the markup.

For example, if the Group class were to define a default property of "children", the <children> element would no longer be required.

My speculation was that JavaFX 2.1 had added @DefaultProperty annotation to the VBox (among others) control. Although the Javadoc for JavaFX 2.1's VBox does not show this annotation applied, the JavaFX 2.1 Javadoc documentation for its parent class, Pane, does indicate the presence of the annotation (and the @DefaultProperty annotation is itself marked @Inherited). The next image shows Pane JavaFX 2.0 and JavaFX 2.1 Javadoc versions side-by-side.

The circled portion of the JavaFX 2.1 API documentation for Pane shows that this control (and controls inheriting from it such as VBox) have children as the component's default property. This explains why children must be explicitly specified in JavaFX 2.0, but is optional for VBox in JavaFX 2.1.

The @DefaultProperty annotation has also been applied to the MenuBar control in JavaFX 2.1. Comparing Javadoc for MenuBar in JavaFX 2.0 to the Javadoc for MenuBar in 2.1 proves this. The next screen snapshot shows them side-by-side.

The circled portion of the JavaFX 2.1 API documentation shows that an annotation has been added in JavaFX 2.1 to the MenuBar class to specify that the default sub-element for MenuBar is now "menus" in JavaFX 2.1. Incidentally, Menu also has a new @DefaultProperty with "items" as its default property. With the @DefaultProperty annotation of MenuBar, I decided to try removing the <menus> elements from my FXML and this appeared to work fine, removing a couple lines of XML from my source FXML and allowing many lines to be less indented. It worked and I had a little more concise of an FXML representation of the same menus application layout.

The more widespread use of the @DefaultProperty annotation is a small, but very welcome addition to JavaFX 2.1. Although adding opening and closing "children" tags adds only two lines per use, it does increase the indentation as well for a well-formatted FXML file. FXML can be appealing because of its visual similarity to the presentation itself and having fewer "extra" lines for common cases can make it even more readable. Although the @DefaultProperty annotation itself was available in JavaFX 2.0, it's much more widely applied and can be more widely used in FXML when using JavaFX 2.1.

Original posting available at http://marxsoftware.blogspot.com/ (Inspired by Actual Events)

Is Programming Less Exciting Today?

2012-01-25T18:24:43-05:00

As discriminatory as this is going to sound, this one is for the old-timers. If you started programming after the turn of the milennium, I don’t know if you’re going to be able to follow the trend of this post—not out of any serious deficiency on your part, hardly that. But I think this is something only the old-timers are going to identify with. (And thus, do I alienate probably 80% of my readership, but so be it.)

Is it me, or is programming just less interesting today than it was two decades ago?

By all means, shake your smartphones and other mobile devices at me and say, “Dude, how can you say that?”, but in many ways programming for Android and iOS reminds me of programming for Windows and Mac OS two decades ago. HTML 5 and JavaScript remind me of ten years ago, the first time HTML and JavaScript came around. The discussions around programming languages remind me of the discussions around C++. The discussions around NoSQL remind me of the arguments both for and against relational databases. It all feels like we’ve been here before, with only the names having changed.

Don’t get me wrong—if any of you comment on the differences between HTML 5 now and HTML 3.2 then, or the degree of the various browser companies agreeing to the standard today against the “browser wars” of a decade ago, I’ll agree with you. This isn’t so much of a rational and logical discussion as it is an emotive and intuitive one. It just feels similar.

To be honest, I get this sense that across the entire industry right now, there’s a sort of malaise, a general sort of “Bah, nothing really all that new is going on anymore”. NoSQL is re-introducing storage ideas that had been around before but were discarded (perhaps injudiciously and too quickly) in favor of the relational model. Functional languages have obviously been in place since the 50’s (in Lisp). And so on.

More importantly, look at the Java community: what truly innovative ideas have emerged here in the last five years? Every new open-source project or commercial endeavor either seems to be a refinement of an idea before it (how many different times are we going to create a new Web framework, guys?) or an attempt to leverage an idea coming from somewhere else (be it from .NET or from Ruby or from JavaScript or….). With the upcoming .NET 4.5 release and Windows 8, Microsoft is holding out very little “new and exciting” bits for the community to invest emotionally in: we hear about “async” in C# 5 (something that F# has had already, thank you), and of course there is WinRT (another platform or virtual machine… sort of), and… well, honestly, didn’t we just do this a decade ago? Where is the WCFs, the WPFs, the Silverlights, the things that would get us fired up? Hell, even a new approach to data access might stir some excitement. Node.js feels like an attempt to reinvent the app server, but if you look back far enough you see that the app server itself was reinvented once (in the Java world) in Spring and other lightweight frameworks, and before that by people who actually thought to write their own web servers in straight Java. (And, for the record, the whole event-driven I/O thing is something that’s been done in both Java and .NET a long time before now.)

And as much as this is going to probably just throw fat on the fire, all the excitement around JavaScript as a language reminds me of the excitement about Ruby as a language. Does nobody remember that Sun did this once already, with Phobos? Or that Netscape did this with LiveScript? JavaScript on the server end is not new, folks. It’s just new to the people who’d never seen it before.

In years past, there has always seemed to be something deeper, something more exciting and more innovative that drives the industry in strange ways. Artificial Intelligence was one such thing: the search to try and bring computers to a state of human-like sentience drove a lot of interesting ideas and concepts forward, but over the last decade or two, AI seems to have lost almost all of its luster and momentum. User interfaces—specifically, GUIs—were another force for a while, until GUIs got to the point where they were so common and so deeply rooted in their chosen pasts (the single-button of the Mac, the menubar-per-window of Windows, etc) that they left themselves so little room for maneuver. At least this is one area where Microsoft is (maybe) putting the fatted sacred cow to the butcher’s knife, with their Metro UI moves in Windows 8… but only up to a point.

Maybe I’m just old and tired and should hang up my keyboard and go take up farming, then go retire to my front porch’s rocking chair and practice my Hey you kids! Getoffamylawn! or something. But before you dismiss me entirely, do me a favor and tell me: what gets you excited these days? If you’ve been programming for twenty years, what about the industry today gets your blood moving and your mind sharpened?

Enterprise consulting, mentoring or instruction. Java, C++, .NET or XML services. 1-day or multi-day workshops available. Contact me for details.

Recent Java-Related Posts Worthy of Special Notice

2012-01-23T09:59:00-05:00

In this blog post, I reference and summarize recent Java-related posts that I have found to be particularly interesting and well worth the time spent reading them.

JDK 8 and Unsigned Integer Arithmetic

Joe Darcy's post Unsigned Integer Arithmetic API now in JDK 8 states that "initial API support for unsigned integer arithmetic" has been pushed into Java 8. Darcy explains that this is implemented largely via static methods on classes java.lang.Integer and java.lang.Long.

Although Darcy's post is not very long, he manages to talk about the specific unsigned arithmetic functionality that is supported (conversion of Strings to unsigned integers, conversion of unsigned integers to Strings, comparing unsigned values, and calculation of unsigned division and remainder) as well as why it was decided to not implement new types such as UnsignedInt. A consequence of not implementing specific unsigned types is that it is easier to inadvertently mix signed and unsigned values and Darcy suggests some ideas built on naming conventions or new built-in annotations to address this concern.

Versions, Code Names, and Features of Java Releases

Speaking of new versions of Java, another Joe (Joseph Kulandai) started 2012 off with a nice post on Java Versions, Features and History. In this post, Kulandai lists the versions of Java in backwards chronological order (Java SE 7 listed first and JDK Version 1.0 at the bottom of the post). Under each major version of Java, Kulandai provides bullet lists of new features in that release and provides the code name of each release.

Java 8 Status Updates

Continuing the theme of Java 8 updates, another post of interest is Johannes Thönes's Java 8 Status Updates. This post looks at the status of "the two big new language features of the upcoming Java SE 8" (Project Lambda and Project Jigsaw).

Java 7 Concurrency

Niklas Schlimm has written two recent posts on using Java 7 concurrency features. He introduces "a flexible thread synchronization mechanism called Phaser" in the post Java 7: Understanding the Phaser and looks in detail at ThreadLocalRandom in the post Java 7: How to write really fast Java code.

OutOfMemoryError: Using Command-line Tools

Vladimir Šor's Solving OutOfMemoryError (part 5) - JDK Tools is, as its title suggests, the fifth in a series on Java memory issues available on that blog ("Solving OutOfMemoryError blog post series"). This post provides a brief summary description and usage information for three command-line tools bundled with the Oracle Java SDK (jps, jmap, and jhat).

The previous entries in this series are written by Nikita Salnikov-Tarnovski: Solving OutOfMemoryError (part 1) - story of a developer, Solving OutOfMemoryError (part 2)- why didn’t operations solve it?, Solving OutOfMemoryError (part 3) - where do you start?, and Solving OutOfMemoryError (part 4) - memory profilers.

Debugging the JVM

Attila Balazs's post Debugging the JVM provides interesting insight on something that we don't seem to have to do as often these days as in the earlier days of the JVM, but could be a very useful resource on the occasions this does occur. Balazs talks about "crashing the JVM itself" via null thread group name and then goes onto explain using gdb in Linux to debug the issue with the JVM.

Groovy Introduction

Alex's post provides an introduction to Groovy including coverage of XML with Groovy, regular expressions with Groovy, and SQL with Groovy.

A New Java Blog With Two JavaFX Posts

I've posted before on why more developers should write blogs. One of the reasons is the variety of opinions and ideas that are generated that way. With this in mind, I have been interested to read the first two posts of new blog Experiments with Java. Both of the blog's current posts have been written in January 2012 and are on JavaFX 2. The posts are Percent Width for TableColumn in JavaFX 2.x TableView and Sliding in JavaFX (It’s all about clipping).

Conclusion

There have been several good Java-related posts in recent weeks and a sample of them are highlighted in this post.

REST Pagination in Spring

2012-01-18T11:03:25-05:00

This is the seventh of a series of articles about setting up a secure RESTful Web Service using Spring 3.1 and Spring Security 3.1 with Java based configuration. This article will focus on the implementation of pagination in a RESTful web service.

The REST with Spring series:

Part 1 – Bootstrapping a web application with Spring 3.1 and Java based Configuration
Part 2 – Building a RESTful Web Service with Spring 3.1 and Java based Configuration
Part 3 – Securing a RESTful Web Service with Spring Security 3.1
Part 4 – RESTful Web Service Discoverability
Part 5 – REST Service Discoverability with Spring
Part 6 – Basic and Digest authentication for a RESTful Service with Spring Security 3.1

Page as resource vs Page as representation

The first question when designing pagination in the context of a RESTful architecture is whether to consider the page an actual resource or just a representation of resources. Treating the page itself as a resource introduces a host of problems such as no longer being able to uniquely identify resources between calls. This, coupled with the fact that outside the RESTful context, the page cannot be considered a proper entity, but a holder that is constructed when needed makes the choice straightforward: the page is part of the representation.

The next question in the pagination design in the context of REST is where to include the paging information:

in the URI path: /foo/page/1
the URI query: /foo?page=1

Keeping in mind that a page is not a resource, encoding the page information in the URI is no longer an option.

Page information in the URI query

Encoding paging information in the URI query is the standard way to solve this issue in a RESTful service. This approach does however have one downside – it cuts into the query space for actual queries:

/foo?page=1&size=10

The Controller

Now, for the implementation – the Spring MVC Controller for pagination is straightforward:

The two query parameters are defined in the request mapping and injected into the controller method via @RequestParam; the HTTP response and the Spring UriComponentsBuilder are injected in the Controller method to be included in the event, as both will be needed to implement discoverability.

Discoverability for REST pagination

Withing the scope of pagination, satisfying the HATEOAS constraint of REST means enabling the client of the API to discover the next and previous pages based on the current page in the navigation. For this purpose, the Link HTTP header will be used, coupled with the official “next“, “prev“, “first” and “last” link relation types.

In REST, Discoverability is a cross cutting concern, applicable not only to specific operations but to types of operations. For example, each time a Resource is created, the URI of that resource should be discoverable by the client. Since this requirement is relevant for the creation of ANY Resource, it should be dealt with separately and decoupled from the main Controller flow.

With Spring, this decoupling is achieved with events, as was thoroughly discussed in the previous article focusing on Discoverability of a RESTful service. In the case of pagination, the event – PaginatedResultsRetrievedEvent – was fired in the Controller, and discoverability is achieved in a listener for this event:

In short, the listener logic checks if the navigation allows for a next, previous, first and last pages and, if it does, adds the relevant URIs to the Link HTTP Header. It also makes sure that the link relation type is the correct one – “next”, “prev”, “first” and “last”. This is the single responsibility of the listener (the full code here).

Test Driving Pagination

Both the main logic of pagination and discoverability should be extensively covered by small, focused integration tests; as in the previous article, the rest-assured library is used to consume the REST service and to verify the results.

These are a few example of pagination integration tests; for a full test suite, check out the github project (link at the end of the article):

Test Driving Pagination Discoverability

Testing Discoverability of Pagination is relatively straightforward, although there is a lot of ground to cover. The tests are focused on the position of the current page in navigation and the different URIs that should be discoverable from each position:

These are just a few examples of integration tests consuming the RESTful service.

Getting All Resources

On the same topic of pagination and discoverability, the choice must be made if a client is allowed to retrieve all the Resources in the system at once, or if the client MUST ask for them paginated.

If the choice is made that the client cannot retrieve all Resources with a single request, and pagination is not optional but required, then several options are available for the response to a get all request.

One option is to return a 404 (Not Found) and use the Link header to make the first page discoverable:

Link=; rel=”first“, ; rel=”last“

Another option is to return redirect – 303 (See Other) – to the first page of the pagination.

A third option is to return a 405 (Method Not Allowed) for the GET request.

REST Paginag with Range HTTP headers

A relatively different way of doing pagination is to work with the HTTP Range headers – Range, Content-Range, If-Range, Accept-Ranges – and HTTP status codes – 206 (Partial Content), 413 (Request Entity Too Large), 416 (Requested Range Not Satisfiable). One view on this approach is that the HTTP Range extensions were not intended for pagination, and that they should be managed by the Server, not by the Application.

Implementing pagination based on the HTTP Range header extensions is nevertheless technically possible, although not nearly as common as the implementation discussed in this article.

Conclusion

This article covered the implementation of Pagination in a RESTful service with Spring, discussing how to implement and test Discoverability. For a full implementation of pagination, check out the github project.

If you read this far, you should follow me on twitter here.

Book Review: JavaFX 2.0: Introduction by Example

2012-01-16T21:49:00-05:00

Although Oracle's changes to JavaFX at JavaOne 2010 and JavaOne 2011 have converted me from a skeptic to a believer when it comes to JavaFX, the shift in JavaFX vision has not been without its downsides. In particular, the JavaFX book market has been tricky because nearly all available JavaFX books have been about version 1.x. In this post, I review the only book that I'm aware of at time of this writing that is completely focused on JavaFX 2.0: Carl Dea's JavaFX 2.0: Introduction by Example.

I'll start my review by stating the most important observation about JavaFX 2.0: Introduction by Example: it provided me exactly what I was looking for exactly when I needed it. There are some attributes of the book that might be considered negative by some readers that I felt were positives in my use of the book. I'll attempt in this post to articulate the finer points of these attributes so that perspective readers can make up their own minds.

JavaFX 2.0 Introduction by Example does exactly what the title implies: it introduces JavaFX 2.0 via numerous and varied examples. This code-heavy book is roughly similar to a "recipes" or "cookbook" with individual item covered (AKA a "recipe" in a recipes or cookbook) featuring subsections on the problem to be solved, the solution or solutions to that problem, and how those solutions work. Like the best recipes-oriented or cookbook-oriented software development books, this one is constructed so that Chapter 1 ("JavaFX Fundamentals") covers some of the basics of JavaFX early on. In other words, the reader is not dropped into JavaFX without first getting some examples of how to write and deploy basic "Hello World" style JavaFX applications.

Although JavaFX 2.0: Introduction by Example does provide introductory examples early on, I really appreciated the author not spending significant time discussing esoteric features of the language or delving into the history of JavaFX in tedious detail or providing pages worth of explanation on why JavaFX is the greatest thing since sliced bread. I'm usually in a hurry and I have come to resent books wasting my time on such things and this book doesn't do that. In this case, I was already familiar with these aspects of JavaFX (at least its history and why I might be interested in learning more about it), so I was especially appreciative of Dea not wasting paper and my time on that subject. In the book's concise "Introduction," Dea covers in a page and a half some advantages of JavaFX and "some history" of JavaFX along with a simple table articulating features of each release of JavaFX. It's a thing of beauty to be able to read all of this in less than two pages and in the introduction!

Dea covers some more background on JavaFX in the first chapter, but again limits that discussion to a single page. This page is more detailed than the introductory section and is a nice, brief segue into the technical meat of the book. This first page also contains the sentences that I think best sum up the value of this book:

Although this book doesn't go through an exhaustive study of all of JavaFX 2.0's capabilities, you will find common use cases that can help you build richer applications. Hopefully, these recipes can lead you in the right direction by providing practical and real-world examples.

This is exactly what JavaFX 2.0: Introduction by Example has done for me. It has provided me with a fast start into the world of JavaFX. Although I have since used several aspects of JavaFX not covered in this book, the book gave me the start that I needed and I was able to use JavaFX documentation for the areas not covered in this book.

JavaFX 2.0: Introduction by Example gets to the point quickly. Besides common things like the very brief introduction and the index, the book contains four chapters (32 "recipes") spanning 174 pages of text, images, and code. Dea doesn't even waste time with a conclusion, but ends the book with "recipe" 4.5 ("Displaying Content from the Database"). Although some readers may need a conclusion to bring closure to their reading experience, I usually little value in this for me as a reader and I didn't miss it here. I typically don't read these types of book cover-to-cover anyway (instead focusing on sections or recipes I am most interested in), so the conclusion is often unnecessary. Lack of a conclusion is another example of how Dea's book focuses most on what I want: the technical meat.

The four chapters in JavaFX 2.0: Introduction by Example are "JavaFX Fundamentals," "Graphics with JavaFX," "Media with JavaFX," and "JavaFX on the Web." The first chapter was most useful for quickly immersing myself into the basics of JavaFX and how to apply it. The examples in that chapter tend to be simple and easy to follow. The examples in the other three chapters tend to be more sophisticated because the functionality being covered tends to be more sophisticated. There are numerous lengthy code listings in the book. Although code listings may not be the easiest to read, I like to see actual code in any book on a language. Dea typically follows each code sample with descriptive text on any new feature shown in the code sample that had not been covered previously in the book. The code samples can be downloaded from Apress's site. The book also features numerous screen snapshots, which I consider a must for a book focused on user interfaces.

The concise and introductory approach of JavaFX 2.0: Introduction by Example that appealed to me may not appeal to everyone. This book, as advertised in the above cited quotation from the first chapter, is intended to be introductory (hence the title) and not to be exhaustive. Some topics that I have not seen covered in this book include subjects such as FXML, the JavaFX charting functionality, GroovyFX, and ScalaFX. Deployment is only lightly covered (and mostly via NetBeans), but Dea does reference Deploying JavaFX Applications for more details on JavaFX deployment. All of these areas, however, are fairly approachable given the JavaFX basics provided in this book. Dea recommends that readers reference forthcoming (mid-February 2012, Apress) Pro JavaFX 2.0 Platform for an "invaluable resource" that provides "further insight into JavaFX."

Although a small number of the items/recipes covered in JavaFX 2.0: Introduction by Example are based on and assume use of NetBeans, most examples in no way specific to any tool or IDE. Rather, most examples provide "raw" code that can be used in any IDE or favorite text editor. Indeed, many of the examples can be compiled with the javac compiler and executed with the java application launcher. I appreciated that in at least one NetBeans-oriented recipe, Dea took the page or two necessary to provide the code listing for code generated by NetBeans. This is invaluable for those who do not use NetBeans or who want to understand the code itself rather than simply understanding how to use NetBeans to generate the code.

JavaFX 2.0: Introduction by Example was exactly what I needed for an efficient and effective start to my investigation of JavaFX. It may not provide quite the level of soft introduction someone completely unfamiliar with JavaFX might want (especially if that person's basic Java skills are a little rusty) and it isn't an "exhaustive" JavaFX 2.0 reference either. It falls in between these extremes and seems to be a fast start example-based introduction to JavaFX for those who want to get into the core of JavaFX as quickly as possible. That's what I wanted when I purchased this book and I was happy to find out that's exactly what this book provides. It's completely JavaFX 2.x-oriented and there is no sign of deprecated JavaFX Script in any of the code examples.

Focus on JavaFX 2 FXML with NetBeans 7.1

2012-01-16T10:06:00-05:00

In October 2011, I used the post Hello JavaFX 2.0: Introduction by NetBeans 7.1 beta to look at using NetBeans 7.1 beta to build a simple Hello, World style of JavaFX 2.0 application. In this post, I look at using NetBeans 7.1 (no longer in beta) to build a slightly more sophisticated JavaFX 2 application that makes heavy use of FXML.

Most of my posts on JavaFX 2 up to this point have emphasized the "pure Java" nature of JavaFX 2. The examples in these posts have been written in standard Java using JavaFX 2 APIs directly from the Java source code. These examples have also been built with the javac compiler and executed with the java application launcher. In this post, I take one of those examples [(Pure Java) JavaFX 2.0 Menus] and "port" it to use FXML for presentation layout.

For convenience, I include the entire Java listing for the "pure Java" implementation of the JavaFX 2 menus demonstration.

JavaFX 2.0 Menus Demonstration (Pure Java)

package dustin.examples;

import static java.lang.System.out;

import javafx.application.Application;
import javafx.beans.property.ReadOnlyDoubleProperty;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyCodeCombination;
import javafx.scene.input.KeyCombination;
import javafx.scene.paint.Color;
import javafx.stage.Stage;

/**
 * Example of creating menus in JavaFX.
 * 
 * @author Dustin
 */
public class JavaFxMenus extends Application
{
   /**
    * Build menu bar with included menus for this demonstration.
    * 
    * @param menuWidthProperty Width to be bound to menu bar width.
    * @return Menu Bar with menus included.
    */
   private MenuBar buildMenuBarWithMenus(final ReadOnlyDoubleProperty menuWidthProperty)
   {
      final MenuBar menuBar = new MenuBar();

      // Prepare left-most 'File' drop-down menu
      final Menu fileMenu = new Menu("File");
      fileMenu.getItems().add(new MenuItem("New"));
      fileMenu.getItems().add(new MenuItem("Open"));
      fileMenu.getItems().add(new MenuItem("Save"));
      fileMenu.getItems().add(new MenuItem("Save As"));
      fileMenu.getItems().add(new SeparatorMenuItem());
      fileMenu.getItems().add(new MenuItem("Exit"));
      menuBar.getMenus().add(fileMenu);

      // Prepare 'Examples' drop-down menu
      final Menu examplesMenu = new Menu("JavaFX 2.0 Examples");
      examplesMenu.getItems().add(new MenuItem("Text Example"));
      examplesMenu.getItems().add(new MenuItem("Objects Example"));
      examplesMenu.getItems().add(new MenuItem("Animation Example"));
      menuBar.getMenus().add(examplesMenu);

      // Prepare 'Help' drop-down menu
      final Menu helpMenu = new Menu("Help");
      final MenuItem searchMenuItem = new MenuItem("Search");
      searchMenuItem.setDisable(true);
      helpMenu.getItems().add(searchMenuItem);
      final MenuItem onlineManualMenuItem = new MenuItem("Online Manual");
      onlineManualMenuItem.setVisible(false);
      helpMenu.getItems().add(onlineManualMenuItem);
      helpMenu.getItems().add(new SeparatorMenuItem());
      final MenuItem aboutMenuItem =
         MenuItemBuilder.create()
                        .text("About")
                        .onAction(
                            new EventHandler()
                            {
                               @Override public void handle(ActionEvent e)
                               {
                                  out.println("You clicked on About!");
                               }
                            })
                        .accelerator(
                            new KeyCodeCombination(
                               KeyCode.A, KeyCombination.CONTROL_DOWN))
                        .build();             
      helpMenu.getItems().add(aboutMenuItem);
      menuBar.getMenus().add(helpMenu);

      // bind width of menu bar to width of associated stage
      menuBar.prefWidthProperty().bind(menuWidthProperty);

      return menuBar;
   }

   /**
    * Start of JavaFX application demonstrating menu support.
    * 
    * @param stage Primary stage.
    */
   @Override
   public void start(final Stage stage)
   {
      stage.setTitle("Creating Menus with JavaFX 2.0");
      final Group rootGroup = new Group();
      final Scene scene = new Scene(rootGroup, 800, 400, Color.WHEAT);
      final MenuBar menuBar = buildMenuBarWithMenus(stage.widthProperty());
      rootGroup.getChildren().add(menuBar);
      stage.setScene(scene);
      stage.show();
   }

   /**
    * Main executable function for running examples.
    * 
    * @param arguments Command-line arguments: none expected.
    */
   public static void main(final String[] arguments)
   {
      Application.launch(arguments);
   }
}

Besides adding the ability to write JavaFX applications in "pure Java" as implemented in the last code listing, JavaFX 2 also provides FXML, an XML grammar for specifying a JavaFX application's layout. This approach is very similar to that provided by Flex's MXML, by OpenLaszlo's LZX, and by Mozilla's XUL. This approach works well with JavaFX's hierarchical Scene Graph.

The ported FXML code is shown next. It is easy to see the presentation structure in this XML.

JavaFx2Menus.fxml

The important portion of this simple FXML can be viewed on a single page within NetBeans 7.1 as shown in the next screen snapshot.

Besides the conciseness of the FXML and the aesthetically pleasing hierarchical presentation, the FXML also should look familiar to anyone who has worked with Flex, OpenLaszlo, or XUL. Most of the presentation structure is easily identified in the FXML document. This example includes an onAction handler that responds to the "About" menu item and there is an onKeyPressed action associated with the menu bar as well (I could not figure out a way to easily associate this handler with the menu item itself). Both of these actions reference names that start with the # symbol. The names following the # are names of methods on the controller class (defined by the fx:controller attribute of the VBox as the class named dustin.examples.MenuController). The source for this controller class is shown next.

MenuController.java

package dustin.examples;

import static java.lang.System.out;
import java.net.URL;
import java.util.ResourceBundle;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.control.MenuBar;
import javafx.scene.input.InputEvent;
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyEvent;

/**
 * Controller class for JavaFX 2 Menus with FXML post and demonstration.
 * 
 * @author Dustin
 */
public class MenuController implements Initializable
{
   @FXML
   private MenuBar menuBar;

   /**
    * Handle action related to "About" menu item.
    * 
    * @param event Event on "About" menu item.
    */
   @FXML
   private void handleAboutAction(final ActionEvent event)
   {
      provideAboutFunctionality();
   }

   /**
    * Handle action related to input (in this case specifically only responds to
    * keyboard event CTRL-A).
    * 
    * @param event Input event.
    */
   @FXML
   private void handleKeyInput(final InputEvent event)
   {
      if (event instanceof KeyEvent)
      {
         final KeyEvent keyEvent = (KeyEvent) event;
         if (keyEvent.isControlDown() && keyEvent.getCode() == KeyCode.A)
         {
            provideAboutFunctionality();
         }
      }
   }

   /**
    * Perform functionality associated with "About" menu selection or CTRL-A.
    */
   private void provideAboutFunctionality()
   {
      out.println("You clicked on About!");      
   }

   @Override
   public void initialize(final URL url, final ResourceBundle rb)
   {
      menuBar.setFocusTraversable(true);
   }   
}

The above code from the controller class includes the two methods referenced as action handlers in the FXML with the # prefixes. These two methods are private and normally would not be visible to the FXML loader, but the use of the annotation @FXML gets around this problem. The menuBar attribute is also private but visible to the FXML loader thanks to its own @FXML annotation.

To get the application to respond to CTRL-A before any initial access of the menu bar, I found that I needed to have a reference to the menu bar in the controller and call setFocusTraversable(true) on that instance. Without doing that, the CTRL-A would only be responded to if I had first clicked on the menu bar once. The hook from the FXML to this attribute in the controller is the fx:id attribute used in the FXML. That attribute references the name "menuBar", which is (not coincidentally) also the name of the attribute in the controller class. In other words, the attribute fx:id="menuBar" ties the XML element that attribute is on in the FXML to the attribute with the same name in the controller.

I did not show much in this post specific to NetBeans 7.1, but it is worth noting that I had all the pertinent files created in a new project using NetBeans 7.1's New Project wizard and selecting a JavaFX FXML Application as the project type. This created a basic FXML file, a basic controller file, and a main class for loading the FXML and running the application. I modified these to the examples above for the FXML and for the controller class. The modified class that loads the FXML and starts the JavaFX application is shown next. (There's not a lot to it!)

JavaFxMenusWithFxmlDemo.java

package dustin.examples;

import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;

/**
 * Simple example of JavaFX 2 FXML used to demonstrate JavaFX 2 menus. This is a
 * "port" of the example featured using "pure Java" (no FXML) in the post
 * "(Pure Java) JavaFX 2.0 Menus"
 * (http://marxsoftware.blogspot.com/2011/12/pure-java-javafx-20-menus.html).
 * 
 * @author Dustin
 */
public class JavaFxMenusWithFxmlDemo extends Application
{
   /**
    * Main function for running this application.
    * 
    * @param arguments Command-line arguments: none expected.
    */
   public static void main(String[] arguments)
   {
      Application.launch(JavaFxMenusWithFxmlDemo.class, arguments);
   }

   /**
    * Overridden Application.start(Stage) method.
    * 
    * @param stage Primary stage.
    * @throws Exception JavaFX application exception.
    */
   @Override
   public void start(final Stage stage) throws Exception
   {
      final Parent fxmlRoot = FXMLLoader.load(getClass().getResource("JavaFx2Menus.fxml"));
      stage.setScene(new Scene(fxmlRoot));
      stage.show();
   }
}

I won't show the output here because it's essentially what the "pure Java" version produced, which is shown in my post on that approach. Besides generating the files that I adapted for my application, NetBeans 7.1's new project wizard for a JavaFX FXML application also created a project that automatically packages up what I need for my JavaFX application in an executable JAR. The contents of the JAR in this case are shown in the next screen snapshot.

The trickiest part about using FXML is the relatively less available documentation. The pure Java APIs have the strong Javadoc API documentation, but I know of no such thing for FXML (including no documentation or schema for the namespace http://javafx.com/fxml). There are some great resources of FXML such as Getting Started with FXML and Introduction to FXML. Perhaps the best document for figuring out what elements and attributes FXML provides is Introducing FXML: A Markup Language for JavaFX, which explains the "mapping" of JavaFX standard Java API classes to JavaFX FXML elements and attributes.

FXML appears to be a fairly attractive approach for building a JavaFX application because it nicely separates presentation (FXML) from business logic (controller class and classes that would be called by controller methods). This can make it easier to visually see the GUI layout in the hierarchical XML and keep the logic and presentation from cluttering each other.

Code Forensics

2012-01-16T09:13:00-05:00

How do you know if using code metrics really does help to produce code with fewer bugs.
I am convinced they do, but how can I possibly prove it?

All projects have historic data. This is usually stored in your bug tracking and source code control tools.
We can use the data stored in these systems to perform ‘code forensics.’
We use the historic data from real issues to see if they could have been avoided.

This can all be done without affecting any of your existing code or adding any risk to your project.
Surely that’s a useful Software Engineering technique?

Disclaimer

Firstly I realise that most bugs you find in a standard project are not caused by code quality – it’s probably only a small percentage. However the ones that exist are avoidable.
It is these avoidable quality issues that I want to concentrate on. I want to be able to determine when exceeding a metric threshold is likely to result in a problem
It’s possible that if enough code forensics are run on my individual code base, I may be able to come up with some numbers that are useful to me in the future.
In the long term it may be possible for someone to do a large study and come up with better guidelines.

Process

The process is quite straightforward.

1. Query your bug tracking tool for all the issues that required a code fix.
2. Assess the defects.
3. Identify the code.
4. Get the root cause.

Query your bug tracking tool.

First thing you need to do is to identify all your recent bugs, let’s say for the last month.
Do a simple query to bring back all of the bugs during that period.This should be easy - otherwise you’re using the wrong tool!
Now you have a full list of all of the defects that you are potentially interested in

Assess the defects.

You now need to go through each of the bugs and assess whether the issue really was a code issue.
Other things it might be include.

• A requirements issue.
• An issue with the deployment environment.
• Configuration Issues

What you are left with is a list of issues that were really caused because of bad code.

Identify the problematic code.

You now need to map your list of issues back to the relevant source.
You will not be able to do this unless you have been disciplined with your check in comments. In most places I have worked, when checking in a bug fix you always start it with a reference to the problem it fixes.
Assuming you have been commenting your commits with the reference, you can do a simple query to see which code was affected. This can be done in fisheye, tortoise etc to get the required code

Get to the root cause.

Finally you have something to look at, so what do you do with it? Well first you have to understand how the fix works and decide if it was a code quality issue. Perhaps the issue was a simple error rather than something a metric would have caught.
However you might open the code and find like this. The average complexity in our system is 10. This piece of code has a complexity of 106!
This was an accident waiting to happen!

Clearly the bug would have been more likely to have been caught, had we failed the build because the code failed to meet expected quality standards. This is a potentially avoidable error.

Another Angle.

Another way to try and establish a link between poor code quality and defects is to take advantage of something such as the Sonar hotspot view to see the most complex classes in you system.

You can then work backwards and examine the history of those files to see if those classes are causing issues in your codebase.
The trouble is that it is not that simple. High complexity files, which are used infrequently, are less likely to cause you trouble than those which are more frequently used, but of a lower complexity.

Automating the process.

For this to be any use it probably needs to be automated so that a large sample of data can be examined. Some tools already make this link between defects and the related fix source code.
The next step is to pull that data back and run your metrics analysis on the files.

Summary

None of this is conclusive, however I still think it's a useful technique.

What it is most likely to prove is that you have had past problems which you could have avoided with metrics. It should also give you an idea of which metrics to use.

It's likely also to show that most problems are not caused by poor code quality, but other factors instead.

Unit Test Code Coverage With Jacoco

2012-01-16T06:09:00-05:00

Insert title hereIt’s easy to collect unit test code coverage because all of the common tools are geared up for it.
This article will explain how you can add unit test coverage to your Maven application in 10 minutes.
We will use the excellent Jacoco code coverage library to show how easy it is.

Examples

All of the examples come from this article.
http://johndobie.blogspot.com/2011/11/test-doubles-with-mockito.html

You can check them out from here

svn co
https://designbycontract.googlecode.com/svn/trunk/examples/testing/test-...

With Maven 3 installed, you can run them with this command.

mvn clean package

What is Jacoco

Jacoco is a free code coverage library for Java. http://www.eclemma.org/jacoco/

I use it because it is very simple to add to all types of build including ANT and Maven, and it is also very simple to add to Java containers or a standalone JVM.

How Does it Work?

Jacoco uses the standard JVM Tool Interface. http://java.sun.com/developer/technicalArticles/J2SE/jvm_ti/
In simple terms you attach a Jacoco agent to a JVM when it starts. It was introduced in JDK 5 for monitoring and profiling JVMs and being able to dynamically modify Java classes as they're being loaded.
Whenever a class is loaded Jacoco can instrument the class so it can see when the class is called and what lines are called. That’s how it builds up the coverage statistics. This is all done on the fly.
By default the results file is created when the JVM terminates.
You can also run the agent in server mode which allows you to trigger a dump of the results.

How do you attach the agent to the JVM?

This is a very simple process. You must specify where the jacoco jar is located and then you pass some parameters to define how the agent is to run.

-javaagent:[yourpath/]jacocoagent.jar=[option1]=[value1],[option2]=[value2]

A typical run might look like this

-javaagent:jacoco.jar=destfile=${sonar.jacoco.itReportPath},includes=com.dbc.*

A full reference is found here.http://www.eclemma.org/jacoco/trunk/doc/agent.html

Jacoco Support For Maven

The docs for the maven plugin are defined here. http://www.eclemma.org/jacoco/trunk/doc/maven.html
First we need to add the plugin itself.


  org.jacoco
  jacoco-maven-plugin
  0.5.5.201112152213

We can then define where the jacoco reports are output.


  ${basedir}/target/coverage-reports/jacoco-unit.exec
  ${basedir}/target/coverage-reports/jacoco-unit.exec

Finally we need to define the following 2 executions to make the agent run before the tests are run and also to make sure that the jacoco report task is run when package is executed.


  
    jacoco-initialize
    
      prepare-agent
    
  
  
    jacoco-site
    package
    
      report

All this together is shown here



 
  org.jacoco
  jacoco-maven-plugin
  0.5.5.201112152213
  
   ${basedir}/target/coverage-reports/jacoco-unit.exec
   ${basedir}/target/coverage-reports/jacoco-unit.exec
  
  
   
    jacoco-initialize
    
     prepare-agent
    
   
   
    jacoco-site
    package
    
     report
    
   
  
 
 
  org.apache.maven.plugins
  maven-compiler-plugin
  
   1.5
   1.5

To run the examples execute the following command.

mvn clean package

Results.

The results are published in /target/site/jacoco.

Revealing Project Naughtiness with Tattletale

2012-01-12T23:46:00-05:00

Tattletale is a highly useful development tool that not only has a catchy name, but also has a clever slogan: "Betraying your project's naughty little secrets." Tattletale scours JAR files to find various naught little secrets about dependencies, multiple versions, extraneous versions of classes, JARs in multiple locations, and so forth. It is a simple tool that can be run from the command-line to generate simple HTML reports of multiple characteristics about JARs and classes.

To demonstrate Tattletale, I will execute it against a Spring Framework 2.5.6 installation. It is simple to run Tattletale and this is demonstrated in the next screen snapshot.

The tattletale.jar is an executable JAR and so is run with java -jar tattletale.jar. The first argument passed to it is the directory to be recursively searched (Spring 2.5.6 distribution in this case) and the second argument is the directory to which the HTML reports should be written (spring-output in this example). The directory listing of the spring-output directory is shown next.

As the two previous snapshots indicate, it is very straightforward to run Tattletale against a desired directory. A web browser can be used to open the index.html page as the starting page. This is shown in the next screen snapshot.

Only a subset of the available reports are shown in the above snapshot. Clicking on links brings up the individual reports. I show portions of select reports (circular dependencies, class locations, multiple copies of JARs, transitive dependencies, and transitive dependents) next.

Tattletale is so easy to use, very little documentation is necessary. However, there is a slide presentation and a User's Guide with introductory information. The 32-page User Guide covers running Tattletale (similar to this post) along with providing details on how to configure the tool via jboss-tattletale.properties and providing an overview of the many reports that Tattletale provides about one's project.

To address and correct a project's naughtiest little secrets, one must know what they are. Tattletale is an easy-to-use tool that exposes these naughty secrets so that they can be addressed.