… interface provides a way of decoupling task submission from the mechanics of how each task will be run, including details of thread use, scheduling, etc. An Executor is normally used instead of explicitly creating threads.

Indeed, Executors provide a more robust and easy mechanism for decoupling of submitting a task, from its execution.

In this series, we shall explore this concurrency construct in detail.

NOTE: Have tried to avoid explaining what is already available in javadoc.

Let’s first see the lifecycle of an Executor

ExecutorService extends the Executor interface, adding a bunch of life cycle methods.

Executor Life Cycle

public static void main(String[] args) {
// Executor doesn't exist before this step
// Executor created and moved to running state
ExecutorService executor = Executors.newSingleThreadExecutor();

// Executor into running state
executor.execute(new Runnable() {
public void run() {
System.out.println("Running...");
}
});

// Lets shutdown
executor.shutdown();

System.out.println(" isShutdown = "+executor.isShutdown());
System.out.println(" isTermianted = "+executor.isTerminated());
}

The program depicts the complete lifecycle. Please see the comments inline in the code

Initially the Executor doesn’t exist. When we create an Executor, using Executor’s we have it in Ready state (ready to accept tasks for execution).
Once we submit a task for execution, the Executor moves to running state. Once it completes the task, it moves back to ready state.

Once we call shutdown() on Executor, it begins its shutdown cycle. Once it is completed it moves to Terminated state.

There are couple of things that need to be noted after shutdown is initiated. An Executor can be executing or may have couple of tasks pending to be executed.

Calling shutdown() initiates an orderly shutdown, means all the pending tasks shall be completed, but new tasks won’t be accepted

Calling shutdownNow() initiates a shutdown, by trying to halt the processing the tasks by interrupting the threads. The method returns a list of Runnable’s which were not executed. Programs can use them to reschedule them later or discard them.

What will happen, if we submit a task once shutdown has been initiated?
This situation can be handled by using RejectExecutionHandler. The default implementation simply discards the tasks. We can have the custom logic to handle the tasks that couldn’t be executed.

Upcoming topic – Exploring a little on ScheduledExecutorService

However, this is not an end to this. May be sometime in the future, when I am have bandwidth available shall start working on this again.

You can check the new MINA User Guide at the following link http://mina.apache.org/user-guide.html

To begin with decided to run some samples on switch and if-else constructs and analyze further.

Wrote three function
1. For if-else - a if-else ladder based on int comparisons
2. For Switch - switch with 21 cases, from 1 to 20
3. For Switch - switch with sparse random values

The reason for choosing two functions for switch was this statement from VM spec "Compilation of switch statements uses the tableswitch and lookupswitch instructions"

Lets see the function codes

if-else

public static void testIfElse(int jumpLabel) {
if(1 == jumpLabel) {
    System.out.println("1");
} else if(2 == jumpLabel) {
    System.out.println("2");
} else if(3 == jumpLabel) {
    System.out.println("3");
} else if(4 == jumpLabel) {
    System.out.println("4");
}
// Removed for simplicity
else {
    System.out.println("default");
}
}

Lets see the switch functions

Finite switch version

public static void testSwitchFinite(int jumpLable) {

switch (jumpLable) {
case 1:
    System.out.println("1");
    break;

case 2:
    System.out.println("2");
    break;

case 3:
    System.out.println("3");
    break;

case 4:
    System.out.println("4");
    break;

case 5:
    System.out.println("5");
    break;

// Removed other cases for simplicity

default:
    System.out.println("default");
    break;
}
}

Sparse switch version

public static void testSwitchSparse(int jumpLable) {

switch (jumpLable) {
case 100:
    System.out.println("1");
    break;

case -1:
    System.out.println("2");
    break;

case 5000:
    System.out.println("3");
    break;

case -8:
    System.out.println("4");
    break;

case 1600:
    System.out.println("5");
    break;

case 250:
    System.out.println("250");
    break;

// Removed other cases for simplicity

default:
    System.out.println("default");
    break;
}
}

With the groundwork done, its the benchmarking time. The benchmarking strategy was simple. Run these functions in loop and see the result, with iteration ranging from 100 to 1000.

Lets look at one of the functions

public static void testSwitchPerf(int iteration) {
    long t1 = System.nanoTime();
    for (int i = 0; i < iteration; i++) {
        testSwitchFinite(i);
    }
    long t2 = System.nanoTime();
    System.out.println("Time Taken (switch) = "+(t2 - t1)/1000000);
}

Well this was the ground work, after executing the conditions, here is the data

NOTE: There is some difference due to the way data is provided and the sample space doesn't provide precise results. However, since the sample space is same for both, it would serve its purpose

Conclusion

1. There is no significant execution difference between if-else and switch. The difference observed is due to the sample space choosen.
2. If using if-else, its always recommended to put frequently used if condition at the top of if-else ladder
3. The finite switch statement was converted to tableswitch and sparse switch was converted to lookupswitch

would be interested to hear from folks about their experience in relation to this. I would say, i still prefer switch for readability. Henceforth, my review comment shall be modified as "Use switch instead of if-else, its more readable and has better performance"

Share your thoughts

I would be very keen to hear from you all, about your opinions and experience about the topic

In previous articles, we saw how to retrieve Image metadata and information. In this post we shall see how Sanselan guesses the Image format. We shall take it in two steps

• First we shall look at the ImageFormat class
• Then, we shall look into the implementation guessFormat() API

ImageFormat class

org.apache.sanselan.ImageFormat Class has three members name, extension and actual. Name and extension are same, however I am not sure I understand the use of actual variable.

The class has list of formats (including Unknown) supported by the library. They are all instances of ImageFormat class. The list is

1. IMAGE_FORMAT_UNKNOWN
2. IMAGE_FORMAT_PNG
3. IMAGE_FORMAT_GIF
4. IMAGE_FORMAT_ICO
5. IMAGE_FORMAT_TIFF
6. IMAGE_FORMAT_JPEG
7. IMAGE_FORMAT_BMP
8. IMAGE_FORMAT_PSD
9. IMAGE_FORMAT_PBM
10. IMAGE_FORMAT_PGM
11. IMAGE_FORMAT_PPM
12. IMAGE_FORMAT_PNM
13. IMAGE_FORMAT_TGA
14. IMAGE_FORMAT_JBIG2

guessFormat API – Under the hood

The guessFormat() API looks at the initial 2 to 4 bytes, also known as magic numbers, to determine the Image Format.

Algorithm is as follows:

• Read first two bytes
• Match with existing set of magic numbers and determine format
• It use byte 3 and 4 to determine format for JBig2

The list of magic numbers for different formats is as follows

In addition to this IMAGE_FORMAT_JBIG2 format, byte 3 must be equal to 0x42 and byte 4 must be equal to 0x32.

Based on this table, Sanselan recognizes the Image format. If the magic numbers don’t match from the one in the table, it returns IMAGE_FORMAT_UNKNOWN

References

Sanselan.java

In this article we shall see how to get Image metadata using Apache Sanselan.

Let’s see how the code looks

public static void main(String[] args) {
    String imageFile = args[0];
    try {
         // Metadata details
         IImageMetadata meta = Sanselan.getMetadata(new File(imageFile));
 
         System.out.println("--- Image Metadata ----");
         System.out.println(meta);
     } catch (ImageReadException e) {
         e.printStackTrace();
     } catch (IOException e) {
         e.printStackTrace();
     }
}

Most of the work is done in single line ?

getMetadata() API returns the IImageMetadata details. The toString() method of actual instance class of IImageMetadata prints the image information in a formatted fashion. The instance depends upon the format of the image.

Running the program on one the images shipped with Sanselan source produced this output

--- Image Metadata ----
Exif metadata:
Root:
Image Description: '’'
Make: 'Oregon Scientific'
Model: 'DS6639'
Orientation: 1
XResolution: 72
YResolution: 72
Resolution Unit: 2
Software: 'Adobe Photoshop 7.0'
Modify Date: '2008:07:13 21:05:34'
YCbCr Positioning: 2
Exif Offset: 228

Exif:
Exposure Time: 10/10266 (0.001)
FNumber: 28/10 (2.8)
Exposure Program: 2
ISO: 55
Exif Version: 48, 50, 50, 48
Date Time Original: '2003:10:20 09:01:29'
Create Date: '2003:10:20 09:01:29'
Components Configuration: 1, 2, 3, 0
Compressed Bits Per Pixel: 2
Brightness Value: 9
Exposure Compensation: 0
Max Aperture Value: 3
Metering Mode: 1
Light Source: 0
Flash: 0
Focal Length: 864/100 (8.64)
Subject Location: 27556, 57533, 60147, 20319
Flashpix Version: 48, 49, 48, 48
Color Space: 1
Exif Image Width: 300
Exif Image Length: 225
File Source: 3
Scene Type: 1
Custom Rendered: 0
Exposure Mode: 0
White Balance: 1
Digital Zoom Ratio: 1
Focal Length In 3 5mm Format: 42
Scene Capture Type: 0
Gain Control: 0
Contrast: 0
Saturation: 0
Sharpness: 0

Sub: (jpegImageData)
Compression: 6
XResolution: 72
YResolution: 72
Resolution Unit: 2
Jpg From Raw Start: 838
Jpg From Raw Length: 6258

Photoshop (IPTC) metadata:
Caption/Abstract: ?

In this article we shall see how to get Image Information using Apache Sanselan.

Let’s see how the code looks

public static void main(String[] args) {
String imageFile = args[0];
System.out.println("Image File = "+imageFile);
try {
ImageInfo imageInfo = Sanselan.getImageInfo(new File(imageFile));
System.out.println(imageInfo);
} catch (ImageReadException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

Most of the work is done in single line

getImageInfo() API returns the ImageInfo details. The toString() method of ImageInfo class prints the image information in a formatted fashion.

Running the program on one the images shipped with Sanselan source produced this output

The ImageInfo class can be used programtically to arrange files, or for other purposes as well

References

Sanselan Source

Sanselan Wiki

• Both are NIO frameworks
• Trustin has been part of both Frameworks, lately contributing to Netty (Thanks to Emmanuel for pointing this out)
• Both uses Annotation, though in MINA this is more in area of MINA State Machine, whereas Netty, has used annotations for configuring the IO Chains as well.
• Both Frameworks are working aggressively towards improving their Documentation

Hmm.. that's it for this post. Will be back soon with more


Before I continue, the opinion expressed here are purely mine, and other can tend to disagree. I am a MINA committer myself, so may have a little bias towards MINA. Shall try to keep my discussion unbiased, as much as possible. Having used MINA for a while, have a natural comfort with the framework.

What to Expect

Shall try to evaluate both the frameworks, as if I need to use them in one of my own projects and try to provide rational for my thoughts. User comments shall provide more indepth to the posts. The details shall be covered as I move along on my journey. This post is just the beginning.

Latest Releases

MINA - MINA 2.0 M4
Netty - 3.0.2 GA

Community Activity

Having an active community in an Open Source project is very important. It assures that the project is actively being looked after.

Source of Data

MINA - http://mina.markmail.org/
Netty - http://netty.markmail.org/

MINA community is very active, and scores well above Netty. Though Trustin is very active in Netty, and I hope Netty community shall have active support from more users/developers.

Documentation

MINA and Netty both have sufficient documentation to start with, but there is need for improvement. Netty Documentation is better organized. MINA Documentation needs a better organization. (Blame me for this, I am supposed to take care of this).

Coming up Next

Working of examples on both the frameworks and try to come up with Application Architectures soon.

Assumption

I shall concentrate only on the configuration of UserDetails service. To see it in Action, you can take Spring petclinic tutorial and add the configuration to it.

Let’s briefly lay down the steps needed to implement a Custom UserDetails

•  Implement a Custom User Class that implements UserDetails interface (This class can be customized to fit your needs)
•  Implement Custom UserDetailsService to based on Hibernate
• Configuring in the Spring context

Implementing Custom UserDetails

For simplicity perspective, I shall be omitting Hibernate related configuration from this section

 
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
 
import org.springframework.security.GrantedAuthority;
import org.springframework.security.GrantedAuthorityImpl;
import org.springframework.security.userdetails.UserDetails;
 
public class CustomUser implements Serializable, UserDetails {
         private static final long serialVersionUID = 1L;
         private long id;
         private String password;
         private String username;
         private Set roles;
 
       public CustomUser() {
       }
 
       public Set getRoles() {
           return roles;
       }
 
      public void setRoles(Set roles) {
            this.roles = roles;
      }
 
     private boolean accountNonExpired;
     private boolean accountNonLocked;
     private boolean credentialsNonExpired;
     private boolean enabled;
 
    public GrantedAuthority[] getAuthorities() {
            List list = new ArrayList();
            for (Authority role : roles) {
                  list.add(new GrantedAuthorityImpl(role.getAuthority()));
            }
           return (GrantedAuthority[])list.toArray(new GrantedAuthority[0]);
    }
}
 

Take a special note of getAuthorities(). This function from UserDetails interface needs to return all the authorities for the given user. You can store Roles in whichever format you desire, and can translate them here. For simplicity sake, here is my Authorities class.

public class Authority implements Serializable {
        private static final long serialVersionUID = 1L;
        private long id;
        private String username;
        private String authority;
}

Implementing Custom UserDetailsService

Here using spring comes very handy. We extend HibernateDaoSupport and get most of the desired Hibernate functionality. Lets take a look at the class.

 
 
import java.util.List;
import org.springframework.dao.DataAccessException;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.security.userdetails.UserDetails;
import org.springframework.security.userdetails.UserDetailsService;
import org.springframework.security.userdetails.UsernameNotFoundException;
 
public class HibernateUserDetailsService extends HibernateDaoSupport implements UserDetailsService {
      public UserDetails loadUserByUsername(String username)
                         throws UsernameNotFoundException, DataAccessException {
              List results = getHibernateTemplate().find("from CustomUser where username = ?",
                                                                        new Object[] {username});
 
              if(results.size() < 1) {
                     throw new UsernameNotFoundException(username + "not found");
               }
               return (UserDetails) results.get(0);
       }
}

Well, its that simple. We just implement loadUserByUsername(String username) function and inside that we query for the specified user using the HibernateTemplate

Configuration

It’s time to tell Spring Security to use our custom UserDetails and UserDetailsService. Ensure that petclinic application is using Hibernate Context file (applicationContext-hibernate.xml). Check the same in web.xml. Let’s take a look at what’s the configuration we need to do

 
<b:bean id="userDetailsService" class="com.ap.user.HibernateUserDetailsService">
		<b:property name="hibernateTemplate" ref="hibernateTemplate" />
</b:bean>
<authentication-provider user-service-ref="userDetailsService">
</authentication-provider>
 

Add the bean definition and update the authentication-provider configuration to use our UserDetailsservice. Restart and Spring Security shall use our Custom UserDetails.

Troubleshooting

It took me a while before I could implement this, and though of sharing the mistakes, so that you don’t repeat them

• Test User/Authority Hibernate class in isolation – I did it initially and my test suite was not complete as to detect that all the authorities were being set for the user. This let me to dig into the Spring Security code, add traces and realizing that it’s my mistake.

• Ensure that you maintain roles with a prefix ROLE_ (case-sensitive). If you choose otherwise, you have to set the prefix as desired for authorization.

This post talks about ways of sending Long message using SMPP

Using SMPP we can send long SMS by two means

Using Payload option

Submit SM PDU has a field called message_payload. Set the data in it and you can send upto 64K octets. But this option is not supported by a lot of provider. Verify with your provider, if they support the same.

Using Message fragementation

This format is more common and widely supported. Essentially, the long SMS is divided into smaller messages and send with a particular format, by setting UDH.

The key TLV options used are

sar_msg_ref_num - The reference number for a particular concatenated short message

sar_total_segments - Indicates the total number of short messages within the concatenated short message

sar_segment_seqnum - Indicates the sequence number of a particular short message fragment within the concatenated short message

How do you set these, depends upon the SMPP library you use. Will brief the algo

• Break the long sms into parts, so that fragement can fit into single Submit SM PDU
• The total number of fragements shall give the value of sar_total_segments
• Generate a unique identifier value, this becomes the values of sar_msg_ref_num
• Now in a loop send the message fragements, with values in step above. sar_segment_seqnum values shall be the value of the loop count (ensure that it starts from 1)

This is it