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

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.

Related Posts

• No Related Post

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);
	}
}

Related Posts

• Google Guice Tutorial
• Google Guice Starts a New Google Age?

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

• HashMap is a raw type. References to generic type HashMap should be parameterized
• Type safety: The method put(Object, Object) belongs to the raw type Map. References to generic type Map should be parameterized

Just because I use to write code like this in java 1.5:

Map parametersMap = new HashMap();
parametersMap.put(properties.get("input.key"), page);

I decided to say, no I don’t want to see them again. You can change the Project Properties in eclipse to ignore them: Right Click on the Project > Java Compiler > Errors / Warnings like in the snapshot (notice you can change this setting only for your specific project or for entire workspace):

Related Posts

• Installing Eclipse Bazaar plug-in and avoiding ‘bzr-xmloutput plugin not found’

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

To read java properties files from the classpath:

The properties files can be stored in the classpath. This way they can be put inside jar files and it’s really useful for web applications when the absolute location of the properties files is not known. When I tested this in an web application it didn’t work:

Properties properties = new Properties() ;
URL url =  ClassLoader.getSystemResource("test.properties");
properties.load(new FileInputStream(new File(url.getFile())));

To read java properties files from the classpath in a web application:

The following example works to load the properties files in a web application. This snippet was tested on Tomcat 5.5. The ‘/’ represents the root of the class path. Otherwise the properties file location is considered relatively to “this” class (or to MyClass for the second example):

Properties properties = new Properties() ;
properties.load(this.getClass().getResourceAsStream("/seoimproved.properties"));

Similar example to use in a static context:

Properties properties = new Properties() ;
properties.load(MyClass.class.getResourceAsStream("/seoimproved.properties"));

To read java properties files from a specific location:

The properties files can be loaded from any location.

Properties properties = new Properties() ;
properties.load(new FileInputStream("C:\\tmp\\test.properties"));

Related Posts

• Multimap in Google Collections Library
• How To Use Ant
• How to write an Ant xml build file to Generate JAXB Code and Compile and Build it to a Jar
• How to Simulate Multiple Inheritance in Java

We need somehow to extend the structure of objects for accepting the visitors without changing them. A way of doing it would be to add a wrapper for the hierarchy classes which accepts visitors and duplicates the structure.

Related Posts

• Drawbacks of Marker Interface Design Pattern.
• FactoryPattern.com – on air

• Install the bazaar plugin bzr-xmloutput by unzipping the archive content in c:\…\Bazaar\plugins\xmloutput\ (wherever your bazaar is installed, the plugin subdirectory should be named xmloutput). For details you can check the plugin readme file.
• Install the eclipse bazaar plugin: Go to Help > Software updates > Find and install > Search for New Features to Install > New Remote Site. Use there the http://bzr-eclipse.sourceforge.net/update-site/ then pres finish and all the required operations to install the eclipse plugin. Restart eclipse and set the bzr.exe location from Window > Preferences > Team > Bazaar(scroll down for the picture).

The detailed installing instructions are here. If you fail noticing the first step, like I did and don’t install the bzr-xmloutput plugin you’ll get “bzr-xmloutput plugin not found” exception like in the picture:

Related Posts

• How to Avoid Generics Related Warnings in Eclipse