package com.javapapers.sample;

import java.util.HashMap;
import java.util.Map;

public class TypeErasure {
	public static void main(String args[]) {

		Map<String, String> languageMap = new HashMap<String, String>();
		languageMap.put("1954", "FORTRAN");
		languageMap.put("1958", "LISP");
		languageMap.put("1959", "COBOL");
		String language = languageMap.get("1954");
		System.out.println("Our favourite language is "+language);
	}
}

In the above code, we instantiate a map saying that the key and values will be String. These are type parameters. It provides you type safety.

Type erasure is a process to remove the types and map it to byte code. Just trying to give a formal definition for type erasure ;-) Type erasure happens at compile time. Java compiler removes those generic type information from source and adds casts as needed and delivers the byte code. Therefore the generated byte code will not have any information about type parameters and arguments. It will look like a old java code without generics. You want to have a look at it?

New as Old!

Compile above given source and get a class file. Then de-compile that generate class file and you will know what is inside. You may use JAD to de-compile. Else you can avoid the round trip and use the JDK itself directly on java source and find out how the compiled source will look like. javac -XD-printflat -d .java

package com.javapapers.sample;

import java.io.PrintStream;
import java.util.HashMap;
import java.util.Map;

public class TypeErasure
{

    public TypeErasure()
    {
    }

    public static void main(String args[])
    {
        Map languageMap = new HashMap();
        languageMap.put("1954", "FORTRAN");
        languageMap.put("1958", "LISP");
        languageMap.put("1959", "COBOL");
        String language = (String)languageMap.get("1954");
        System.out.println((new StringBuilder("Our favourite language is ")).append(language).toString());
    }
}

You should note two things in the above de-compiled code.

1. First thing is, “<String, String>” is missing.
2. Second thing is (String)languageMap.get(“1954″) a type cast is added.

This is done by the java compiler while compiling java source code to byte code. This process is called java type erasure.

Main reason behind having type erasure at compile time is to give compatibility with old versions of java code where you don’t have generics. If you look at the definition of Map intereface using source available in JDK (beyond 1.5 ), it will be like

public interface Map<K,V> {

So if you use the Map without generics that should work with latest code. Thats why the java type erasure is brought in. When you use generics compiler checks whether you use all you type properly or not. If something is wrong you get an error at compile time and you need not wait until run time and blow up your production.

Consequences of Type Erasures

A java class with parametrized type cannot be instantiated as it requires a call to constructor. At run-time the type is not available because of type erasure and the instantiation cannot be done.

T instantiateElementType(List<T> arg)
{
  return new T(); //causes a compilation error
}

Because of type erasure, at run-time you will not be able to find out what was the predefined type. There are hacks available using Reflection, but it is not guaranteed that it will work in all cases. It is also not a formal way.

There is lots of discussions on whether you need type erasure or is it implemented in a good way is going around. Leave that aside. If you use java, its better to use generics as much as possible. Advantage you get in using generics is type safety and clarity in your code. Though type erasure is good or bad, better know about it. Because it is the one that translates your generic java code to byte code.

I thought of experimenting using a little known class from sun package. Unsafe is a class that belongs to sun.misc package. For some of you the package might be new. You need not worry about it. If you have sun’s JDK then you have this class already.

When a class name is “Unsafe” in java, it calls for your attention immediately. Then I decided to dig deep into it and find what is unsafe about that class. Voila, it really opens up the pandora’s box. Its difficult to find the source of Unsafe. Get the source and look at the methods you will know what I am referring to.

Java’s security manager provides sufficient cover and ensures you don’t fiddle with memory that easily. As a first step, I thought of getting the memory location of a java object. Until the exploration, I too was 100% confident that it was not possible to find the location / address of an object in java.

Sun’s Unsafe.java api documentation shows us an opportunity to get the address using the method objectFieldOffset. That method says, “Report the location of a given field in the storage allocation of its class“. It also says, “it is just a cookie which is passed to the unsafe heap memory accessors“. Whatsoever, I am able to get the storage memory location of an object from the storage allocation of its class.

You can argue that, what we have got is not the absolute physical memory address of an object. But we have got the logical memory address. The following program will be quite interesting for you!

As a first step, I have to get an object of Unsafe class. It is quite difficult as the constructor is private. There is a method named getUnsafe which returns the unsafe object. Java’s security manager asks you to make your java source code privileged. I used little bit of reflection and got an instance out. I know there are better ways to get the instance. But to bypass the security easily I chose the following.

Using Unsafe’s object just invoke objectFieldOffset and staticFieldOffset. The result is address / location of object in the storage allocation of its class.

Following example program runs well on JDK 1.6

import sun.misc.Unsafe;
import java.lang.reflect.Field;

public class ObjectLocation {

 private static int apple = 10;
 private int orange = 10;

 public static void main(String[] args) throws Exception {
  Unsafe unsafe = getUnsafeInstance();

  Field appleField = ObjectLocation.class.getDeclaredField("apple");
  System.out.println("Location of Apple: "
    + unsafe.staticFieldOffset(appleField));

  Field orangeField = ObjectLocation.class.getDeclaredField("orange");
  System.out.println("Location of Orange: "
    + unsafe.objectFieldOffset(orangeField));
 }

 private static Unsafe getUnsafeInstance() throws SecurityException,
   NoSuchFieldException, IllegalArgumentException,
   IllegalAccessException {
  Field theUnsafeInstance = Unsafe.class.getDeclaredField("theUnsafe");
  theUnsafeInstance.setAccessible(true);
  return (Unsafe) theUnsafeInstance.get(Unsafe.class);
 }
}

toLowerCase() respects internationalization (i18n). It performs the case conversion with respect to your Locale. When you call toLowerCase(), internally toLowerCase(Locale.getDefault()) is getting called. It is locale sensitive and you should not write a logic around it interpreting locale independently.

import java.util.Locale;

public class ToLocaleTest {
    public static void main(String[] args) throws Exception {
        Locale.setDefault(new Locale("lt")); //setting Lithuanian as locale
        String str = "\u00cc";
		System.out.println("Before case conversion is "+str+" and length is "+str.length());// Ì
        String lowerCaseStr = str.toLowerCase();
		System.out.println("Lower case is "+lowerCaseStr+" and length is "+lowerCaseStr.length());// i?`
    }
}

In the above program, look at the string length before and after conversion. It will be 1 and 3. Yes the length of the string before and after case conversion is different. Your logic will go for a toss when you depend on string length on this scenario. When your program gets executed in a different environment, it may fail. This will be a nice catch in code review.

To make it safer, you may use another method toLowerCase(Locale.English) and override the locale to English always. But then you are not internationalized.

So the crux is, toLowerCase() is locale specific.

Then what do you need to do for Applet to get that privilege? You need to explicitly grant those security privileges by creating a policy file. In that policy you specify what are all the privileges you are granting.

There is another option also. It is opposite of the above. You say that this code doesn’t require any security policy and it is privileged to do the same (anything) as system code. Do you smell something evil here? This is a risky thing to do. Giving away the security is OS dependent. “Privileged code + malicious user + hole in OS” will be a worst thing to tackle.

Therefore you need to keep the code block as minimum as possible, for which you are going to give privilege. You might require this in the following scenarios

• To read a file
• To read a system property
• To create a network connection to the local machine
• To get direct access to files that contain fonts

How to make java code privileged?

   anyMethod() {
        ...other java code here...
        AccessController.doPrivileged(new PrivilegedAction() {
            public Object run() {
                // put the privileged code here, example:
                System.loadLibrary("awt");
                return null; // in our scenario nothing to return
            }
        });
       ...other code continues...
  }

AccessController API explains more about java privileged code and examples.

There are many fancy tools and framework available to do this. Before using all of those, you need to understand the low level details of serializing a java object to database.

In older days before the advent of JDBC 3.0 you need to completely rely on streams.

1. Stream the object to a ByteArrayOutputStream via an ObjectOutputStream.
2. Convert the ByteArrayOutputStream to a byte array.
3. Call the setBytes method on the prepared statement.

Now you can use Object type support from jdbc to store the object into database.

There are some key factors before performing serialization.
1. Database in use
2. Datatype to be used to persist the object

Also know some fundamentals of serialization.

I have given a sample java source code below to serialize and de-serialize java object to mysql database. In that, I have commented a line
Object object = rs.getObject(1);
Enable this line and comment the following 4 lines and execute and see the result. You will learn one more point.

To de-serialize a java object from database:

1. Read the byte array and put it into a ByteArrayInputStream
2. Pass that to an ObjectInputStream
3. Then read the object.

Sample Java Source Code – Serialize to DB

Before you run the following example, you need to create a database and a table in it.
Run the following query to create a table before running the sample java program.
I used mysql and driver mysql-connector-java-5.0.3-bin.jar. You may use the database of your choice with tweaks to the connection strings.

 create database javaserialization;

 CREATE TABLE `serialized_java_objects` (
 `serialized_id` int(11) NOT NULL auto_increment,
 `object_name` varchar(20) default NULL,
 `serialized_object` blob,
 PRIMARY KEY  (`serialized_id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=latin1;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Vector;

public class SerializeToDatabase {

	private static final String SQL_SERIALIZE_OBJECT = "INSERT INTO serialized_java_objects(object_name, serialized_object) VALUES (?, ?)";
	private static final String SQL_DESERIALIZE_OBJECT = "SELECT serialized_object FROM serialized_java_objects WHERE serialized_id = ?";

	public static long serializeJavaObjectToDB(Connection connection,
			Object objectToSerialize) throws SQLException {

		PreparedStatement pstmt = connection
				.prepareStatement(SQL_SERIALIZE_OBJECT);

		// just setting the class name
		pstmt.setString(1, objectToSerialize.getClass().getName());
		pstmt.setObject(2, objectToSerialize);
		pstmt.executeUpdate();
		ResultSet rs = pstmt.getGeneratedKeys();
		int serialized_id = -1;
		if (rs.next()) {
			serialized_id = rs.getInt(1);
		}
		rs.close();
		pstmt.close();
		System.out.println("Java object serialized to database. Object: "
				+ objectToSerialize);
		return serialized_id;
	}

	/**
	 * To de-serialize a java object from database
	 *
	 * @throws SQLException
	 * @throws IOException
	 * @throws ClassNotFoundException
	 */
	public static Object deSerializeJavaObjectFromDB(Connection connection,
			long serialized_id) throws SQLException, IOException,
			ClassNotFoundException {
		PreparedStatement pstmt = connection
				.prepareStatement(SQL_DESERIALIZE_OBJECT);
		pstmt.setLong(1, serialized_id);
		ResultSet rs = pstmt.executeQuery();
		rs.next();

		// Object object = rs.getObject(1);

		byte[] buf = rs.getBytes(1);
		ObjectInputStream objectIn = null;
		if (buf != null)
			objectIn = new ObjectInputStream(new ByteArrayInputStream(buf));

		Object deSerializedObject = objectIn.readObject();

		rs.close();
		pstmt.close();

		System.out.println("Java object de-serialized from database. Object: "
				+ deSerializedObject + " Classname: "
				+ deSerializedObject.getClass().getName());
		return deSerializedObject;
	}

	/**
	 * Serialization and de-serialization of java object from mysql
	 *
	 * @throws ClassNotFoundException
	 * @throws SQLException
	 * @throws IOException
	 */
	public static void main(String args[]) throws ClassNotFoundException,
			SQLException, IOException {
		Connection connection = null;

		String driver = "com.mysql.jdbc.Driver";
		String url = "jdbc:mysql://localhost/javaserialization";
		String username = "root";
		String password = "admin";
		Class.forName(driver);
		connection = DriverManager.getConnection(url, username, password);

		// a sample java object to serialize
		Vector obj = new Vector();
		obj.add("java");
		obj.add("papers");

		// serializing java object to mysql database
		long serialized_id = serializeJavaObjectToDB(connection, obj);

		// de-serializing java object from mysql database
		Vector objFromDatabase = (Vector) deSerializeJavaObjectFromDB(
				connection, serialized_id);

		connection.close();
	}
}

Output of the above java program

Java object serialized to database. Object: [java, papers]
Java object de-serialized from database. Object: [java, papers] Classname: java.util.Vector

As almost everybody ;-) in the web world I also got my due share of problems from Go Daddy. It all started with trying to host multiple domains using the same hosting account. Economy pack didn’t have multiple hosting option and I was asked to upgrade to next higher plan by paying more bucks. Without spending much time on research I paid the amount. How stupid I was!

What I finally got was a hosting account mapped to one primary domain with all the sub domains visible through the primary one! I raised support requests. I got prompt replies. But I feel like yelling here. All the replies I got are from their robots! Can you imagine they have a software robot to reply for customers. If their robot is that much intelligent they need not be in hosting business. They would be providing software products for NASA.

It just grabs the keywords and responds with same pre-formatted template replies. I tried my BEST to reach a real person and all went in vain. This is what triggered me to look for options. One more issue I was living with from day one is too much advertisement. Their control panel is a crap. To find even a log out link it will take minutes. I was with Godaddy for atleast three years and got used to this interface nightmare.

One more issue (problems list with Godaddy is quite long) was, I am not able to map to a third part DNS server for a domain name. I had a domain registered with them and I was trying to point it to a third party hosting provider. Initially it gets set. But after a week or so (I am not able to find out the window period) they reset it to their own DNS server and a default page, which has tons of garbage advertisements.

I tried couple of times to point it back to my server, but I think they have a cron job to redo it again on a defined interval. This is a serious issue in the hosting world. I know this might be a very odd case but the real problem is I couldn’t get help from their support staff. Finally I was determined to ditch Godaddy and move to a new hosting provider.

This time I did volume of research on hosting providers. Cheap providers are off my list and I had quality as first criteria. I got some three providers. Then finally narrowed down it to mediatemple. Yes it is little heavy on bills, but I heard every penny is worth it. Multiple domain hosting option is a real carrot from them and the clean plesk control panel. I took the bait.

It was a very difficult process from moving the application, data from one hosting provided to another. Main thing is to avoid the downtime in between. You migth blackout and that might cause serious damage to rankings in search engines. I had to go through volume of blog posts and help documents. Finally I got succeeded without any damage.

In transfer of data, mediatemple phpmyadmin’s response is slow. Sometimes even I thought server is down. This is the only issue I got so far. As data import is a very rare job, I am not much worried about it. It is smooth sailing thereafter. Its been a week and there is no incident. We need to wait and see for performance of the mediatemple’s famed servers.

Voila, now javapapers is served to you from mediatemple. Of course with little extra cost for which I got extra quality. I got clean interface to deal with, excellent multiple site hosting option and above all a real person to get support. Do you realize that the pages are rendered quicker by fraction of a second ;-) Bye bye Godaddy.

Wish you a Happy New Year 2010!