java设计模式之代理模式

java代理实现可以简单分为静态代理和动态代理。

代理模式(Proxy Pattern)是GoF 23种Java常用设计模式之一。提供了对目标对象另外的访问方式，即通过代理对象访问目标对象。
这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.
这里使用到编程中的一个思想:开闭原则，就是说对扩展开放，对修改关闭。在工作中不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法。

代理模式包含如下角色：
ISubject：抽象主题角色，是一个接口。该接口是对象和它的代理共用的接口。
RealSubject：真实主题角色，是实现抽象主题接口的类。
Proxy：代理角色，内部含有对真实对象RealSubject的引用，从而可以操作真实对象。代理对象提供与真实对象相同的接口，以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。

静态代理

1. 代码实现
   (1) Subject

/**
 * 抽象主题，定义主要功能
 */
public interface Subject {
   public void request();
}

(2) RealSubject

/**
 * 具体主题
 */
public class RealSubject implements Subject{

   @Override
   public void request() {
        System.out.println("RealSubject start===========");
   }
}

(3) Proxy

/**
 * 代理类
 */
public class Proxy implements Subject{

    private Subject subject;

    public Proxy(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void request() {
        System.out.println("Proxy before subject start!!!!!!!");
        subject.request();
        System.out.println("Proxy after subject start-------");
    }

    public static void main(String[] args) {
        Subject subject = new RealSubject();
        //生成代理类
        Proxy proxy = new Proxy(subject);
        proxy.request();
    }

}

运行结果： Proxy before subject start!!!!!!!
RealSubject start===========
Proxy after subject start——-

建议用聚合方式实现代理，继承式的实现方式则不够灵活，而聚合因为代理类及被代理类都实现了同一个接口，可实现灵活多变。 比如，在管理员操作的同时需要进行权限的处理，操作内容的日志记录，操作后数据的变化三个功能。三个功能的排列组合有6种，也就是说使用继承要编写6个继承了Admin的代理类，而使用聚合，仅需要针对权限的处理、日志记录和数据变化三个功能编写代理类，在业务逻辑中根据具体需求改变代码顺序即可。
静态代理实现中，一个委托类对应一个代理类，代理类在编译期间就已经确定。

动态代理

动态代理中，代理类并不是在Java代码中实现，而是在运行时期生成，相比静态代理，动态代理可以很方便的对委托类的方法进行统一处理，如添加方法调用次数、添加日志功能等等，动态代理分为jdk动态代理和cglib动态代理。
JDK动态代理
代理类所在包:java.lang.reflect.Proxy
JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:
static Object newProxyInstance(ClassLoader loader, Class<\?>[] interfaces,InvocationHandler h )
注意该方法是在Proxy类中是静态方法,且接收的三个参数依次为:
ClassLoader loader,:指定当前目标对象使用类加载器,获取加载器的方法是固定的
Class<\?>[] interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型
InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的.方法作为参数传入(Class<\?>中的\只是作为转义 无其他特别意义)

利用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口定义代理类的实现。

public class JdkDynamicProxy implements InvocationHandler {
    /**
     * 维护一个要代理的对象
     */
    private Object targert;

    public JdkDynamicProxy(Object targert) {
        this.targert = targert;
    }

    @Override
    public Object invoke(Object object, Method method, Object[] arg) throws Throwable {
        System.out.println("代理方法前执行");
        //调用被代理对象的方法
        method.invoke(targert, arg);
        System.out.println("代理方法后执行");
        return null;
    }
    /**
     * 给目标对象生成代理对象 并返回
     * @return
     */
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(targert.getClass().getClassLoader(),        targert.getClass().getInterfaces(), this);
    }

    public static void main(String[] args) {
        RealSubject subject = new RealSubject();
        Subject proxy = (Subject) (new JdkDynamicProxy(subject).getProxyInstance());
        proxy.request();
    }
}

代理方法前执行
RealSubject start===========
代理方法后执行

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

Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)
Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.
Cglib子类代理实现方法:
1.需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.
2.引入功能包后,就可以在内存中动态构建子类
3.代理的类不能为final,否则报错
4.目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

/**
 * 目标对象,没有实现任何接口
 */
public class User {

    public void save() {
            System.out.println("----已经保存用户信息!----");
        }
}

/**
 * Cglib子类代理工厂
 * 对User在内存中动态构建一个子类对象
 */
public class CglibDynamicProxy implements MethodInterceptor {

    /**
     * 内部维护一个被代理对象
     */
    private Object targert;

    public CglibDynamicProxy(Object targert) {
        super();
        this.targert = targert;
    }
    /**
     * 创建代理对象并返回
     * @return
     */
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(targert.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();
    }
    @Override
    public Object intercept(Object object, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("代理方法前执行");
        //调用被代理对象的方法
        method.invoke(targert, args);
        System.out.println("代理方法后执行");
        return null;
    }

    public static void main(String[] args) {
        User user = new User();
        //生成代理对象
        User proxy = (User) new CglibDynamicProxy(user).getProxyInstance();
        proxy.save();
    }
}

jdk和cglib动态代理实现的区别
1、jdk动态代理生成的代理类和委托类实现了相同的接口；
2、cglib动态代理中生成的字节码更加复杂，生成的代理类是委托类的子类，且不能处理被final关键字修饰的方法；
3、jdk采用反射机制调用委托类的方法，cglib采用类似索引的方式直接调用委托类方法；
4、如果被代理的目标对象有实现接口,用JDK代理，如果目标对象没有实现接口,用Cglib代理

代理模式的应用形式
(1)远程代理(Remote Proxy) -可以隐藏一个对象存在于不同地址空间的事实。也使得客户端可以访问在远程机器上的对象，远程机器可能具有更好的计算性能与处理速度，可以快速响应并处理客户端请求。
(2)虚拟代理(Virtual Proxy) – 允许内存开销较大的对象在需要的时候创建。只有我们真正需要这个对象的时候才创建。
(3)写入时复制代理(Copy-On-Write Proxy) – 用来控制对象的复制，方法是延迟对象的复制，直到客户真的需要为止。是虚拟代理的一个变体。
(4)保护代理(Protection (Access)Proxy) – 为不同的客户提供不同级别的目标对象访问权限
(5)缓存代理(Cache Proxy) – 为开销大的运算结果提供暂时存储，它允许多个客户共享结果，以减少计算或网络延迟。
(6)防火墙代理(Firewall Proxy) – 控制网络资源的访问，保护主题免于恶意客户的侵害。
(7)同步代理(SynchronizationProxy) – 在多线程的情况下为主题提供安全的访问。
(8)智能引用代理(Smart ReferenceProxy) - 当一个对象被引用时，提供一些额外的操作，比如将对此对象调用的次数记录下来等。
(9)复杂隐藏代理(Complexity HidingProxy) – 用来隐藏一个类的复杂集合的复杂度，并进行访问控制。有时候也称为外观代理(Façade Proxy)，这不难理解。复杂隐藏代理和外观模式是不一样的，因为代理控制访问，而外观模式是不一样的，因为代理控制访问，而外观模式只提供另一组接口。