public class Singleton implements Serializable{
	private static Singleton _INSTANCE = null;

	static{
  		_INSTANCE = new Singleton();
 	}

	private Singleton() {
  	}

	public static Singleton getInstance() {
		return _INSTANCE;
	}
 }

Lets look at one by one.

private static Singleton  _INSTANCE keeps reference of the instance
static block this will prevent multi-thread initialization
readResolve() to make sure a new instance is not created by deserialization process

Beware that double locking solution will not work:

class Singleton {
  private static  Singleton singleton = null;
  public static Singleton getSingleton() {
    if (singleton == null){
        synchronized(this) {
           if (singleton == null)
              singleton = new Singleton ();
        }
   }
    return singleton ;
    }
  }

Please read the article why.

First lets create a basic Account class that will contain two pieces of information: account id and amount

public class Account {
	private int accountId = -1;
	private BigDecimal amount = null;

	public Account(int id, BigDecimal amount) {
		this.accountId = id;
		this.amount = amount;
	}

	public int getAccountId() {
		return accountId;
	}

	public void setAccountId(int accountId) {
		this.accountId = accountId;
	}

	public BigDecimal getAmount() {
		return amount;
	}

	public void setAmount(BigDecimal amount) {
		this.amount = amount;
	}

}

Next step we create an interface for processing banking requests.

import java.math.BigDecimal;
public interface Bank {
	public void deposit(BigDecimal amount, int accountId);
	public void withdraw(BigDecimal amount, int accountId);
}

Create a contrete class that will implement Bank interface and provide implementations for deposit and withrdaw methods. We will use hashtable to store all accounts in and we will syncronize updates per account basis.

import java.math.BigDecimal;
import java.util.Hashtable;
import java.util.Map;

public class BankImpl implements Bank  {

	final private Map accounts = new  Hashtable();

	public BankImpl(){
		//create accounts
		accounts.put(new Integer(1234), new Account(1234,
                                            new BigDecimal("1000.00")));
	 	accounts.put(new Integer(1000), new Account(1000,
                                            new BigDecimal("5000.00")));
	 	accounts.put(new Integer(1500), new Account(1500,
                                            new BigDecimal("10000.00")));
	}

	@Override
	public void deposit(BigDecimal amount,int accountId) {
		Account account  = accounts.get(accountId);
		if (account==null)
                   throw new RuntimeException("Account not found ["+accountId+"]");

		synchronized (account) {
		 account.getAmount().add(amount);
		 System.out.printf("Deposited $%(,.2f to account[%d]%n",
                                        amount, accountId);
    	}
 	}

	@Override
	public void withdraw(BigDecimal amount,int accountId) {
		Account account  = accounts.get(accountId);
		if (account==null)
                 throw new RuntimeException("Account not found ["+accountId+"]");
		synchronized (account) {
		 account.getAmount().subtract(amount);
		 System.out.printf("Withdrew $%(,.2f from account[%d]%n",
                                        amount, accountId);

		}
	}

}

Now, we need to create a LoggingHandler class that will inject “additional” code before and after the business calls.

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class LoggingHandler implements InvocationHandler{
	protected Object actual;

	public LoggingHandler(Object actual) {

		this.actual = actual;
	}

	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		try {
			System.out.println(">>>>>>start executing method: "
                                                + method.getName());
			Object result = method.invoke(actual, args);
			return result;
		} catch (InvocationTargetException ite) {
			throw new RuntimeException(ite.getMessage());
		} finally {
			System.out.println("<<<<<executing method: " + method.getName());
		}
	}
}

Create a factory class to return a bank instance with or without the proxy.

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class BankFactory {
	private static BankFactory singleInstance = null;

	private BankFactory() {
	}

	public static BankFactory getInstance() {
		if (singleInstance == null) {
			singleInstance = new BankFactory();
		}
		return singleInstance;
	}

	public Bank getBank(boolean withLogging) {
		Bank bank = new BankImpl();

		if (withLogging) {
		 	InvocationHandler handler = new LoggingHandler(bank);
		 	bank = (Bank) Proxy.newProxyInstance(bank.getClass().getClassLoader(),
                                   bank.getClass().getInterfaces(), handler);
		}
		return bank;
	}
}

Now finally we create the main class to demo methods calls with and without the proxy.

import java.math.BigDecimal;

public class TestProxy {

	public static void main(String[] args) {

		System.out.println("++++++++++++++++Without dynamic proxy++++++++++++++++");

	 	Bank bank = BankFactory.getInstance().getBank(false);
		bank.deposit(new BigDecimal("200.00"), 1000);

		System.out.println("+++++++++++++ With dynamic proxy++++++++++++++++");
		bank = BankFactory.getInstance().getBank(true);
		bank.deposit(new BigDecimal("200.00"), 1000);

	}

}

Results:

++++++++++++++++Without dynamic proxy++++++++++++++++
Deposited $200.00 to account[1000]
+++++++++++++ With dynamic proxy++++++++++++++++
>>>>>> start executing method: deposit
Deposited $200.00 to account[1000]
<<<<<< finished executing method: deposit