Proxy代理模式分为静态代理和动态代理，简单说即是在不改变源码的情况下，实现对目标对象的功能扩展。
举一个很简单的例子，比如有个歌手对象叫SunZi，这个对象有一个唱歌方法叫sing()。
public class Sunzi{
public void sing() {
System.out.println("我会唱唐人");
}
}
假如现在你希望，这个歌手对象，在唱歌前后还要想观众问好和答谢，也即对目标对象Singer的sing方法进行功能扩展，代码如下：
public void sing() {
System.out.println("向观众问好");
System.out.println("我会唱唐人");
System.out.println("答谢观众");
}
但是你现在又不能直接对源代码进行修改，这时就需要用到java的代理模式了。
/** 静态代理 **/
public interface ISinger {
void sing();
}
/**
* 目标对象实现了某一接口
*/
public class SunZi implements ISinger{
public void sing(){
System.out.println("我会唱唐人");
}
}
/**
* 代理对象和目标对象实现相同的接口
*/
public class SingerProxy implements ISinger{
// 接收目标对象，以便调用sing方法
private ISinger target;
public UserDaoProxy(ISinger target){
this.target=target;
}
// 对目标对象的sing方法进行功能扩展
public void sing() {
System.out.println("向观众问好");
target.sing();
System.out.println("答谢观众");
}
}
/**
* 测试类
*/
public class Test {
public static void main(String[] args) {
//目标对象
ISinger target = new SunZi();
//代理对象
ISinger proxy = new SingerProxy(target);
//执行的是代理的方法
proxy.sing();
}
}
总结：静态代理其实就是创建一个代理类SingerProxy，继承了ISinger接口并实现了其中的方法，只不过这种实现特意包含了目标对象的方法，正是这种特征使得看起来像是“扩展”了目标对象的方法。假使代理对象中只是简单地对sing方法做了另一种实现而没有包含目标对象的方法，也就不能算作代理模式了，所以这里的包含是关键。
缺点：代理对象必须提前写出，如果接口层发生了变化，代理对象的代码也要进行维护。
/** 动态代理（也叫JDK代理） **/
public interface ISinger {
void sing();
}
/**
* 目标对象实现了某一接口
*/
public class SunZi implements ISinger{
public void sing(){
System.out.println("我会唱唐人");
}
}
public class Test {
public static void main(String[] args) {
Singer target = new Singer();
ISinger proxy = (ISinger) Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("向观众问好");
// 执行目标对象方法
Object returnValue = method.invoke(target, args);
System.out.println("答谢观众");
return returnValue;
}
});
proxy.sing();
}
}
java封装了newProxyInstance这个方法的实现细节，所以使用起来才能这么方便。
缺点：可以看出静态代理和JDK代理有一个共同的缺点，就是目标对象必须实现一个或多个接口，假如没有，则可以使用Cglib代理。
/** Cglib代理 **/
/**
前提条件：
需要引入cglib的jar文件，由于Spring的核心包中已经包括了Cglib功能，所以也可以直接引入spring-core-3.2.5.jar
目标类不能为final
目标对象的方法如果为final/static，那么就不会被拦截，即不会执行目标对象额外的业务方法
**/
/**
* 目标对象,没有实现任何接口
*/
public class Singer{
public void sing() {
System.out.println("我会唱唐人");
}
}
/**
* Cglib子类代理工厂
*/
public class ProxyFactory implements MethodInterceptor{
// 维护目标对象
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
// 给目标对象创建一个代理对象
public Object getProxyInstance(){
//1.工具类
Enhancer en = new Enhancer();
//2.设置父类
en.setSuperclass(target.getClass());
//3.设置回调函数
en.setCallback(this);
//4.创建子类(代理对象)
return en.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("向观众问好");
//执行目标对象的方法
Object returnValue = method.invoke(target, args);
System.out.println("答谢观众");
return returnValue;
}
}
/**
* 测试类
*/
public class Test{
public static void main(String[] args){
//目标对象
Singer target = new Singer();
//代理对象
Singer proxy = (Singer)new ProxyFactory(target).getProxyInstance();
//执行代理对象的方法
proxy.sing();
}
}
总结：三种代理模式各有优缺点和相应的适用范围，主要看目标对象是否实现了接口。以Spring框架所选择的代理模式举例，在Spring的AOP编程中：
如果加入容器的目标对象有实现接口，用JDK代理
如果目标对象没有实现接口，用Cglib代理
