Code:

BeforeAdvice interface:

/**
 * Preamplifier
 * 
 * @author Veeja.Liu
 * @emial veejaliu@gmail.com
 * 
 */
public interface BeforeAdvice {
	public void before();
}

AfterAdvice interface:

/**
 * Post enhancement
 * 
 * @author Veeja.Liu
 * @emial veejaliu@gmail.com
 * 
 */
public interface AfterAdvice {
	public void after();
}

ProxyFactory (proxy factory class):

/**
 * Agent factory class
 * 
 * It is used to generate proxy objects. It needs all the parameters.
 * 
 * 1. Create agent factory 
 * 2. Set three parameters for the factory
 * 	 * Target enhancement: setTargetObject(xxx);
 *   * Pre enhancement: setbeforeadvice (implementation of the interface)
 *   * Post enhancement: setafteradvice (implementation of this interface)
 * 3. Call createProxy() to get the object
 *   * When executing a proxy object method,
 *   > before of implementing BeforeAdvice
 *   > Target method of executing target object
 *   > after() of AfterAdvice
 * @author Veeja.Liu
 * @emial veejaliu@gmail.com
 * 
 */
public class ProxyFactory {
	private Object targetObject;// Target object
	private BeforeAdvice beforeAdvice;// Preamplifier
	private AfterAdvice afterAdvice;// Post enhancement

	/*
	 * Used to generate proxy objects
	 */
	public Object createProxy() {
		/*
		 * 1. Three parameters are given
		 */
		ClassLoader classLoader = this.getClass().getClassLoader();
		Class[] interfaces = targetObject.getClass().getInterfaces();
		InvocationHandler h = new InvocationHandler() {

			public Object invoke(Object proxy, Method method,
					Object[] args) throws Throwable {
				/*
				 * This method is executed when the method of the proxy object is called.
				 */
				// Perform pre enhancement
				if (beforeAdvice != null) {
					beforeAdvice.before();
				}
				
				// Target method of executing target object
				Object result = method.invoke(targetObject, args);
				
				// Perform post enhancement
				if (afterAdvice != null) {
					afterAdvice.after();
				}
				
				// Returns the return value of the target object
				return result;
			}
		};
		// Get proxy object
		Object proxyObject = Proxy.newProxyInstance(classLoader, interfaces, h);
		return proxyObject;
	}

	/*
	 * get,set Method
	 */

	public Object getTargetObject() {
		return targetObject;
	}

	public void setTargetObject(Object targetObject) {
		this.targetObject = targetObject;
	}

	public BeforeAdvice getBeforeAdvice() {
		return beforeAdvice;
	}

	public void setBeforeAdvice(BeforeAdvice beforeAdvice) {
		this.beforeAdvice = beforeAdvice;
	}

	public AfterAdvice getAfterAdvice() {
		return afterAdvice;
	}

	public void setAfterAdvice(AfterAdvice afterAdvice) {
		this.afterAdvice = afterAdvice;
	}

}

usage method:

Let's say there's a server interface. There are two methods, one is serve() service, the other is cash() collection.

/*
 * Attendant interface
 */
public interface Waiter {
	// Service method
	public void serve();
	//Method of collecting money
	public void cash();

}

We use a ManWaiter class to implement this interface.

public class ManWaiter implements Waiter {

	public void serve() {
		System.out.println("In service...Here is your lemonade...");
	}

	public void cash() {
		System.out.println("You consumed it. $186000,Please pay!");
	}

}

How can we enhance this class?
Please look at the example, and then realize by yourself.

public class Demo3 {
	public void fun1() {
		ProxyFactory factory = new ProxyFactory();
		factory.setTargetObject(new ManWaiter());
		factory.setBeforeAdvice(new BeforeAdvice() {

			public void before() {
				System.out.println("Hello, welcome!!!");
			}
		});
		factory.setAfterAdvice(new AfterAdvice() {

			public void after() {
				System.out.println("Goodbye, come again next time!!!");
			}
		});
		Waiter waiter = (Waiter) factory.createProxy();
		waiter.serve();

	}
}

END.