static public void printDomainDetails(String domain)
			throws UnknownHostException, NamingException
	{
		InetAddress netAddress = InetAddress.getByName(domain);
		String ipAddress = netAddress.getHostAddress();

		System.out.println(domain + " / " + ipAddress);

		InitialDirContext initialDirContext = new InitialDirContext();

		// get the DNS records:
		Attributes attributes = initialDirContext.getAttributes(
												"dns:/" + domain);

		// get an enumeration of the attributes:
		NamingEnumeration<? extends Attribute> attributeEnumeration
												 = attributes.getAll();

		System.out.println("DNS Details:");
		while (attributeEnumeration.hasMore())
		{
			Attribute attribute = attributeEnumeration.next();
			System.out.println(attribute.toString());
		}
		attributeEnumeration.close();
	}

Get Current Date

Date date = new Date();
Calendar calendar = Calendar.getInstance();

Convert from/to Date to/from Calendar

Date date = new Date();
Calendar calendar = Calendar.getInstance();

date = calendar.time();
calendar.setTime(date);

Format Date To String

Date date = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
String dateAsString = dateFormat.format(date);
System.out.println(dateAsString);

Parse Date String

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date date = dateFormat.parse(dateAsString);

Add/Substact Days to Current Date

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Calendar calendar = Calendar.getInstance(); // get current date as calendar object
calendar.add(Calendar.DATE, 1);	//Add 1 day to calendar date
calendar.add(Calendar.DATE, -2);	//Substract 2 days to calendar date
String dateAsString = dateformat.format(calendar.getTime());
System.out.println(dateAsString);

Add/Substact Years/Months/Days/Hours/Minutes/Seconds to Current Date

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Calendar calendar = Calendar.getInstance(); // get current date as calendar object
calendar.add(Calendar.YEAR, 1);	//Add 1 year to calendar date
calendar.add(Calendar.YEAR, -2);	//Substract 2 years to calendar date
calendar.add(Calendar.MONTH, 1);	//Add 1 month to calendar date
calendar.add(Calendar.MONTH, -2);	//Substract 2 months to calendar date
calendar.add(Calendar.DATE, 1);	//Add 1 day to calendar date
calendar.add(Calendar.DATE, -2);	//Substract 2 days to calendar date
calendar.add(Calendar.HOUR, 1);	//Add 1 day to hourr date
calendar.add(Calendar.HOUR, -2);       //Substract 2 hours to calendar date
calendar.add(Calendar.MINUTE, 1);       //Add 1 minute to calendar date
calendar.add(Calendar.MINUTE, -2);      //Substract 2 minutes to calendar date
calendar.add(Calendar.SECOND, 1);       //Add 1 second to calendar date
calendar.add(Calendar.SECOND, -2);     //Substract 2 seconds to calendar date
String dateAsString = dateformat.format(calendar.getTime());
System.out.println(dateAsString);

First of all you have to use Statement.addBatch/executeBatch instead of simple execute methods. For each added batch, the jdbc driver will store in local memory and when the executeBatch is invoked, all the batches are sent at once to the database. This will result in an huge speed improvement.

When you deal with such operations you should keep an eye one the memory allocated to the java process. The JDBC driver(Connector/J) will use the heap memory to build the batch until is executed. In order to make sure you don’t run out of memory you have to executeBatch method from time to time.

When you deal with mySQL database you can make and additional speed improvement. This can be applied for the cases when you have to insert values in the database(which is the probably the case because 90% of large amount data operations are imports).

When you configure the JDBC connection with “rewriteBatchedStatements=true”, the driver takes the statements in the form “INSERT INTO foo VALUES (…)” and rewrites them as “INSERT INTO foo VALUES (…), (…), (…)”. You can see here benchmarks which records 10x performance increase. Yu have to make sure you have the latest Connector/J version to to squeeze the best performance out of it(at least 5.1.8).

static protected String INSERT_GAME_SQL =
	"INSERT INTO tablename(name, category, title, description"
	", metascore) VALUES(?, ?, ?, ?, ?)";

public void batchInsert()
			throws SQLException {
	try
	{
		Class.forName("com.mysql.jdbc.Driver").newInstance();
		connection = DriverManager.getConnection(
connectionString + "?rewriteBatchStatements=true",user,passwd);

		connection.setAutoCommit(false);
		PreparedStatement statement = connection.prepareStatement(
INSERT_SQL_STATEMENT);

		for (int i = 0; i < limit; i++)
		{
			statement.setString(1,  "value1");
			statement.setString(2,  "value2");
			statement.setString(3,  "value3");
			statement.setString(4,  "value4");
			statement.setInt(5,  134);

			statement.addBatch();

			if ( i % 1000 == 0) {
				statement.executeBatch();// Execute every 1000 items
			}
		}

		statement.executeBatch();
		connection.commit();
	}
	catch(SQLException e)
	{
		connection.rollback();
		throw e;
	}
	finally
	{
		// if not required anymore:
		//close statement
		//close connection
	}
}

	static public void download(String address, String localFileName)
											throws MalformedURLException
												 , FileNotFoundException
												 , IOException
	{

		URL url = new URL(address);

		OutputStream out = new BufferedOutputStream(
								new FileOutputStream(localFileName));
		URLConnection conn = url.openConnection();
		InputStream in = conn.getInputStream();

		byte[] buffer = new byte[1024];
		int numRead;
		int progress = 0;
		while ((numRead = in.read(buffer)) != -1) {
			out.write(buffer, 0, numRead);
			progress += 1024;
			System.out.print("\r" + (int)(progress / 1000)+ "kb");
		}            

		in.close();
		out.close();
	}

Starting with the version 4 the classes were drastically changed. Old tutorials don’t works anymore and the class names and methods were changed to some degree which makes old code pretty useless if you want to switch to a version 4.

Here is a small snippet which shows how to invoke a webpage via post method and how to pass post parameters. In real scenarios post parameters can be used to pass login informations. The snippet uses the method to Convert Input Stream To String from the previous post:

package com.factorypattern.httpclient;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;

public class PostRequestClient {

	public static void main(String[] args) throws Exception {

		// prepare post method
		HttpPost post = new HttpPost("http://mydomain.com/");

		// add parameters to the post method
        List <NameValuePair> parameters = new ArrayList <NameValuePair>();
        parameters.add(new BasicNameValuePair("param1", "value1"));
        parameters.add(new BasicNameValuePair("param2", "value2")); 

        UrlEncodedFormEntity sendentity = new UrlEncodedFormEntity(parameters, HTTP.UTF_8);
        post.setEntity(sendentity); 

        // create the client and execute the post method
		HttpClient client = new DefaultHttpClient();
        HttpResponse response = client.execute(post);

        // retrieve the output and display it in console
        System.out.print(convertInputStreamToString(response.getEntity().getContent()));
        client.getConnectionManager().shutdown();
	}

	/**
	 * method to convert an InputStream to a string using the BufferedReader.readLine() method
	 * this methods reads the InputStream line by line until the null line is encountered
	 * it appends each line to a StringBuilder object for optimal performance
	 * @param is
	 * @return
	 * @throws IOException
	 */
	public static String convertInputStreamToString(InputStream inputStream) throws IOException
	{
		if (inputStream != null)
		{
			StringBuilder stringBuilder = new StringBuilder();
			String line;

			try {
				BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
				while ((line = reader.readLine()) != null)
				{
					stringBuilder.append(line).append("\n");
				}
			}
			finally
			{
				inputStream.close();
			}

			return stringBuilder.toString();
		}
		else
		{
			return null;
		}
	}
}

Lots of libraries returns objects of type InputStream and sometimes you know the stream small and you just need the data as a simple String. Here is the snippet written as a static method to transfer the data from a InputStream to a String.

The method reads the InputStream line by line (using BufferedReader.readLine()) until the null line is encountered. It appends each line to a StringBuilder object for optimal performance and returns it as a String:

	/**
	 * method to convert an InputStream to a string using the BufferedReader.readLine() method
	 * this methods reads the InputStream line by line until the null line is encountered
	 * it appends each line to a StringBuilder object for optimal performance
	 * @param is
	 * @return
	 * @throws IOException
	 */
	public static String convertInputStreamToString(InputStream inputStream) throws IOException
	{
		if (inputStream != null)
		{
			StringBuilder stringBuilder = new StringBuilder();
			String line;

			try {
				BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
				while ((line = reader.readLine()) != null)
				{
					stringBuilder.append(line).append("\n");
				}
			}
			finally
			{
				inputStream.close();
			}

			return stringBuilder.toString();
		}
		else
		{
			return null;
		}
	}

For example we can build a rectangle class using using the Method Chaining for setters. You can see the setters are a little bit different than regular setters:

class ChainedRectangle
{
    protected int x;
    public ChainedRectangle setX(int x) { this.x = x; return this; }

    protected int y;
    public ChainedRectangle setY(int y) { this.y = y; return this; }

    protected int width;
    public ChainedRectangle setWidth(int width) { this.width = width; return this; }

    protected int height;
    public ChainedRectangle setHeight(int height) { this.height = height; return this; }

    protected String color;
    public ChainedRectangle setColor(String color) { this.color = color; return this; }
}

Then if we need to build a rectangle we can write a single line for setting all the required values:

new         Rectangle().setX(10).setY(10).setWidth(13).setHeight(15).setColor("red");

Along with autocomplete option in most of todays IDEs method chaining might provide a suggestive way of doing some actions in less code.

For example we can write a simple class to build sql queries. Then we can invoke in a simple way.

public class Query
{
    protected String queryString = "";

    public Query select(String what)
    {
        queryString = "SELECT " + what;
    }

    public Query from(String from)
    {
        queryString = " FROM " + from;
    }

    public Query where(String where)
    {
        queryString = " WHERE " + where;
    }

    public ResultSet Invoke()
    {
        //... database invocation bla bla
        return result;
    }
}

Then, to build the query we invoke:

new Query().select("*").from("table").where("a=b").Invoke();

One of the problems of the Method Chaining pattern is the fact that it can not ensure the order of the invoked method. In order to do that each method can return a specific interface object which implements only the allowed methods.

For example we define an interface ISelectedQuery with a single method from, IFromQuery with a single method where. ISelectedQuery.from returns and object of type IFromQuery and IFromQuery returns a Query object. All the interfaces are implemented by the Query object. That way the order of invoking the methods is ensured.

Here is how the code looks like:

public interface ISelectedQuery
{
    IFromQuery from(String from);
}

public interface IFromQuery
{
    Query where(String where);
}

 public class Query implements ISelectedQuery, IFromQuery
{
    protected String queryString = "";

    public ISelectedQuery select(String what)
    {
        queryString = "SELECT " + what;
        return this;
    }

    public IFromQuery from(String from)
    {
        queryString = " FROM " + from;
        return this;
    }

    public Query where(String where)
    {
        queryString = " WHERE " + where;
        return this;
    }

    public ResultSet Invoke()
    {
        //... database invocation bla bla
        return result;
    }
}

The above code ensure that only the right methods can be invoked. Further more the syntax autocomplete option from most of today IDEs will show in the drop down only the right method(s).

Cache and memory cache exists for a long time; even the hardware parts link hard disks cd units have some sort of memory cache.

Why memory cache becomes so important when we talk about web applications? It’s simple. Because web applications happens to fulfill thousands of requests simultaneously. Or sometimes they have to. It’s obvious that keeping the data into memory and reuse it the next time you need it it will improve the performance. And it looks very simple. At the first view simple hashmap would do the job, unless…

There a few facts we need to be consider in real world:

• What happens when the database is updated?
• In most cases a web application create a thread for each http request. The same thing happens in java of php or other languages. The creation of the threads is handled by the web server, web container, and not by the code we write.
• The scalable applications run distributed on multiple servers. If one application change the database, the cache system should be informed on all the machines.

The cache cache is very simple. If the data can be retrieved from cache it will be retrieved from cache. If not then it should be retrieved from database and put in cache:

if (data is in cache)
   retrieve data from cache
if (data not in cache)
   retrieve data from database
   add data to cache
use data

How to handle database updates?

Even if we have a simple application and we use a simple hashmap as a memory cache we still have to address this issue. When we update a database the cache should be updated with the new data or the old data should be removed from the cache.

Each time we update something in the database we have to remove the updated entities from the cache. We should take a special care because we our changes might affect other entities kept in cache:

update database  
invalidate saved and affected entities from cache

Memory Cache in Web Applications

As I said web applications are special applications. For each http request a thread will be created. In order to make sure that everything will work fine we must ensure that:
- All the http request threads will access the same data in cache. There a many ways to achieve it, singletons can be taken into discussion.
- The way the data is accessed is synchronized – one thread will not read the data while another one is updating it.

Distributed applications

The applications where memory cache is required are the applications with many users and usually they run in distributed environments. There are options here:
- each server instance will have its own memory cache. If in one instance an entity is changed the affected entities should be invalidated in the cache on all the other server instances. The server instance changing the database will have to trigger the propagation the changes to other server instances.
- the cache will run as a separate process and all the server instances will use it in common, connecting remotely to read/invalidate cached data.

This techniques can not be used in distributed environments. If we use it we’ll have one injector instance on each JVM because on distributed environments for each JVM there is one ServletContext. ServletContext on one JVM is not visible from another JVM, so if we can not use guice scopes distributed on multiple machines.

Initializing Guice Injector in ServletContext

As we said there is only one instance of javax.servlet.ServletContext(as long as we don’t have a distributed application). We can trigger the initialization of the ServletContext using ServletContextListener. All we have to do is to implement the ServletContextListener.contextInitialized to create the google guice injector, and to set it as an attribute in the ServletContext:

package com.exam.web.guice;

import java.lang.reflect.InvocationTargetException;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Module;

public class GuiceServletContextListener implements ServletContextListener {
    public static final String KEY = Injector.class.getName(); 

    public void contextInitialized(ServletContextEvent servletContextEvent)
    {
    	servletContextEvent.getServletContext()
    		.setAttribute(KEY, getInjector(servletContextEvent.getServletContext()));
    } 

    public void contextDestroyed(ServletContextEvent servletContextEvent) {
    	servletContextEvent.getServletContext().removeAttribute(KEY);
    } 

    @SuppressWarnings("unchecked")
    private Injector getInjector(ServletContext servletContext) {
        String className = servletContext.getInitParameter("module");
        try {
            Class module = (Class) Class.forName(className);
            return Guice.createInjector(module.getConstructor().newInstance());
        }
        catch (ClassNotFoundException e) { throw new RuntimeException(e); }
        catch (NoSuchMethodException e) { throw new RuntimeException(e); }
        catch (InvocationTargetException e) { throw new RuntimeException(e); }
        catch (IllegalAccessException e) { throw new RuntimeException(e); }
        catch (InstantiationException e) { throw new RuntimeException(e); }
    }
}

Then we have to change the web.xml to define the listener to be used by the web application container:

            com.exam.web.guice.GuiceServletContextListener
        
    

Storing module configuration in web.xml

We use web.xml to define which module to be used by Guice in block. When we create the guice injector the parameter is read and used:

String className = servletContext.getInitParameter("module");

The class name is defined like this in web.xml:

     
module
com.webapplication.bus.HibernateDaoModule
        Guice Module to be used for the servlets app
    

Finally in the servlet we can use this expression to get the injector:
(Injector) servletContext.getAttribute(GuiceServletContextListener.KEY)

We can add an injector field to the servlet and “inject” the injector into it when the servlet is initialized(a super servlet class can be created to define this code in only one place):

public class MyServlet  extends HttpServlet {

	Injector injector;
        ...

	@Override
	public void init(ServletConfig config) throws ServletException {

        HibernateUtil.Configure(true);  

	    ServletContext servletContext = config.getServletContext();
	    injector = (Injector) servletContext.getAttribute(GuiceServletContextListener.KEY);
	    injector.injectMembers(this);

	    managersRegistry = injector.getInstance(ManagersRegistry.class);

		super.init(config);
	}
}

Now, lets cut the chat. Here is the script(maven-env.vbs) which sets the environments required by maven2 according to the instructions and add the bin folder to the class path:

Dim WSHShell
Set WSHShell = WScript.CreateObject("WScript.Shell")

WScript.Echo "The current PATH is:" & chr(10) & chr(10) & Replace(WSHShell.Environment.item("PATH"),";", chr(10))

WScript.Echo "Current values of the variables to be changed or added:" & chr(10) _
	& "M2_HOME=" & WSHShell.Environment.item("M2_HOME") & chr(10) _
	& "M2=" & WSHShell.Environment.item("M2")
	
'maven environment variables are created according to http://maven.apache.org/download.html#Installation
WSHShell.Environment.item("M2_HOME") = "C:\java\apache-maven-2.0.9"
WSHShell.Environment.item("M2") = "%M2_HOME%\bin"
WSHShell.Environment.item("PATH") = WSHShell.Environment.item("path") & ";%M2%"

Set WSHShell = Nothing    
WScript.Quit(0)

I’m using the first echo line in a separate script to display the path and to display one directory on each line replacing ; with end of line(chr(0) represents end of line). If you want to change registry values you can use:

WSHShell.RegWrite "HKCU\path\key", "value"
WSHShell.RegRead("HKCU\path\key")

If you need to know that script for more advanced operation you can check VBScript Functions