In this post I’ll try to teach you how to create a message driven bean which can communicate with an application client.
In order to follow this tutorial, I’ll assume you have Netbeans (6.9) and Glassfish available on your system.

Creating the Message driven bean

Create a new project in Netbeans and choose for a Java EE – EJB Module.

Create a new project

Next, give your project a name and make sure you select Glassfish 3 as your server and Java EE 6 as your Java EE version.

Server and settings

Than you can add a new Message Driven Bean to your project

Add a Message Driven Bean

Give the Bean a name and a package.
Click next to destinations on the Add button to add a destination.
Choose a name for your destination.
Choose between Queue or Topic. In this example it isn’t important which one you choose. The difference between Topic and Queue is if you want Point-to-point or Publish/subscribe communication for your beans.

Name your bean

Netbeans creates code for you and, except for the actual businesscode, your bean is ready.

In this simple example, I just want to pass a name from my applicationclient to my bean and my bean has to echo “Helllo name”

The full code looks like this:

package hello;

import java.util.logging.Level;
import java.util.logging.Logger;
import javax.ejb.ActivationConfigProperty;
import javax.ejb.MessageDriven;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;

@MessageDriven(mappedName = "jms/hello", activationConfig =  {
        @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
        @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue")
    })
public class HelloBean implements MessageListener {

    public HelloBean() {
    }

    public void onMessage(Message message) {
        try {
            System.out.println("Hello " + message.getStringProperty("name"));
        } catch (JMSException ex) {
            Logger.getLogger(HelloBean.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

Almost all the configuration is mapped into 1 annotation.
- The annotation @MessageDriven transforms your normal class into an actual Message Driven Bean.
- The @ActivationConfigProperty annotation is to be used for defining properties to your bean such as the acknowledge mode, message selector, subscription durability and destination type.
In previous versions of JEE, you had to create an XML-file to define all these properties.

Our bean is finished and can be deployed.
Start your Glassfish server and simply click on the deploy button to deploy your bean into Glassfish.

If you open your Glassfish admin console (by default located at http://localhost:4848/ ), you should see that your application is successfully deployed and activated into Glassfish.

Also verify that the JMS resources for your MDB are succesfully created

Creating the Application client

The MDB is created and is waiting for messages. Now it’s time to create the Application client.
Just create a new project and choose for an Enterprise Applicaton Client from the list

The code for the applicaton client looks like this:

package mdbclient;

import javax.annotation.Resource;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;

public class Main {

    @Resource(mappedName = "jms/helloFactory")
    private static ConnectionFactory connectionFactory;

    @Resource(mappedName = "jms/hello")
    private static Queue queue;

    public static void main(String[] args) throws JMSException {
        Connection connection = connectionFactory.createConnection();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        MessageProducer producer = session.createProducer(queue);
        Message message = session.createTextMessage();
        message.setStringProperty("name", "World!!");
        producer.send(message);
        System.exit(0);
    }
}

If you deploy and run this application you should see in the server output the string “Hello World!!

What’s going on?
First we have to create 2 resources to inject the parameters into the Queue and ConnectionFactory . This can be done easily with the @resource annotation.
Next, we just have to create the actual jms-message. I think the code is pretty clear so it shouldn’t be to difficult to understand what’s going on.

Remote invocation

It would be cool if we can run the client from a remote computer.
This is also very easy with webstart.

Go to your Glassfish admin and simply enable Java Web Start.

If you launch this jnpl file from a remote compter, you should again see the message “Hello World!!” in your Glassfish Server output.

When you get an error, it’s possible that you have to change the IP address of the orb-listener-1 to the IP address of the computer where your Glassfish is running on.

Happy Messaging!!

Look at the following code:

//Create an array
$array=array('a','b','c','d','e','f','g');

//Loop over the array by reference
foreach($array as &$a){
}

//Loop again over the array
foreach($array as $a){
}

//Print the array
print_r($array);

What do you think the output would be if you run this piece of code?
Because the array is never changed, the expected result would be:

Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => d
    [4] => e
    [5] => f
    [6] => g
)

If that was the case, I obviously wouldn’t made this blogpost
The result of the code is:

Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => d
    [4] => e
    [5] => f
    [6] => f
)

What’s going on??
Well…
When you loop the first time over the array, the variable $a will be referenced to the array $array.
This means that with every iteration $a points to the specified element in the array.
After every element passed the foreach, $a still points to the last element in the array. In this case ‘g’.

Now you have to loop again over the array.
When the first element ‘a’ is passed to the foreach. $a will be set to ‘a’ but there is still a reference to $a from the previous foreach, which holds the value ‘g’. Because it’s a reference, the value of ‘g’ in the array changes to ‘a’.
When the second element ‘b’ is passed to the foreach. $a will be set to ‘b’ but the reference to $a still exists so the value of the referenced $a changes from ‘a’ to ‘b’
And so on.

If you print the value of the array at every iteration, you will have the following output:

Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f [6] => a )
Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f [6] => b )
Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f [6] => c )
Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f [6] => d )
Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f [6] => e )
Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f [6] => f )
Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f [6] => f )

What to do??
1. Don’t use references in a foreach. Really. If you have to do it, you propably are doing something wrong.
2. If you do need them, delete them after they are used:

$array=array('a','b','c','d','e','f','g');

//Loop over the array
foreach($array as &$a){
}
//remove the reference
unset($a);
//loop again over the array. The output looks like expected
foreach($array as $a){
        print_r($array);
}

3. If you do need them and you can’t delete it because you need the variable elsewhere. Document your code!!!
This little piece of code is very hard to debug when there’s something wrong. Good documented code can save you a lot of headache.

package be.eek.test.mysql;

import java.io.IOException;
import java.io.InputStream;

public class MysqlBackup {

    /**
    main method is just to create a working example
    **/
    public static void main(String[] args) throws IOException {
        new MysqlBackup().MakeBackup();
    }

    public void MakeBackup() throws IOException {
        String dump = "mysqldump "      //Path to mysql
                + "--host=localhost "       //Mysql hostname
                + "--port=3306 "            //Mysql portnumber
                + "--user=root "            //Mysql username
                + "--password=test "        //Mysql password
                + "--add-drop-table "       //Add a DROP TABLE statement before each CREATE TABLE statement
                + "--add-drop-database "    //Add a DROP DATABASE statement before each CREATE DATABASE statement
                + "--complete-insert "      //Use complete INSERT statements that include column names.
                + "--extended-insert "      //Use multiple-row INSERT syntax that include several VALUES lists
                + "test";                   //Mysql databasename

        Process run = Runtime.getRuntime().exec(dump);

        InputStream in = run.getInputStream();

        int nextChar;
        StringBuffer sb = new StringBuffer();

        while ((nextChar = in.read()) != -1) {
            sb.append((char) nextChar);
        }

        //Here, you can for example write it to a file and save it
        System.out.println(sb);
    }
}

The same thing is also possible in php:

$dump = "mysqldump "
        . "--host=localhost "       //Mysql hostname
        . "--port=3306 "            //Mysql portnumber
        . "--user=root "            //Mysql username
        . "--password=test "        //Mysql password
        . "--add-drop-table "       //Add a DROP TABLE statement before each CREATE TABLE statement
        . "--add-drop-database "    //Add a DROP DATABASE statement before each CREATE DATABASE statement
        . "--complete-insert "      //Use complete INSERT statements that include column names.
        . "--extended-insert "      //Use multiple-row INSERT syntax that include several VALUES lists
        . "test";                   //databasename

$backup = system($dump);
echo $backup;
die();