动态代理实例

public interface ArithmeticCaculator {
	int add(int a, int b);

	int sub(int a, int b);

	int mul(int a, int b);

	int div(int a, int b);
}

public class ArithmeticCaculatorImpl implements ArithmeticCaculator {

	@Override
	public int add(int a, int b) {
		return a + b;
	}

	@Override
	public int sub(int a, int b) {
		return a - b;
	}

	@Override
	public int mul(int a, int b) {
		return a * b;
	}

	@Override
	public int div(int a, int b) {
		return a / b;
	}

}

public class AritmethticCaculatorProxy {

	// 要代理的目标对象
	ArithmeticCaculator target;

	public AritmethticCaculatorProxy(ArithmeticCaculator target) {
		this.target = target;
	}

	public ArithmeticCaculator proxy() {
		ClassLoader loader = target.getClass().getClassLoader(); // 代理对象由哪个类加载器加载
		Class<?>[] interfaces = target.getClass().getInterfaces(); // 代理对象所实现的接口
		
		InvocationHandler invocationHandler = new InvocationHandler() {//代理对象调用其中的方法时，執行該代碼

			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				System.out.println("before:" + Arrays.asList(args));
				Object result = method.invoke(target, args);
				System.out.println("result:" + result);
				return result;
			}
		};
		return (ArithmeticCaculator) Proxy.newProxyInstance(loader, interfaces, invocationHandler);
	}
}

public class Main {

	public static void main(String[] args) {
		ArithmeticCaculator arithmeticCaculator = new ArithmeticCaculatorImpl();
		AritmethticCaculatorProxy aritmethticCaculatorProxy = new AritmethticCaculatorProxy(arithmeticCaculator);
		ArithmeticCaculator target = aritmethticCaculatorProxy.proxy();
		target.add(1, 2);
		target.sub(4, 3);
		target.mul(100, 0);
		target.div(8, 2);
	}
}

结果

before:[1, 2]
result:3
before:[4, 3]
result:1
before:[100, 0]
result:0
before:[8, 2]
result:4