设计模式——代理模式

代理模式

1、基本介绍：

• 为对象提供一个替身——代理对象，通过代理对象来访问目标对象。这样做的好处是，可以在目标对象实现的基础上，增加额外的功能，即扩展目标对象的功能，不需要修改原来的代码。
• 适用场景：远程对象、创建开销大的对象、需要安全控制的对象
• 几种形式：静态代理、动态代理、Cglib代理

2、静态代理

1）、介绍：

静态代理在使用时，需要定义接口或者父类，被代理对象与代理对象一起来实现相同的接口或者是继承相同父类，然后代理对象再聚合被代理对象。

2）、代码

//接口
public interface ITeacherDao {

    void teach();//授课的方法

}

//被代理对象
public class TeacherDao implements ITeacherDao {
    @Override
    public void teach() {
        System.out.println("老师正在上课");
    }
}

//代理对象，静态代理
public class TeacherDaoProxy implements ITeacherDao {

    private ITeacherDao target;//目标对象，通过接口来聚合

    //构造器
    public TeacherDaoProxy(ITeacherDao target) {
        this.target = target;
    }

    @Override
    public void teach() {
        System.out.println("代理对象开始");
        target.teach();
        System.out.println("代理对象结束");
    }
}

public class Client {
    public static void main(String[] args) {
        //1、创建被代理对象
        TeacherDao teacherDao = new TeacherDao();

        //2、创建代理对象，同时将被代理对象传递给代理对象
        TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);

        //3、通过代理对象，调用被代理对象的方法
        teacherDaoProxy.teach();
    }
}

3）、特点：

**优点：**可以不修改原来代码，通过代理对象对目标功能进行拓展

缺点：

• 因为代理对象目标需要与目标对象实现一样的接口，所以会有很多代理类（增强一次被代理对象就得新增一个代理类）
• 一旦接口增加方法，目标对象与代理对象都需要修改

3、动态代理

1）介绍：

• 代理对象不需要实现接口，但是目标对象要实现接口
• 代理对象的生成是利用JDK的API，动态在内存中构建代理对象

2）代码：

//接口
public interface ITeacherDao {

    void teach();//授课的方法

    String sayHello(String name);
}

public class TeacherDao implements ITeacherDao {
    @Override
    public void teach() {
        System.out.println("老师正在上课");
    }

    @Override
    public String sayHello(String name) {
        System.out.println(name);
        return name;
    }
}

public class ProxyFactory {

    //维护一个目标对象
    private Object target;

    //构造器，对target进行初始化
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象生成一个代理对象
    public Object getProxyInstance() {

        //参数说明
        //1、ClassLoader：指定当前目标对象使用的类加载器，获取加载器的方法固定
        //2、Class<?>[] interface：目标对象实现的接口类型，使用泛型方法确认类型
        //3、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 returnValue = method.invoke(target, args);
                        System.out.println("JDK代理结束");
                        return returnValue;
                    }
                });

    }
}

public class Client {
    public static void main(String[] args) {
        //1、创建被代理对象
        ITeacherDao target = new TeacherDao();

        //2、创建代理对象
        ITeacherDao proxyInstance = (ITeacherDao) new ProxyFactory(target).getProxyInstance();

        //说明第二步生成的是代理对象
        System.out.println(proxyInstance.getClass());

        //3、通过代理对象调用目标对象的方法
        proxyInstance.teach();
        String rwl = proxyInstance.sayHello("rwl");
        System.out.println(rwl);

    }
}

3、Cglib

1）介绍

• 静态代理和JDK代理模式都要求被代理对象实现一个接口，但有时候目标对象只是一个单独的队形啊，并没有实现任何接口（也就是说cglib和JDK代理的区别在于被代理对象是否需要实现接口），这个时候可使用目标对象子类来实现代理，这就是Cglib代理。

2）代码

public class TeacherDao {
    public void teach() {
        System.out.println("老师授课中");
    }
}

public class ProxyFactory implements MethodInterceptor {

    //维护一个目标对象
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    //返回target的代理对象
    public Object getProxyInstance() {
        //1、创建一个工具类
        Enhancer enhancer = new Enhancer();

        //2、设置父类
        enhancer.setSuperclass(target.getClass());

        //3、设置回调函数
        enhancer.setCallback(this);

        //4、创建子类对象，即代理对象
        return enhancer.create();
    }

    //重写拦截方法，在代理对象使用时，这个方法会调用目标对象的方法
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("代理模式开始");
        Object invoke = method.invoke(target, args);
        System.out.println("代理模式结束");
        return invoke;
    }
}

public class Client {
    public static void main(String[] args) {
        //1、创建目标对象
        TeacherDao target = new TeacherDao();

        //2、获取到代理对象，并且将目标传递给代理对象
        TeacherDao proxyInstance = (TeacherDao) new ProxyFactory(target).getProxyInstance();

        //3、执行代理对象的方法
        proxyInstance.teach();
    }
}