Create database triggers like features using Hibernate events

When you are creating a Java application with database operations, it is obvious to use JDBC as the database communication method. Well, that’s not the case here. Imagine a situation like this, if you are developing an application that manages an inventory and when a product reaches to its re-order level, your application should automatically populate and send a purchase order to the supplier.

Here you’ll say that “Ok, I can do it by creating a trigger in the database”. But the thing is how that trigger notifies or talks to your application about the product?

Currently there is no support for triggers in JDBC (This is clearly my opinion. I Googled about this for a day and I found nothing. Guys, you can check this out if you are interested). But I must acknowledge to the changes in the database in real time through my Java application.

What are the database events that can be monitored by your application?

Following are the usual CRUD (Create, Read, Update, and Delete) events that occur in any regular database.

1. Pre – Select:  These types of events occur before executing any select statement against the database.
2. Post – Select: These types of events occur after executing any select statement against the database.
3. Pre – Insert: These types of events occur before you execute any insert statement.
4. Post – Insert: These types of events occur after executing an insert statement.
5. Pre – Update: These types of events occur before executing any update statements against the database.
6. Post – Update: These types of events occur after executing any update statement against the database.
7. Pre – Delete: These types of events occur before executing any delete statement against the database.
8. Post – Delete: These types of events occur after executing a any delete statement against the database.

Apart from that, there can be several types of events occur in a database. But for the sake of simplicity, I’ll not consider them because they are not in our scope.

How to trap those events in  your Java application?

There are several ways to do that. But we already know using JDBC is impossible at the moment. One way to achieve this is implementing a thread in your application to monitor the changes in the database object (such as a table in the database). If any change occurred, that thread can dispatch the changes in your application. But this is not a good practice. What if your database has more than ten tables? Then you have to create ten threads for each table and that would be a great mess regarding to the performance. So you have to omit that approach.

But Hibernate (An open source ORM framework) can save your day by using Its Interceptors and event system to trap those events.

Let’s see how can we do it using hibernate.

Hibernate Event System

Before I proceed, I assume that you have some knowledge about Hibernate and its general architecture. (Visit http://www.hibernate.org for more information).

Hibernate ships with powerful event system. You can browse the org.hibernate.event package for more information, but this package was poorly documented.

You can react to particular events in the persistence layer using this event architecture. Essentially all of the methods of the Session interface correlate to an event. You have a LoadEvent, aFlushEvent, etc (consult the XML configuration-file DTD or the org.hibernate.event package for the full list of defined event types). When a request is made of one of these methods, the Hibernate Session generates an appropriate event and passes it to the configured event listeners for that type. Out-of-the-box, these listeners implement the same processing in which those methods always resulted. However, you are free to implement a customization of one of the listener interfaces (i.e., the LoadEvent is processed by the registered implementation of the LoadEventListener interface), in which case their implementation would be responsible for processing any load() requests made of the Session.

A custom listener should implement the appropriate interface for the event it wants to process. There are several types of event listener interfaces. If you want to receive change notifications, all you have to do is implement the appropriate event interface in your program. For example, for pre-select events, you have to implement the LoadEventListener. For post-update events, you have to implement the PostUpdateListener interface.

Below is the commonly used listener interfaces in hibernate.

Event Listeners in org.hibernate.event package

Along with these listeners, you can use associated event objects to get information related with a particular event. For instance, after updating an object you can retrieve the updated instance of an object using PostUpdateEvent object.  Then it can be used to set the properties like update timestamp.

Below is the commonly used event objects associated with event listeners.

Event Objects in org.hibernate.event package

How to use hibernate events in your application?

1. Implement the appropriate event interface in your application.
2. Register the listeners in hibernate.cfg.xml file.

Very simple application to demonstrate the post-update event type

Here I’m going to create an application to trap an object after updating.

package com.dunithd.events;

import org.hibernate.event.PostUpdateEvent;
import org.hibernate.event.PostUpdateEventListener;

import com.dunithd.events.InventoryProduct;

/**
 * A class that implements PostUpdateEventListener interface
 *
 * @author duischen
 * @version 1.0, Oct 27, 2009
 */
public class ProductUpdateListener implements PostUpdateEventListener {

	@Override
	public void onPostUpdate(PostUpdateEvent event) {
		if (event.getEntity() instanceof InventoryProduct) {
			InventoryProduct product = (InventoryProduct) event.getEntity();

			// Check for quantity and re-order level for this product
			int quantity = product.getQuantity();
			int reOrderLevel = product.getReOrderLevel();

			// Check if this product is under the re-order level
			if (quantity <= reOrderLevel) {
				System.out.println("Need to purchase.");
			} else {
				System.out.println("No Need to purchase.");
			}

		}
	}

}

Then register this listener in hibernate.cfg.xml file.

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		.....
	<mapping resource="com/dunithd/events/InventoryProduct.hbm.xml" />

	  <!-- Register the listeners -->
	  <listener type="post-update"/>

	</session-factory>
</hibernate-configuration>

Create the database table as follows.

create table products (
	int product_id primary key,
	varchar(100) description,
	float price,
	int quantity,
	int reorder_level
)

When you run your application, you can see the message “Need to purchase.” or “No need to purchase”, depending on the quantity of the product.

Send email using JavaMail API and your Gmail account

Sending email using Java is not a difficult task and it’s just about writing few lines of codes. But when you are writing such an application, you’ll end up with lot of exceptions obviously. There are lots of reasons for that, but as my opinion, wrong email configuration settings would cause the exceptions.

If you need to write a Java application to send an email, you need an outgoing mail server such as SMTP (Simple Mail Transfer Protocol) server. There are many SMTP servers out there, but in order to send an email most servers require authentication (You have to have an account in your SMTP server and you must know account credentials). There exist free SMTP servers without authentication, but I’m not sure about their reliability and Quality of Service (QoS).

At the authentication process, most developers fail due to bad configurations. There are several configuration settings should be set in your code, before you submit the message to the SMTP server.

To demonstrate this settings, I’ll create a Java application from the scratch and it will use Gmail as the outgoing SMTP server (You can use any SMTP server with valid credentials. But here I used Gmail because I’m addicted to Google!).

You can download the complete source code and required libraries here. I developed it using NetBeans IDE, but you can use any IDE to proceed.

Prerequisites

• JavaMail API (http://java.sun.com/products/javamail) libraries. (No need to download the libraries. I’ve included them in my sample application).
• Valid Gmail (http://www.google.com/gmail) account. (You must know the user name and the password)

Source Code

package com.dunithd.jmail;

import javax.mail.*;
import javax.mail.internet.*;
import javax.mail.internet.MimeMessage.RecipientType;

import java.util.*;

/**
 * Simple Class to send an email using JavaMail API (javax.mail) and Gmail SMTP server
 * @author Dunith Dhanushka, dunithd@gmail.com
 * @version 1.0
 */
public class GmailSender {

    private static String HOST = "smtp.gmail.com";
    private static String USER = "your_username@gmail.com";
    private static String PASSWORD = "put_your_password_here";
    private static String PORT = "465";
    private static String FROM = "put_from_address_here";
    private static String TO = "put_to_address_here";

    private static String STARTTLS = "true";
    private static String AUTH = "true";
    private static String DEBUG = "true";
    private static String SOCKET_FACTORY = "javax.net.ssl.SSLSocketFactory";
    private static String SUBJECT = "Testing JavaMail API";
    private static String TEXT = "This is a test message from my java application. Just ignore it";
    
    public static synchronized void send() {
        //Use Properties object to set environment properties
        Properties props = new Properties();

        props.put("mail.smtp.host", HOST);
        props.put("mail.smtp.port", PORT);
        props.put("mail.smtp.user", USER);

        props.put("mail.smtp.auth", AUTH);
        props.put("mail.smtp.starttls.enable", STARTTLS);
        props.put("mail.smtp.debug", DEBUG);

        props.put("mail.smtp.socketFactory.port", PORT);
        props.put("mail.smtp.socketFactory.class", SOCKET_FACTORY);
        props.put("mail.smtp.socketFactory.fallback", "false");

        try {

            //Obtain the default mail session
            Session session = Session.getDefaultInstance(props, null);
            session.setDebug(true);

            //Construct the mail message
            MimeMessage message = new MimeMessage(session);
            message.setText(TEXT);
            message.setSubject(SUBJECT);
            message.setFrom(new InternetAddress(FROM));
            message.addRecipient(RecipientType.TO, new InternetAddress(TO));
            message.saveChanges();

            //Use Transport to deliver the message
            Transport transport = session.getTransport("smtp");
            transport.connect(HOST, USER, PASSWORD);
            transport.sendMessage(message, message.getAllRecipients());
            transport.close();

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
       GmailSender.send();
       System.out.println("Mail sent successfully!");
    }
}

When writing the application, you have to set some Environment Properties that are used by the JavaMail APIs. The JavaMail javadocs contain additional information on properties supported by JavaMail.

You can use java.util.Properties class to set these properties.

• mail.smtp.host: Specifies the protocol-specific default Mail server. In your application, set this property to smtp.gmail.com
• mail.smtp.user: Specifies the protocol-specific default username for connecting to the Mail server. In your application, set this property to your Gmail username.
• mail.smtp.auth: Specifies whether host requires authentication or not. In our application, set this property to true.
• mail.smtp.debug: Specifies the initial debug mode. Setting this property to true will turn on debug mode, while setting it to false turns debug mode off. If you need deeper diagnosis, set this to true.
• mail.smtp.port: Specifies the port that is used by SMTP server. In your application, set this to 465.
• mail.smtp.starttls.enable: This is the most important one. If you miss this, you’ll definitely get an error. Most SMTP servers support SSL (Secure Socket Layer) connections which can be used for secure login to the server. They use STARTTLS command (see RFC 2487 and RFC 3501) to switch the connection to be secured by TLS.
  Use of the STARTTLS command is preferred in cases where the server supports both SSL and non-SSL connections. This SSL/TLS support in JavaMail works only when JavaMail is used on a version of J2SE that includes SSL support.
  The STARTTLS support is available in the standard “IMAP” and “SMTP” protocols, but must be enabled by setting the appropriate property, mail.imap.starttls.enable or mail.smtp.starttls.enable, to “true”. When set, if the server supports the STARTTLS command, it will be used after making the connection and before sending any login information.

If everything goes fine, you’ll see an output like this.

Output of the application

Notes

This application cannot be used in a network that uses a proxy server. You must have a direct connection to the internet otherwise you’ll get UnknownHostException.

UnknownHostException

In my next post, I’m gonna explain you how to send an email with an attachment.

Download source code and required libraries here.