设计模式之代理模式

说到代理，很多人都会想到MyBatis框架中的代理对象mapper,而本文就简单的说一下这一模式 。现在给出这样的一个场景，卢泽龙喜欢某一位女生，但由于不好意思，就将表白的任务委托给了张帅（代理）

静态代理模式

这个模式需要代理、接口、接口实现类，并且代理也需要实现该接口，且聚合一个接口对象。
接口：Ilove

package proxy.statics;

public interface ILove {

    void sayLove();

}

接口实现类：LoveDao

package proxy.statics;

public class LoveDao implements ILove{
    @Override
    public void sayLove() {
        System.out.println("我喜欢你.....");
    }
}

代理：LoveDaoProxy

package proxy.statics;

public class LoveDaoProxy implements ILove{
    private ILove target;
    public LoveDaoProxy(ILove target){
        super();
        this.target = target;
    }
    @Override
    public void sayLove() {
        System.out.println("卢泽龙说:");
        target.sayLove();
        System.out.println("999999999");
    }
}

客户端调用测试：

package proxy.statics;

public class client {
    public static void main(String[] args) {
        LoveDao loveDao = new LoveDao();
        LoveDaoProxy loveDaoProxy = new LoveDaoProxy(loveDao);
        loveDaoProxy.sayLove();
    }
}

动态代理之jdk代理

和上面静态代理相比，依旧需要接口，但是代理已经不需要实现该接口了

接口：ILove

package proxy.JDK;

public interface ILove {
    void sayLove();
}

接口实现类:LoveDao

package proxy.JDK;

public class LoveDao implements ILove {
    @Override
    public void sayLove() {
        System.out.println("我喜欢你.....");
    }
}

代理：ProxyFactory

package proxy.JDK;

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

public class ProxyFactory {
    private Object target;
    public ProxyFactory(Object target){
        this.target = target;
    }
    public Object getProxtInstance(){
        /**
         * ClassLoader loader : 指定当前目标对象使用的类加载器，获取加载器的方法固定
         * Class<?>[] interfaces: 目标对象实现的接口类型，使用泛型方法确认类型
         * InvocationHandler h: 事情处理，执行目标对象的方法时，会触发事情处理器方法，会把当前执行的目标对象方法作为参数传入
         */
        return 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("JDK代理开始");
                        Object returnVal = method.invoke(target, args);
                        System.out.println("JDK代理结束");
                        return returnVal;
                    }
                });
    }
}

客户端调用，测试：

package proxy.JDK;

public class client {
    public static void main(String[] args) {
        ILove target = new LoveDao();
        ILove proxyInstance = (ILove)new ProxyFactory(target).getProxtInstance();
        System.out.println("proxyInstance="+proxyInstance.getClass());
        System.out.println("========================");
        proxyInstance.sayLove();
    }
}

动态代理之Cglib代理

和jdk代理相比，现在连接口都不需要了
但是需要导入下面的四个jar包：

实体类：

package proxy.Cglib;


public class LoveDao {
    public void sayLove() {
        System.out.println("我喜欢你.....");
    }
}

代理：

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;

public class ProxyFactory implements MethodInterceptor {

    private Object target;

    public ProxyFactory(Object target){
        this.target = target;
    }
    public Object getProxyInstance(){
        //创建一个工具类
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(target.getClass());
        //设置回调函数
        enhancer.setCallback(this);
        //创建子类对象，及代理对象
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("Cglib代理开始.....");
        Object res = method.invoke(target, args);
        System.out.println("Cglib代理结束.....");
        return res;
    }
}

客户端调用测试：

package proxy.Cglib;

public class client {
    public static void main(String[] args) {
        LoveDao loveDao = new LoveDao();
        LoveDao proxyInstance = (LoveDao)new ProxyFactory(loveDao).getProxyInstance();
        proxyInstance.sayLove();
    }
}