关于Java代理模式的一些理解

Java代理模式

使用代理模式的一个好处：
可以拓展目标对象方法的实现，并且不需要修改该方法。

代理中的关键概念：
代理对象与目标对象。代理对象是对目标对象的扩展， 并会调用目标对象。

1.静态代理：

代理类实现目标类的接口，传入目标对象作为自己的一个属性，在实现代理方法的时候实际上是调用目标对象的该方法，并在调用的前后进行拓展。

//代理的接口
public interface Hello{
    public void sayHello();
}
//需要代理的目标类
public class HelloImpl implements Hello{
    publicvoid sayHello(){
        System.out.println("Hello!");
    }
}
//代理类
public class HelloProxy implements Hello{
    private HelloImpl h;
    public HelloProxy(HelloImpl h){
        this.h = h;
    }
    public void sayHello(){
        System.out.println("proxy start...");
        h.sayHello();
        System.out.println("proxy end...");
    }
}
//测试方法
public class Main{
    public static void main(String[] args){
        HelloImpl h = new HelloImpl();//目标对象
        HelloProxy hp = new HelloProxy(h);//代理对象
        hp.sayHello();
    }
}

静态代理优点：

1.实现较为简单

静态代理缺点：

1.如果需要代理很多实现了不同接口的类，就需要创建很多代理对象。

2.被代理的接口一旦被修改，代理类和目标类都需要修改。

2.动态代理：代理对象不需要实现接口。

1.JDK动态代理

所在的包：java.lang.reflect.Proxy

//目标对象实现的接口
public interface Hello{
    public void sayHello(String s);
}
//需要代理的目标类
public class HelloImpl implements Hello{
    public void sayHello(String s){
		System.out.println("Hello, "+s+" !");
    }
}
//代理类
public class HelloProxy implements InvocationHandler{
    private Hello h;
    public HelloProxy(Hello h){
        this.h = h;
    }
    @Override
    public Object invoke(Object proxy,Method method,Object[] args) Throws Throwable{
        System.out.println("before proxy...");
        Object returnValue = method.invoke(h,args);
        System.out.println("after proxy...");
        return returnValue;
    }
}
//测试方法
public class Main{
    public static void main(String[] args){
        Hello h = new HelloImpl();//目标对象
        HelloProxy hp = new HelloProxy(h);
        Hello sh = (Hello) Proxy.newProxyInstance(HelloImpl.class.getClassLoader(),new Class<?>[]{Hello.calss},hp);//代理对象
        sh.sayHello("zz");
    }
}

JDK动态代理是对接口的代理，所以代理的对象必须要实现了接口。

JDK动态代理的实现主要使用的是newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)方法，其中：

• ClassLoader loader：当前目标对象使用的类加载器
• Class<?>[] interfaces:目标对象实现的接口的类
• InvocationHandler h：事件处理器，代理时实际上实现的就是其中的invoke方法。

缺点：

目标对象一定要实现接口，否则不能使用JDK动态代理

CGLIB动态代理：

有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候就可以使用CGLIB代理。

CGLIB代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.

import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

//目标类，并未实现任何接口
class Hello2{
    public void sayHello(String s) {
        System.out.println("Hello: "+s+" !");
    }
}
//代理类
class HelloProxy2 implements MethodInterceptor {
    //维护目标对象
    private Object target;
    public HelloProxy2(Object target) {
        this.target = target;
    }
    //给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //工具类
        Enhancer en = new Enhancer();
        en.setSuperclass(target.getClass());
        en.setCallback(this);
        return en.create();
    }
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("start proxy...");
        Object returnValue = method.invoke(target, args);
        System.out.println("end proxy...");
        return returnValue;
    }
}
//测试
public class Main{
    public static void main(String[] args){
        Hello2 h = new Hello2();//目标对象
        Hello2 hp = (Hello2)new HelloProxy2(h).getProxyInstance();//代理对象
        //执行代理对象的方法
        hp.sayHello("zzz");
    }
}

需要注意的是：

1.代理类不能为final，否则会错误。

2.目标对象的方法如果为final/static，则无法被拦截，只会执行目标方法而不会执行代理对象额外的业务方法。