Author Archives: Nico Heid

When I first had to use regular expressions in Java I made some fairly common mistakes.
Let’s start out with a simple search.

simple string matching

We want to search the string: asdfdfdasdfdfdf for occurences of dfd. I can find it four times in the String.
Let’s evaluate what our little Java program says.

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexCoding {

	public static void main(String[] args) {

		String source = "asdfdfdasdfdfdf";
		Pattern pattern = Pattern.compile("dfd");
		Matcher matcher = pattern.matcher(source);
		int hits = 0;
		while (matcher.find()) {
			hits++;
		}
		System.out.println(hits);

	}
}

The result should be 2. So either our code is wrong, or the logic works differently than expected. And indeed, it does.

The first important rule of regular expressions in Java is: The search runs from left to right, and if a character has been used in search it will not be reused. So when we see dfdfd we used the first three letters for the match, and only fd remains, which is no match any more.

getting IP addresses out of some input

Let’s pretend you application wants to read the IP addresses out of some garbled texted you got from a service.
First of all we have to define how an IP address can look like. We have 4 pairs of numbers separated by dots ranging from 0 to 255.

Let’s write this as a regular expression. This might not be the best solution, if you have any better or more elegant feel free to leave a comment.

Pattern: \b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b (this one is from http://www.regular-expressions.info/examples.html , thanks). This is IPv4 only.
It basically takes the allowed numbers for the first three blocks separated by dot and then quantified by 3. And the final block with the same pattern but without the trailing dot.

So let’s see if it works:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexCoding {

	public static void main(String[] args) {

		String logtext = "asdfesgewg 215.2.125.32 alkejo 234 oij8982jld" +
				"kja.lkjwech . 24.33.125.234 kadfjeladfjeladkj";
		
		String regexpatter = "\\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}" +
				"(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\b";
		
		Pattern pattern = Pattern.compile(regexpatter);
		Matcher matcher = pattern.matcher(logtext);
		
		while (matcher.find()) {
			System.out.println(logtext.substring(matcher.start(),matcher.end()));
		}
		

	}
}

As you can see, it prints the IP addresses found in the string.
You have to take care to escape the \ properly, otherwise you’ll end with an empty result or an invalid escape sequence error.

further reads

http://java.sun.com/javase/6/docs/api/java/util/regex/Pattern.html
http://en.wikipedia.org/wiki/Regular_expression
http://www.gamedev.net/community/forums/topic.asp?topic_id=357270

Hibernate is a well known object-relational mapping library (ORM) for Java. It allows you to map entries in your relational database to objects in your Java classes.
Usually this is done by a mapping file written in XML. As this approach is a bit more expensive we will use annotations to map a class to the relating database table.
Based on the Maven tutorial by my colleague Phillip, we will begin with a quickstart archetype and include Hibernate and a MySQL connection. Then we will write a simple data access object (DAO) which maps to the database table we will create. After that we use a class to set up the connection and fill the database with some of our objects.

Note: This is just a superficial glance at Hibernate to get in touch with the framework.

Setting up the project

After generating the quickstart archetype we will extend the pom.xml. Add the following dependencies:

       <!-- hibernate with annotations for persistence -->
       <dependency>
           <groupId>org.hibernate</groupId>
           <artifactId>hibernate-entitymanager</artifactId>
           <version>3.3.2.GA</version>
       </dependency>
       
       <dependency>
           <groupId>org.hibernate</groupId>
           <artifactId>hibernate-annotations</artifactId>
           <version>3.3.1.GA</version>
       </dependency>

        <!-- connector to mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>

The first two extensions add hibernate support and annotation support. The third one provides the the connection to MySQL.

The Database Parts

Now we will create a simple database table to store our data and add a corresponding class. Let’s pretend we want to store interesting coordinates. We just use a description, the longitude and latitude. Additionally we use an id as our primary key which will autoincrement.

CREATE TABLE `hibernateexample`.`coordinatestorage` (
  `id` INT  NOT NULL AUTO_INCREMENT,
  `description` VARCHAR(100)  NOT NULL,
  `longitude` FLOAT  NOT NULL,
  `latitude` FLOAT  NOT NULL,
  PRIMARY KEY (`id`)
)

The Java class looks according, using annotations for the mapping.

package com.unitedcoders.dao;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;


@Entity
@Table(name = "coordinatestorage")
public class CoordinateStorage {

    @Id
    @GeneratedValue
    Integer id;
    
    @Column
    String description;
    
    @Column
    Float longitude;
    
    @Column
    Float latitude;

   // ... following Getter and Setter, cut out for brevity

That’s about all we need to store the data but we’re still lacking the connection to the database. Create a hibernate.properties file in you classpath and fill it with the appropriate values.

hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.connection.driver_class=com.mysql.jdbc.Driver
hibernate.connection.url=jdbc:mysql://localhost/hibernateexample
hibernate.connection.username=root
hibernate.connection.password=root

The Application

To test the persistence classes we will set up a simple Java class, get a session, create some objects and save them into the database.

package com.unitedcoders;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.classic.Session;

import com.unitedcoders.dao.CoordinateStorage;


public class FillDatabase {

    public static void main(String[] args) {

        AnnotationConfiguration configuration = new AnnotationConfiguration();
        configuration.addAnnotatedClass(CoordinateStorage.class);
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        for (Float i = 0.0F; i < 10.0F; i++) {
            CoordinateStorage coStorage = new CoordinateStorage();
            coStorage.setDescription("Location " + i);
            coStorage.setLatitude((i * i * 12) % 360);
            coStorage.setLongitude((i * i * 55) % 360);

            session.save(coStorage);
        
        }

        
        session.close();
        sessionFactory.close();

    }

}

Final Words

As you can see it's fairly simple to get Hibernate integration in your project. We just looked a very minimal feature set here and integrated Hibernate manually. For a real application you would configure the project differently.

For more information refer to the Hibernate documentation and especially to the available annotations.

The Google App Engine (GAE) is a wonderful playground for your apps, especially when you have no server at hand. It gives you everything you need for free, up to a certain limit. As I happened to be a Java developer it became really interesting when the GAE started supporting Java. You have to register for a GAE account and then apply for Java to be activated. There is a small waiting time but there still seem to be open slots.

As I’m working with Apache Wicket at the moment I thought it would be a nice idea to give you everything you need to get started with development with the GAE and Wicket as your frontend. So in the following lines we will set up a minimal Java / Wicket application and deploy it into the GAE.

Download and install the Google App Engine Java

You’ll find everything you need to know on Google’s page: http://code.google.com/appengine/
Make sure to select the Java SDK and not the Python one. While downloading you can register and get a GAE account. After you are locked in apply for the Java environment. The developer kit brings along an application server, so that you can test your application locally. It might take some time till you get the confirmation link which will be telling that you’re free to use Java. Until then you have to limit your experiments to your local machine.

Creating the Wicket Project with Maven

As build tool we will be using Maven, so if you’re new to that you might want to read the Maven tutorial of my colleague Phillip. It gives a good introduction of maven and how it will aid you in software development.

For the impatient, here’s the quickstart, as found on the Wicket homepage:

mvn archetype:create -DarchetypeGroupId=org.apache.wicket \
   -DarchetypeArtifactId=wicket-archetype-quickstart  \
   -DarchetypeVersion=1.4-rc2 \
   -DgroupId=com.united-coders -DartifactId=gae-minimal

I’ll be using the second release candidate of Wicket 1.4. Running the command will leave you with the project structure we’ll be working with. You can run and deploy this in you local servlet containter, but to deploy it into the GAE we need to make some changes.

Google App Engine specific changes

As mentioned on Alastair Maw’s blog, we need to make a few changes to the project so that it will be running, once deployed. This is due to the special environment (the sandbox) the application will be running in. For our example we have to change the application so that it does not spawn any extra threads. Alastair Maw already mentioned what we have to do, so we take his advice and then import the GAE settings into our project, so that we can deploy it.

Changes in the Wicket project

When building the project for deployment make sure to enable the deployment mode. In deployment mode Wicket does not try to spawn any processes for monitoring changes in resource files. This can be done in the configuration file or in the command line when building the project. Because this is a setting only used before deployment I prefer to use the command line option and leave the configuration untouched.
So when you’re ready to deploy use the following command: (not yet, we need to make some more changes. but it should compile)

mvn -Dwicket.configuration=deployment clean package

Additionally we need to override the creation of the newSessionStore(), so that it does not run in a separate thread in the background.
So edit your WicketApplication.java as shown below.

public class WicketApplication extends WebApplication
{
    /**
     * Constructor
     */
        public WicketApplication()
        {
        }

        /**
         * @see org.apache.wicket.Application#getHomePage()
         */
        public Class<HomePage> getHomePage()
        {
                return HomePage.class;
        }

    @Override
    public HttpSessionStore newSessionStore(){
       return new HttpSessionStore(this);
    }

}

GAE specific settings

Take the appengine-web.xml file from the new_project_template in the demo folder and copy it to your projects src/main/webapp/WEB-INF/ folder.
Enable session support and enter the name of your project (as shown in the GAE). After that your appengine-web.xml file should look similar to this:

<appengine-web-app xmlns="http://appengine.google.com/ns/1.0">

  <!-- Replace this with your application id from http://appengine.google.com -->
  <application>nameOfYourProject</application>

  <version>1</version>

  <sessions-enabled>true</sessions-enabled>

</appengine-web-app>

Deploy your application into the Google App Engine

After building your project with maven you can upload the project files with the script supplied with the SDK.

./bin/appcfg.sh update projects/wickethelloworld/target/wickethelloworld-1.0-SNAPSHOT

That’s it. Sources are attached. The deployed app can be found here: http://wickethelloworld.appspot.com/

UPDATE
* The limit of available accounts has been abolished.

And there two articles I’d recommend reading when you want to get a bit more detail before you start:
* Google App Engine for Java – 3 Tips for Getting Started
* Google App Engine For Java – Microblogging Case Study