IT Tips and Memory Joggers!

Tuesday, 11 June 2013

Spring AOP Error

AOP can be used in spring to weave aspects. This is commonly used for database transactions using the @Transactional annotation. However, this means that spring has to make proxy objects for beans which use these annotations. This can lead to the error,

Error Cannot convert value of type [$Proxy...] to required type

Basically what is happening is that spring is creating the proxy objects from the corresponding interfaces but in the spring context an actual implementation of the interface is required as a property by a bean. In this case spring can't guarantee that the proxy implementation will satisfy the beans requirement and this error is thrown.

Solution 1

The first and best solution is to correct the receiving bean to take an interface instead of an implementation. Most beans should take interfaces so that the implementation can easily be swapped in the spring configuration. Once the beans are wired purely with interfaces this problem with go away.

Solution 2

Where solution 1 above isn't an option it is possible to tell spring to proxy classes and not interfaces. This is done with this spring command

<aop:config proxy-target-class="true"/>

This requires the correct namespace definitions at the top of the spring context xml file such as

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:aop="http://www.springframework.org/schema/aop"

xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd

http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

Tuesday, 4 June 2013

JMS, Spring & MQ

Here is a sample configuration for using MQ with JMS and Spring.

Firstly the MQ library is needed. This can be found in a number of places but if you are using eclipse you can install the Websphere Liberty Profile (8.5.next) from the market place. The required MQ library is available in

<liberty_install_dir>/lib/com.ibm.ws.messaging.jms.wmq_1.0.jar

Maven Dependencies

The MQ jar can be used as a maven dependency using the System scope using the install directory above.

<dependency>
<groupId>com.ibm.ws.messaging.jms</groupId>
      <artifactId>wmq</artifactId>
      <version>1.0</version>
      <scope>system</scope>
      <systemPath><liberty_install_dir>/lib/com.ibm.ws.messaging.jms.wmq_1.0.jar</systemPath>
</dependency>

The JMS interfaces are all that is necessary if installing into an application server / container.

<dependency>
<groupId>javax</groupId>
  <artifactId>javaee-api</artifactId>
  <version>6.0</version>
  <scope>provided</scope>
</dependency>

Note that this is a provided dependency because the implementation of these interfaces are provided by the container. If the app is standalone and isn't deployed into a container then concrete implementations of the JMS spec needs to be provided. One example is the geronimo library,

<dependency>
<groupId>org.apache.geronimo.specs</groupId>
<artifactId>geronimo-jms_1.1_spec</artifactId>
<version>1.1.1</version>
  <scope>compile</scope>

</dependency>

And finally the spring jms jar is also required,

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jms</artifactId>
<version>3.1.1.RELEASE</version>
<scope>compile</scope>
</dependency>

(Note: you'll need to add a spring property place holder for the properties or replace the ${...} values in the following examples)

JMS Connection Factory

The JMS connection factory is dependent on the queue / topic implementation that is being used. In this case this is IBM MQ,

This will configure a Queue based connection. To create a topic based connection is just as simple. Just replace the 'Queue' with 'Topic' in the configuration above. This gives,

Spring Connection Factory

The spring connection factory wraps the JMS Connection Factory. There are a number of connection factories available. If this is a simple connection with no authentication then just use,

<bean id="springConnectionFactory"

class="org.springframework.jms.connection.SingleConnectionFactory">

</bean>

otherwise if credentials are required use,

Spring JMS Template

The JMS template does a lot of the boilerplate code required to open and close connections. It is very like JdbcTemplate from that point of view.

Message Driven Bean

A message driven bean is triggered when a message is received by the JMS system. Spring maintains this relationship and in its simplest form it is exactly the same as the standard JMS setup,

<bean id="sampleMessageDrivenBean" class="com.me.SampleMessageDrivenBean">
</bean>


<bean id="springJmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="springConnectionFactory" />
<property name="destination" ref="jmsDestination" />
<property name="messageListener" ref="sampleMessageDrivenBean" />
</bean>

In this case the message driven bean just implements the standard MessageListener interface from JMS,

public class SampleMessageDrivenBean implements MessageListener
{
@Override
public void onMessage(Message message)
{
System.out.println("Message Driven Bean: New Message");
System.out.println(message.toString());
}
}

Spring also provides a session message listener which provides the session object in the onMessage() call.

Sending Messages

Creating a class to send a message is very easy too. Using spring to inject the JmsTemplate and Destination leaves a class to send messages as,

public class MessageSender
{

/**
* JMSTemplate.
*/
private JmsTemplate jmsTemplate;

/**
* JMSTemplate.
*/
private Destination jmsDestination;

/**
* Send a message.
*/
public void sendMessage()
{
jmsTemplate.send(jmsDestination, new MessageCreator()
{
@Override
public Message createMessage(Session session) throws JMSException
{
System.out.println("Message Sent");
final Calendar now = Calendar.getInstance();
return session.createTextMessage(now.toString());
}
});
}

/**
* Sets jmsTemplate to the given value.
*
* @param jmsTemplate the jmsTemplate to set
*/
public void setJmsTemplate(JmsTemplate jmsTemplate)
{
this.jmsTemplate = jmsTemplate;
}

/**
* Sets jmsDestination to the given value.
*
* @param jmsDestination the jmsDestination to set
*/
public void setJmsDestination(Destination jmsDestination)
{
this.jmsDestination = jmsDestination;
}
}

Thursday, 16 May 2013

Motion JPG / MJPG

MJPG is a format which is used by some webcams. This format is just a series of JPG images as bytes separated by a boundary and some headers. For example

--myboundary
Content-Type: image/jpg
Content-Length: 1234

  afhaoiughwer< 1234 bytes >
  --myboundary

  Content-Type: image/jpg
  Content-Length: 2345

  poipoijngiuh< 2345 bytes >

The blank line after the headers is also used in http requests to separate headers from content - this is pretty standard. This is pretty simple to parse and get the jpg files from. Below is a sample java class which does this. This allows a number of images to be skipped so that not every image has to be processed if that isn't required. This currently just bins the headers but could easily be extended to return the header properties as well.

/**
* Class to parse a MJPG stream and generate jpg files
*/
public class MjpgParser
{
/**
* The content length header.
*/
private static final String CONTENT_LENGTH_HEADER = "Content-Length: ";

/**
* The size of the content length string. Used to chop of the head name and calculate the integer.
*/
private static final int CONTENT_LENGTH_HEADER_SIZE = CONTENT_LENGTH_HEADER.length();

/**
* The input stream.
*/
private BufferedInputStream mjpgStream;

/**
* The number of images to skip.
*/
private int imagesToSkip;

/**
* Constructs a new MjpgParser with the given parameters.
*
* @param urlResource The url mjpg resource
* @throws IOException an exception from opening the url
*/
public MjpgParser(final String urlResource) throws IOException
{
this(urlResource, 0);
}

/**
* Constructs a new MjpgParser with the given parameters.
*
* @param urlResource The url mjpg resource
* @param imagesToSkip The number of images to skip.
* @throws IOException an exception from opening the url
*/
public MjpgParser(final String urlResource, final int imagesToSkip) throws IOException
{
final URL url = new URL(urlResource);
initialise(url.openStream(), imagesToSkip);
}

/**
* Initialise.
*
* @param inputStream The Input Stream
* @param imagesToSkipNo The number of images to skip.
*/
private void initialise(final InputStream inputStream, final int imagesToSkipNo)
{
this.mjpgStream = new BufferedInputStream(inputStream);
this.imagesToSkip = imagesToSkipNo;
}

/**
* Get the next jpg as a JavaFX Image.
*
* @return an Image object
*/
public Image nextAsImage() throws IOException
{
return new Image(new ByteArrayInputStream(nextWithSkip()));
}

/**
* Get the next jpg as an array of bytes.
*
* @return the bytes of the next jpg
*/
public byte[] nextAsBytes() throws IOException
{
return nextWithSkip();
}

/**
* Close the streams.
*/
public void close() throws IOException
{
mjpgStream.close();
}

/**
* This method calls next but takes account of the imagesToSkip value.
*
* @return the jpg file after skipping the correct number
* @throws IOException Thrown by reading from the stream
*/
private byte[] nextWithSkip() throws IOException
{
for (int i = 0; i < imagesToSkip - 1; i++)
{
next();
}
return next();
}

/**
* Get the next jpg as bytes. This reads the headers and then reads the jpg from the
* stream using the Content-Length value to know when to stop.
*
* @return the next jpg file
* @throws IOException
*/
private byte[] next() throws IOException
{
// Find the boundary line
String lineStr = readHeaderLine();
while (!lineStr.startsWith("--"))
{
lineStr = readHeaderLine();
}

// Read the headers.
int contentLength = 0;
lineStr = readHeaderLine();
while (!lineStr.isEmpty())
{
// If this is the content length then process it.
if (lineStr.startsWith(CONTENT_LENGTH_HEADER))
{
contentLength = parseContentLength(lineStr);
}

lineStr = readHeaderLine();
}

return readJpgBytes(contentLength);
}

/**
* Read a line from the input stream. This is a header line so it will be a readable string
* and can be trimmed to remove the end of line characters.
*
* @return the line as bytes
* @throws IOException
*/
private String readHeaderLine() throws IOException
{
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
int entry = mjpgStream.read();
while (entry != '\n')
{
baos.write(entry);
entry = mjpgStream.read();
}
return new String(baos.toByteArray()).trim();
}

/**
* Parse the content length line.
*
* @param contentLengthLine The line to parse
* @return The content length
*/
private int parseContentLength(final String contentLengthLine)
{
return Integer.parseInt(contentLengthLine.substring(CONTENT_LENGTH_HEADER_SIZE));
}

/**
* Read the jpg.
*
* @param contentLength the length of the jpg
* @return the jpg as an {@link Image}
* @throws IOException
*/
private byte[] readJpgBytes(final int contentLength) throws IOException
{
final byte [] jpgBytes = new byte[contentLength];
for (int i = 0; i < contentLength; i++)
{
jpgBytes[i] = (byte) mjpgStream.read();
}
return jpgBytes;
}
}

Maven Sources Plugin

This useful plugin will generate and install a jar of the sources of the project. Most of the time a really simple configuration works. However, there is one thing worth noting. If this is used with the wrong goal the sources will be regenerated. If this is used in conjunction with the Maven Replacer Plugin then the replacer will not run as the goal for this is usually prepare-package.

So, the configuration which will not frig with the sources is

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-source-plugin</artifactId>
  <version>2.2.1</version>
  <executions>
<execution>
<id>attach-sources</id>
<phase>verify</phase>
<goals>
<goal>jar-no-fork</goal>
      </goals>
</execution>
</executions>
</plugin>

The jar-no-fork will force this plugin to use the sources which already exist. If this is only jar then the sources will be regenerated.

Thursday, 18 April 2013

JavaFX JUnit Testing

Unit testing in JavaFX is important but normal JUnit tests will fail because they are not run on the JavaFX thread. Below is an example of how to solve this. The two classes below take care of loading JavaFX and a JUnit test runner which guarantees that JavaFX is running and makes sure that all tests are run in the JavaFX thread.

This solution is based on a JUnit4 Runner. The new runner class extends the BlockJUnit4ClassRunner which is the default runner for JUnit tests. If you also need the spring support then just extend the SpringJUnit4ClassRunner instead. Both runners can co-exist if necessary because they both use the JavaFxJUnit4Application class to guarantee a single JavaFx instance.

JavaFxJUnit4ClassRunner

Runs all the unit tests in the JavaFX Thread.

import java.util.concurrent.CountDownLatch;

import javafx.application.Platform;

import org.junit.runner.notification.RunNotifier;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;

/**
* This basic class runner ensures that JavaFx is running and then wraps all the runChild() calls
* in a Platform.runLater(). runChild() is called for each test that is run. By wrapping each call
*  in the Platform.runLater() this ensures that the request is executed on the JavaFx thread.
*/
public class JavaFxJUnit4ClassRunner extends BlockJUnit4ClassRunner
{
/**
* Constructs a new JavaFxJUnit4ClassRunner with the given parameters.
*
* @param clazz The class that is to be run with this Runner
* @throws InitializationError Thrown by the BlockJUnit4ClassRunner in the super()
*/
public JavaFxJUnit4ClassRunner(final Class<?> clazz) throws InitializationError
{
super(clazz);

JavaFxJUnit4Application.startJavaFx();
}

/**
* {@inheritDoc}
*/
@Override
protected void runChild(final FrameworkMethod method, final RunNotifier notifier)
{
// Create a latch which is only removed after the super runChild() method
// has been implemented.
final CountDownLatch latch = new CountDownLatch(1);
Platform.runLater(new Runnable()
{
@Override
public void run()
{
// Call super to actually do the work
JavaFxJUnit4ClassRunner.super.runChild(method, notifier);

// Decrement the latch which will now proceed.
latch.countDown();
}
});
try
{
latch.await();
}
catch (InterruptedException e)
{
// Waiting for the latch was interruped
e.printStackTrace();
}
}
}

JavaFxJUnit4Application

Manages starting JavaFX. Uses a static flag to make sure that FX is only started once.

Manages starting JavaFX. Uses a static flag to make sure that FX is only started once and a LOCK to make sure that multiple calls will pause if the JavaFX thread is in the process of being started. This improves on the previous version because it doesn't involve a sleep.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javafx.application.Application;
import javafx.stage.Stage;

/**
* This is the application which starts JavaFx. It is controlled through the startJavaFx() method.
*/
public class JavaFxJUnit4Application extends Application
{

/** The lock that guarantees that only one JavaFX thread will be started. */
private static final ReentrantLock LOCK = new ReentrantLock();

/** Started flag. */
private static AtomicBoolean started = new AtomicBoolean();

/**
* Start JavaFx.
*/
public static void startJavaFx()
{
try
{
// Lock or wait. This gives another call to this method time to finish
// and release the lock before another one has a go
LOCK.lock();

if (!started.get())
{
// start the JavaFX application
final ExecutorService executor = Executors.newSingleThreadExecutor();
executor.execute(new Runnable()
{
@Override
public void run()
{
JavaFxJUnit4Application.launch();
}
});

while (!started.get())
{
Thread.yield();
}
}
}
finally
{
LOCK.unlock();
}
}

/**
* Launch.
*/
protected static void launch()
{
Application.launch();
}

/**
* An empty start method.
*
* @param stage The stage
*/
@Override
public void start(final Stage stage)
{
started.set(Boolean.TRUE);
}
}

Sample Test

A sample test class which instantiates a Scene object. This will fail if it isn't on the JavaFX thread. It can be shown to fail if the @RunWith annotation is removed.

/**
* This is a sample test class for java fx tests.
*/
@RunWith(JavaFxJUnit4ClassRunner.class)
public class ApplicationTestBase
{
/**
* Daft normal test.
*/
@Test
public void testNormal()
{
assertTrue(true);
}

/**
* Test which would normally fail without running on the JavaFX thread.
*/
@Test
public void testNeedsJavaFX()
{
Scene scene = new Scene(new Group());
assertTrue(true);
}
}

JavaFxJUnit4Application - Previous version

Manages starting JavaFX. Uses a static flag to make sure that FX is only started once.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javafx.application.Application;
import javafx.stage.Stage;

/**
* This is the application which starts JavaFx. It is controlled through the startJavaFx() method.
*/
public class JavaFxJUnit4Application extends Application
{
/**
* Flag stating if javafx has started. Static so that it
* is shared across all instances.
*/
private static boolean started;

/**
* Start JavaFx.
*/
static void startJavaFx()
{
if (started)
{
return;
}

started = true;

/**
* The executor which starts JavaFx.
*/
final ExecutorService executor = Executors.newSingleThreadExecutor();

// Start the java fx application
executor.execute(new Runnable()
{
@Override
public void run()
{
JavaFxJUnit4Application.launch();
}
});

// Pause briefly to give FX a chance to start
try
{
Thread.sleep(1000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}

/**
* Launch.
*/
static void launch()
{
Application.launch();
}

/**
* An empty start method.
*
* @param stage The stage
*/
@Override
public final void start(final Stage stage)
{
// Empty
}
}

Friday, 15 February 2013

JavaFX Pan & Zoom

These notes are based around putting objects into a normal Pane object and not, for example, a ScrollPane where the rules for finding the centre point to pivot a scale around are a bit odd!

JavaFX gives amazing controls over panning and zooming. For example to pan a pane you can simply use

pane.setTranslateX(10);
pane.setTranslateY(10);

This will set the translate. If you want to move an object more from its currently panned position use

pane.setTranslateX(pane.getTranslateX() + ...);
pane.setTranslateY(pane.getTranslateY() + ...);

Zooming is very similar, to double the size around the centre point of the pane,

pane.setScaleX(2);
pane.setScaleY(2);

Putting these together is fine and works well. However, you would normally want to zoom around the centre point of the screen rather than the centre point of the pane, particularly if the pane has been panned first. To do a zoom around a particular point you can use the Scale transformation provided as standard.

Scale scale = new Scale();
scale.setPivotX(pivotX);
scale.setPivotY(pivotY);
scale.setX(zoomFactorX);
scale.setY(zoomFactorY);
pane.getTransforms().add(scale);

The pivotX, pivotY point here is the point around which the scale takes place. How, the problem comes to calculate the pivot point. You can do this fairly easily using the position of the pane in the parent.

Bounds bip = pane.boundsInParent().get();
double pivotX = (screenWidth / 2 - bip.getMinX()) / scaleX;
double pivotY = (screenHeight / 2 - bip.getMinY()) / scaleY;

Scale scale = new Scale()
...

scaleX *= zoomFactorX;
scaleY *= zoomFactorY;

Where scaleX and scaleY are the current scaling. You can keep track of the current scale easily enough by adjusting it after each zoom (as above) or you can get the current width / height from the bounds object and calculate the zoom from the original size.

For consistency, you can now use a transform to do the translation as well. This makes no difference to the scaling and pivot calculation as the boundsInParent will still be the same whichever way the translation is done.

Translate translate = new Translate(panX, panY);
pane.getTransforms().add(translate);

JavaFX Layout Sizes

If you are using JavaFX then it is worth knowing that the definitive way to get size and position information for a Pane is to use

Bounds bounds = pane.boundsInParent().get();

The Bounds object obtained gives width, height and translated position (minX, minY) for this pane in its parent. Even if the width of a pane is set it may get overridden by the layout if there is insufficient room. Therefore, you cannot rely on what you think the size is. Instead use the bounds above to get the actual answer.