Java 代理模式

1、什么是代理

代理是一种设计模式，它的核心思想，是将对目标的访问转移到代理对象上。这样做的好处就是，目标对象在不改变代码的情况下，可以通过代理对象加一些额外的功能。这是一种编程思想，在不改变原有代码的情况下，通过代理增加一些扩展功能。

代理过程如图所示，用户访问代理对象，代理对象通过访问目标对象，来达到用户访问目标对象的目的。

 代理模式包含以下三个角色：

　　--|　ISubject：接口对象，目标对象和代理对象共用的接口

　　--|　TargetSubject：目标对象，实现共用的接口

　　--|    Proxy：代理对象，内部含有对目标对象TargetSubject的引用，从而可以操作真实对象。代理对象提供与目标对象相同的接口，以便在任何时刻都能代替目标对象。同时，代理对象可以在执行目标对象操作时，附加其他的操作，相当于对真实对象进行封装。

常见的代理模式分为静态代理和动态代理，动态代理在Java中的实现分为JDK动态代理和cglib代理。

2、静态代理

　　1）共用接口对象

package proxy;

public interface playMovie {
    void play();
}

　　2）目标对象，实现共用的接口

package proxy;

public class RealMovie implements playMovie{

    @Override
    public void play() {
        System.out.println("电影开始播放了");
    }
}

　　3）代理对象

package proxy;

public class ProxyMovie implements playMovie{
    RealMovie rm;
    
    public ProxyMovie(RealMovie rm) {
        super();
        this.rm = rm;
    }
    
    public void guanggao() {
        System.out.println("开始放广告了");
    }
    
    @Override
    public void play() {
        // TODO Auto-generated method stub
        guanggao();
        rm.play();
        System.out.println("电影结束了，散场了");
    }

}

　　4）客户端调用

package proxy;

public class ProxyTest {
    public static void main(String[] args) {
        RealMovie rm = new RealMovie();
        ProxyMovie pm = new ProxyMovie(rm);
        pm.play();
    }
}

结果打印：
开始放广告了
电影开始播放了
电影结束了，散场了

静态代理，在不修改目标对象的情况下，可以通过代理对象做额外的扩展功能。但静态方法不是很灵活，如果目标接口的代码修改，目标对象和代理对象都需要修改。

动态代理在一定程度上避免这种情况，动态代理不需要代理对象实现目标接口，并且上在java 虚拟机的内存中动态的生成代理对象

3、动态代理（JDK代理）

Jdk的动态代理由Proxy这个类来生成，它有三个参数：

• ClassLoader loader,:指定当前目标对象使用类加载器,获取加载器的方法是固定的
• Class<?>[] interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型
• InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {}

使用步骤如下：

1）共用接口对象

package proxy.jdkproxy;

public interface Subject {
    public void doSomething() ;
}

2）目标对象，实现接口

package proxy.jdkproxy;

public class RealSubject implements Subject{

    @Override
    public void doSomething() {
        System.out.println("目标对象：do Something");
    }

}

3）代理对象

package proxy.jdkproxy;

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

public class ProxyFactory implements InvocationHandler{
    private Object proxied;
    
    public ProxyFactory(Object proxied) {
        this.proxied = proxied;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置增强处理：yoho");
        Object obj =method.invoke(proxied, args);
        System.out.println("后置增强处理：lalala");
        return obj;
    }

}

4）客户端调用

package proxy.jdkproxy;

import java.lang.reflect.Proxy;

public class ProxyClient {
    public static void main(String[] args) {
        Subject rs = new RealSubject();
        Subject proxyOfrs = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(),
                new Class[] {Subject.class}, new ProxyFactory(rs));
        System.out.println(proxyOfrs);
        
        proxyOfrs.doSomething();
    }
}