代理模式

代理(Proxy)是一种设计模式,提供了间接对目标对象进行访问的方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的功能上,增加额外的功能补充,即扩展目标对象的功能.

这就符合了设计模式的开闭原则，即在对既有代码不改动的情况下进行功能的扩展。

举个例子来说明代理的作用:明星与经纪人之间就是被代理和代理的关系,明星出演活动的时候，明星就是一个目标对象,他只要负责活动中的节目,而其他琐碎的事情就交给他的代理人(经纪人)

来解决.这就是代理思想在现实中的一个例子。

静态代理

在使用静态代理时,被代理对象与代理对象需要一起实现相同的接口或者是继承相同父类，因此要定义一个接口或抽象类.

代码案例：

第一步、创建静态代理类和需要被代理类的共同接口

package proxy.calm;

//接口
public interface IStar {
        void sing();
}

第二步、创建真实类

package proxy.calm;

//真实对象
class LDHStar implements IStar {
    @Override
    public void sing() {
        System.out.println("刘德华唱歌");
    }
}

第三步、创建代理类（它需要有真实对象的控制权 (引用)）

package proxy.calm;

// 静态代理类需要有真实对象的控制权 (引用)
class ProxyManger implements IStar {

    // 真实对象的引用
    private IStar star;

    public ProxyManger() {
        super();
    }

    public ProxyManger(IStar star) {
        super();
        this.star = star;
    }

    @Override
    public void sing() {
     System.out.println("唱歌前准备");
     star.sing();
     System.out.println("善后工作");
    }
}

第四步、客户端测试

扫描二维码关注公众号，回复： 10789068 查看本文章

package proxy.calm;

public class Client {
    public static void main(String[] args) {
        // 创建明星对象
        IStar ldh = new LDHStar();
        //创建他的理
        ProxyManger proxy = new ProxyManger(ldh);
        proxy.sing();
    }
}

唱歌前准备
刘德华唱歌
善后工作

静态代理总结:
优点：可以做到在不修改目标对象的功能前提下,对目标功能扩展.
缺点:  因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.

而动态代理方式可以解决上面的问题

动态代理

动态代理的主要特点就是能够在程序运行时JVM才为被代理对象生成代理对象。

常说的动态代理也叫做JDK代理也是一种接口代理，JDK中生成代理对象的代理类就是Proxy，所在包是java.lang.reflect
还是上面明星的例子，接口、被代理类不变，我们构建一个handler类来实现InvocationHandler接口。

动态代理具体步骤：

1. 通过实现 InvocationHandler 接口创建自己的调用处理器；
2. 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；
3. 通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
4. 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

package proxy.dynamic;

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

class MyInvocationHandle implements InvocationHandler {
    private Object target;
    public void setTarget(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("唱歌前准备");
            method.invoke(target, args);
            System.out.println("善后工作");
            return null;
    }
}

创建一个代理类，通过Proxy类的静态方法newProxyInstance返回一个接口的代理实例。针对不同的代理类，传入相应的代理程序控制器InvocationHandler。

package proxy.dynamic;

import java.lang.reflect.Proxy;

class MyProxyFactory{
    public static Object getProxy(Object target) {
        MyInvocationHandle handle = new MyInvocationHandle();
        handle.setTarget(target);
        Object proxy = Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                handle);
        return proxy;
    }
 }

客户端测试 ：完成了与静态代理相同功能

package proxy.dynamic;

public class Client {
    public static void main(String[] args) {
        IStar dog = new LDHStar();
        IStar proxy =(IStar) MyProxyFactory.getProxy(dog);
        proxy.sing();
    }
}

唱歌前准备
刘德华唱歌
善后工作

总结：代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能使用动态代理，因此这也算是这种方式的缺陷。

Cglib代理

上面的静态代理和动态代理模式有个相同点就是都要求目标对象是实现一个接口的对象,然而并不是任何对象都会实现一个接口，也存在没有实现任何的接口的对象,

这时就可以使用继承目标类以目标对象子类的方式实现代理,这种方法就叫做:Cglib代理，也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.

使用JDK动态代理有一个限制,就是被代理的对象必须实现一个或多个接口,若想代理没有实现接口的类,就需要使用Cglib实现.

需要导入jar包

 现在真实对象可以不实现任何接口

package proxy.cglib;


//真实对象
class LDHStar {
    public void sing() {
        System.out.println("刘德华唱歌");
    }
}

第二步、创建cglib代理工厂

package proxy.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * 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 o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("唱歌前准备");
        //执行目标对象的方法
        Object returnValue = method.invoke(target, objects);
        System.out.println("善后工作");
        return returnValue;
    }
}

开始测试，同样完成了相同功能

package proxy.cglib;


public class Client {
    public static void main(String[] args) {
        // 创建明星对象
        LDHStar ldh = new LDHStar();
        //创建他的代理
        LDHStar proxy = (LDHStar) new ProxyFactory(ldh).getProxyInstance();
        proxy.sing();
    }
}

唱歌前准备
刘德华唱歌
善后工作

附：

在Spring的AOP编程中:

如果加入容器的目标对象有实现接口,用JDK代理

如果目标对象没有实现接口,用Cglib代理。