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).

Related Posts

• No Related Post

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

Related Posts

• No Related Post

There are various reasons when we have to wrap java exceptions. Often those reasons are called: Checked Exceptions. According to the definition there are 2 types of exceptions:

• Checked Exceptions – Exceptions that are not descending from RuntimeException are called checked exceptions. Checked exceptions must be handled by a try catch mechanism or by adding the throws declaration to the method. If neither of those is done then the compiler throws an exception.
• Unchecked Exceptions – The exceptions that are not checked, of course. They are inherited from RuntimeException and no handling is enforced by the compiler. Simply put you don’t have to check them.

But Why?

In practice using checked exceptions will lead to undesired behavior. Here are a few scenarios:

• Let’s assume we have to use a method called getProperty(String key) throws SQLException defined in DBConfig to read a color property from the database and then to display it on screen. We instantiate the config object and then invoke the method. For avoiding a compiler exception we’ll add a throws SQLException to our method declaration. And then imagine that you have to add another one to the method invoking the method we wrote. The more mothods are involved the more checked exceptions added to the method declaration. It doesn’t make sense for a method called paintScreen to force you to handle excpetions like SQLException or IOException, doesn’t it?

• Now we are going to add an interface named IConfig. We’ll have the existing class DBConfig and we’ll create another one FileConfig. The first one will throw SQLException and the second one IOException. If we’ll have too many checked exceptions we’ll pollute the interface with exceptions that might depend on implementation, inducing a tight coupling in our classes: the abstraction depends on modules exceptions. Pretty bad, isn’t it?

• Now the bad practice: We’ll not going to use throws declaration. Not at all, because it generates too many problems. So let’s just try, catch, printstacktrace and that’s it. We’ll see later what to do. This is fast. This practice is again bad, because it just hide the problems. Especially in large applications with many programmers they tend to forget about the caught exceptions and real problems are not discovered. After all remember that exceptions are meant to signal a real abnormal behavior of the application.

• There is also another reason that make us wrapping exceptions which is not related to checked or unchecked exceptions. Sometimes we simply want to hide and separate the implementation details from the exposed interface in order to reduce the complexity and to simplify the interface.

Ok, then. But How?

We have 2 simple options:

• To wrap the exceptions in such a way that the original exception object is not used.and only the message as String is encapsulated in the new exception.
• Create another exception that contains references to the thrown exception

There is a very thin line between those 2 options and you have to understand it very well. First of all let’s think about it. The module which invokes the code throwing exceptions will have the wrapped class in the class path? If the response is definitely an yes then go for second point, otherwise choose the first one.

For example a client invokes remotely your api using rmi. The api throws the exception wrapped but the client have only the wrapper exception class in the classpath, not the wrapped one. An exception will be thrown. In cases like this one runtime exception should be created containing a descriptive message and should not wrap the original exception.

Related Posts

• No Related Post

Context Parameters

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
  <context-param>
    <description>This is a context parameter example</description>
    <param-name>ContextParam</param-name>
    <param-value>ContextParam value</param-value>
  </context-param>
...
<web-app>

The following code can be be invoked from a servlet or a filter to retrieve the ContextParam value. The parameter can be read successfully from any servlet or filter class.

@Override
	public void init(ServletConfig config) throws ServletException {
		String contextParam = config.getServletContext().getInitParameter("ContextParam");
	}

//or
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp)
			throws ServletException, IOException {
		String contextParam = this.getServletContext().getInitParameter("ContextParam");
		...
	}
	...
}

String value = this.getServletContext().getInitParameter("ContextParam");

Init Parameters

...
<servlet>
    <servlet-name>A Servlet</servlet-name>
    <servlet-class>com.controller.TestServlet</servlet-class>
    <init-param> 
        <description>This is an init parameter example</description> 
        <param-name>InitParam</param-name> 
        <param-value>init param value</param-value> 
    </init-param> 
</servlet>
...

The following code can be be invoked to retrieve the value of InitParam. The parameter can be accessed only from com.controller.TestServlet.

public class DefaultController extends HttpServlet
{
	@Override
	public void init(ServletConfig config) throws ServletException {
		String initParam  = config.getInitParameter("InitParam");
	}

//or
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp)
			throws ServletException, IOException {
		String initParam = getServletConfig().getInitParameter("InitParam");
		...
	}
	...
}

Iterating through context-params and init-params

It’s possible to iterate through the paramters if required:

public class DefaultController extends HttpServlet
{
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp)
			throws ServletException, IOException {
		Enumeration contextParams = getServletContext().getInitParameterNames();

		Sytem.out.println("context-params: ");
		while (params.hasMoreElements()) {
			String name = (String) params.nextElement();
			Sytem.out.println(name + " = " + config.getInitParameter(name));
		}

		Enumeration initParams = getServletConfig().getInitParameterNames();

		Sytem.out.println("init-params: ");
		while (params.hasMoreElements()) {
			String name = (String) params.nextElement();
			Sytem.out.println(name + " = " + config.getInitParameter(name));
		}

		...
	}
	...
}

Related Posts

• No Related Post

Before giving a few examples about it, a few words about Google Collections. This is a really light java framework, build in one jar of about 300 kb. Currently only the Alpha version is released, but it doesn’t mean it’s not tested. In the Google Collection FAQ on Google Code the authors explain what 0.5 Alpha means” “We already use this library extensively in production for services like GMail, Reader, Blogger, Docs & Spreadsheets, AdWords, AdSense and dozens more. We consider it to be pretty safe. However, during the alpha period, we do reserve the right to make changes of any kind to it at any time.”

All you have to do is to download the latest Google Snapshot, unzip google-collect-snapshot-20080321.jar and then add it to your classpath. In our sample we are going to use one class and one interface (classes link to javadocs): com.google.common.collect.HashMultimap, com.google.common.collect.Multimap. Here is an example of Google Collection in action:

Multimap multimap = new HashMultimap();
multimap.put("key1", "value1A");
multimap.put("key2", "value1A");
multimap.put("key1", "value1B");
System.out.println(multimap.get("key1").toString());

Something similar using Generics:

Multimap> peoples = new HashMultimap>();

Multimap vehicles = new HashMultimap();
vehicles.put("Ferrari", "Silver Ferrari");
vehicles.put("Ferrari", "Red Ferrari");
vehicles.put("Car", "Honda Civic");
vehicles.put("Bycicle", "33 Gears Bycicle");
peoples.put("Kevin S.", vehicles);

System.out.println(peoples);

And the final snippet using some classes created by us. We use Google Collection to keep some existing ‘has’ relations:

Multimap> samepeoples = new HashMultimap>();
Multimap newvehicles = new HashMultimap();
newvehicles.put("Porsche", new Car("Silver Porsche"));
newvehicles.put("Porsche", new Car("Red Porsche"));
newvehicles.put("Car", new Car("Honda Civic"));
newvehicles.put("Bycicle", new Bycicle("33 Gears Bycicle"));
samepeoples.put(new Person("Kevin S."), newvehicles);

System.out.println(samepeoples);

The result of the test program printed to the console:

[value1B, value1A]
{Kevin S.=[{Car=[Honda Civic], Ferrari=[Red Ferrari, Silver Ferrari], Bycicle=[33 Gears Bycicle]}]}
{Kevin S.=[{Car=[Honda Civic], Porsche=[Silver Porsche, Red Porsche], Bycicle=[33 Gears Bycicle]}]}

Here are the classes I created to for the previous snippet:

class Person {
	private String name;
	public Person(String name)
	{
		this.name = name;
	}
	public String toString()
	{
		return name;
	}
}
class Vehicle {
	private String name;
	public Vehicle(String name)
	{
		this.name = name;
	}
	public String toString()
	{
		return name;
	}
}
class Car extends Vehicle {
	public Car(String name)
	{
		super(name);
	}
}
class Bycicle extends Vehicle {
	public Bycicle(String name)
	{
		super(name);
	}
}

Many situations occurred in the past when I had to organize some data in some hierarchical structures. I didn’t want to create some classes keep hierarchical structures so I used hashmaps, hashtables or even sets or lists, storing Set or some other collection as values. Some sort of sets of sets, maps of lists and so on. The Multimap comes to fulfill this need and opens the way for a multitude of uses of collections. Until now, when I thought how I used the collections I felt a little bit that I’m doing something wrong since is not something that Java Collection was providing. Now, that I know that Google has this class I feel better.

Just think to the coupling degree if we modify the classes to keep association relations. For example a Person class should be enhanced to keep collection of Vehicles so the person class will be coupled with the Vehicle interface. If we just want to add some 1-to-many relations between some existing classes, changing them might not be the best way of doing it.

Related Posts

• How to Read/Write Java Properties Files
• Google Guice Tutorial
• How To Use Ant
• How to write an Ant xml build file to Generate JAXB Code and Compile and Build it to a Jar

Skipping the technical aspect, I can not ignore a few points.
1. Google releases a Java framework, produced in their free open source code forge, aiming a “market” where there is only one “competitor”, Spring, the only Java IOC Container truly widely used. Guice is not a real Google product, it is resulted from their initiative to support the open source community. The interesting aspect here is the fact that the owner of the project is Google itself, Guice is not only an open source framework hosted on Google Code.

2. Spring is a framework used to integrate any other framework. Guice is intended to be the same. Entire web and enterprise applications can be built on it. It’s something that everyone needs.

3. Guice is more close to the conventional applications, it is not an MashUp Api and is not based on google products like most of the api’s made available for the masses, it’s a framework than can be used for any Java application. In other words Google expands its boundaries toward a more traditional software community.

Guice seems to be really nice and light and many programmers prefer using it, writing java code instead of changing xml files in Spring. You can check the google tech talks presentation on google video:

For more details: Google Guice Home Page
There are many questions emerging here. I’m asking if Google decided to produce open-source software or it’s just supporting the open source community. Are we going to live in a java world where we can use many frameworks called Google Something? Recently Google Collections for Java was released; now it’s just version 0.5, but like Guice it’s a framework that can be the foundation of any application and has the characteristics to achieve the world domination. For a good cause of course.

Related Posts

• Guice Servlets Integration
• Google Guice Tutorial

How To Install Ant

Ant can be installed on almost any operating system in a few easy steps:

1. Install Java Runtime Environment(JRE) or Java Development Kit(JDK). Ant need a JRE or JDK in order to run.
2. 2. Download the ant binary distribution from this link and unzip it to a directory of your choice.
3. 3. Add the location of the bin folder to the path environment variable. For example in windows: PATH=%PATH%;c:\ant\bin
4. 4. Set ANT_HOME environment variable to the location where ant is installed. For example: ANT_HOME=c:\ant

How to create your first ANT project

Any ant project consist of one or more xml files containing the ant tasks. Lets create a small file named “build.xml”, containing only one task to print a small “Hello World!!!”. In order to run you have to go to the directory containing the build.xml file and type and run “ant”.

<project name="how-to-use-ant" basedir="." default="hello-world">

    <target name="hello-world">
        <echo message="Hello World!!!"/>
    </target>
	
</project>

As you noticed we defined in this and project one task named hello-world and this is the default task. If everything goes well, the ant will run (we added in the path the ant bin directory when we installed it) and will print the following text:

Buildfile: build.xml

hello-world:
     [echo] Hello World!!!

BUILD SUCCESSFUL
Total time: 0 seconds

How To Compile and Build Using Ant

In real life we use Ant as the build tool for our applications and Ant is used in 90 percent of the cases for that. I’ve created a separate post to serve as a tutorial. You can check How to Create Jar Files from Ant.

Lets take this time in consideration a real life project. Most of the time Ant is used to compile and build java projects. This means generating, compiling and building jar files. For this we are going to define severals tasks. Lets consider the we create a buid.xml file in the directory where sources are located. The sources are put in the subdirectory called src. We also need to include a jar in the classpath while compiling. We are going to create a separate property file to define the location of this file:

#===================================
#	File Name: build.properties
#===================================

env.LIB=c://java//thirdparty//lib

The ant task contains a few tasks for doing the following operations:
1. Clean the build directory if exists.
2. Create the build directory where the new classes will be built.
3. Compile the java classes.
4. Build a jar file from the java classes.

Here is the build.xml file. Note the dependencies between the tasks and how the properties are defined in the ant xml file or loaded from the properties file:

<project name="how-to-use-ant" basedir="." default="hello-world">

	<property name="build" value="build"/>
	<property file="build.properties"/>
	
	<target name="clean">
		<delete dir="${build}"/>
	</target>

	<target name="init" depends="clean">
		<mkdir dir="${build}"/>
	</target>	
	
	<target name="compile" depends="init">
		<!-- Compile the java code -->
		<javac srcdir="src" destdir="${build}">
			<classpath>
				<pathelement location="${env.LIB}/required-jar1.jar"/>
				<pathelement location="${env.LIB}/required-jar2.jar"/>
			</classpath>
		</javac>
	</target>	
	
	<target name="jar" depends="compile">
		<!-- Build the jar file -->
		<jar basedir="${build}" destfile="${build}/new-jar.jar"/>
	</target>
	
</project>

Now that you’ve seen how to create an ant task you might ask why you need an ant build file for building a jar file. This can be done as well with a few batch commands which will take only a 4 lines bat file. There are certain advantages. The ant files can be easily parametrized and reused, sub projects cand be created, lots of tasks are implemented, covering most of the operations you want to do (junits, sql operations, zip file tasks, tasks for replacing and editing text and xml files, …) and new tasks can be implemented in java and used in any ant file.

Related Posts

• How to write an Ant xml build file to Generate JAXB Code and Compile and Build it to a Jar
• How to Create Jar Files from Ant
• Howto generate Hibernate POJO and mapping files using ant from a db schema
• How to Read/Write Java Properties Files

Mainly you have to use 2 ant tasks after the java code is generated, one for compiling the classes, the other one to package them. In the following example I’m using ant to generate some jaxb classes, then to compile them and build a jar file. In this task there are 2 ant tasks, named compile and jar, responsible for compiling and generating the ant file:

<?xml version="1.0"?>
<project name="bbindings.jaxb" default="jar" basedir=".">

<property name="home" value="."/>
<property name="build" value="build"/>
<property name="logs" value="logs"/>
<property name="src" value="src"/>
<property file="build.properties"/> 

<target name="clean">
	<delete dir="${logs}"/>
	<delete dir="${build}"/>
	<delete dir="${src}"/>
</target>

<target name="init" depends="clean">
	<mkdir dir="${build}"/>
	<mkdir dir="${logs}"/>
	<mkdir dir="${src}"/>
</target>

<target name="copy_xsd" depends="init">
	<copy file="${env.XSD_FILE}" todir="${src}"/>
</target>       

<target name="generate_jaxb" depends="copy_xsd">
	<java jar="${env.JWSDP_HOME_LIB}\jaxb-xjc.jar" fork="true" dir="${src}">
		<arg value="-p"/>
		<arg value="com.bbindings.jaxb"/>
		<arg value="${home}/${env.XSD_FILE}"/>
	</java>
</target>  

<target name="compile" depends="init,generate_jaxb">
	<!-- Compile the java code -->
	<javac srcdir="${src}" destdir="${build}">
		<classpath>
			<pathelement location="${env.JWSDP_HOME_LIB}/jaxb-api.jar"/>
			<pathelement location="${env.JWSDP_HOME_LIB}/jaxb-impl.jar"/>
			<pathelement location="${env.JWSDP_HOME_LIB}/jaxb-xjc.jar"/>
			<pathelement location="${env.JWSDP_HOME_LIB}/jsr173_api.jar"/>
		</classpath>
	</javac>
</target>
  
<target name="jar" depends="compile">
	<!-- Build the jar file -->
	<jar basedir="${build}" destfile="${build}/${env.JAR_FILE}"/>
</target>

</project>

Related Posts

• How to Create Jar Files from Ant
• How To Use Ant
• Howto generate Hibernate POJO and mapping files using ant from a db schema
• JAXB Castor Comparison

The great idea to achieve it is to use delegation instead of inheritance. Let’s consider we already have to classes we want to extend. We can use the inheritance so our new class will extend the first class. For the second class we can not use inheritance again, because we already inherit the first one, on the other side we want to overwrite some method implementations. The trick is to create an inner class extending the second class, and to delegate the calls from the main outer class to the inner class.

The technique can be “scaled” for any number of classes. For each new class which we need to inherit, we need to create another inner class and delegate the request to it. The big drawback here is the amount of code that should be written for creating the inherited inner classes and the code for delegating all the requests which which in case of multiple inheritance are done by default.

Related Posts

• Drawbacks of Marker Interface Design Pattern.
• How to Read/Write Java Properties Files
• Multimap in Google Collections Library
• How To Use Ant

#===================================
#	File Name: build.properties
#===================================

env.LIB=c://java//thirdparty//lib

The ant task contains a few tasks for doing the following operations:
1. Clean the build directory if exists.
2. Create the build directory where the new classes will be built.
3. Compile the java classes.
4. Build a jar file from the java classes.

Here is the build.xml file. Note the dependencies between the tasks and how the properties are defined in the ant xml file or loaded from the properties file:

<project name="how-to-use-ant" basedir="." default="jar">

	<property name="build" value="build"/>
	<property file="build.properties"/>
	
	<target name="clean">
		<delete dir="${build}"/>
	</target>

	<target name="init" depends="clean">
		<mkdir dir="${build}"/>
	</target>	
	
	<target name="compile" depends="init">
		<!-- Compile the java code -->
		<javac srcdir="src" destdir="${build}">
			<classpath>
				<pathelement location="${env.LIB}/required-jar1.jar"/>
				<pathelement location="${env.LIB}/required-jar2.jar"/>
			</classpath>
		</javac>
	</target>	
	
	<target name="jar" depends="compile">
		<!-- Build the jar file -->
		<jar basedir="${build}" destfile="${build}/new-jar.jar"/>
	</target>
	
</project>

Now that you’ve seen how to create an ant task you might ask why you need an ant build file for building a jar file. This can be done as well with a few batch commands which will take only a 4 lines bat file. There are certain advantages. The ant files can be easily parametrized and reused, sub projects cand be created, lots of tasks are implemented, covering most of the operations you want to do (junits, sql operations, zip file tasks, tasks for replacing and editing text and xml files, …) and new tasks can be implemented in java and used in any ant file.

Related Posts

• How to write an Ant xml build file to Generate JAXB Code and Compile and Build it to a Jar
• How To Use Ant
• Howto generate Hibernate POJO and mapping files using ant from a db schema
• How to Read/Write Java Properties Files