Java设计模式——代理模式

Java设计模式——代理模式

摘要：本文主要学习Java中的代理模式，包括静态代理和动态代理。

部分内容来自以下博客：

https://blog.csdn.net/mine_song/article/details/71373305

https://www.cnblogs.com/cenyu/p/6289209.html

什么是代理模式

代理模式是常用的Java设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

优势

代理是一种设计模式，提供了对目标对象另外的访问方式：即通过代理对象访问目标对象。

这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。

代理模式的关键点是：代理对象与目标对象。代理对象是对目标对象的扩展，并会调用目标对象。

分类

按照代理类的创建时期，代理类可分为两种：

静态代理：由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。

动态代理：在程序运行时，运用反射机制动态创建而成。

静态代理通常只代理一个类，动态代理是代理一个接口下的多个实现类。

静态代理事先知道要代理的是什么，而动态代理不知道要代理什么东西，只有在运行时才知道。

动态代理是实现JDK里的InvocationHandler接口的invoke方法，但注意的是代理的是接口，也就是你的业务类必须要实现接口，通过Proxy里的newProxyInstance得到代理对象。

还有一种动态代理CGLIB，代理的是类，不需要业务类继承接口，通过派生的子类来实现代理。通过在运行时，动态修改字节码达到修改类的目的。

在Spring的AOP编程中，如果加入容器的目标对象有实现接口就用JDK代理，如果目标对象没有实现接口就用CGLIB代理。

静态代理

静态代理在使用时，需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者是继承相同父类，然后通过调用相同的方法来调用目标对象的方法。

可以做到在不修改目标对象的功能前提下，对目标功能扩展。

因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类。同时，一旦接口增加方法，目标对象与代理对象都要维护。

测试代码：

public class Demo {
    public static void main(String[] args) {
        IRoleDao studentDao = new StudentDao();// 创建一个实例为StudentDao的IRoleDao引用
        RoleDaoProxy studentDaoProxy = new RoleDaoProxy(studentDao);// 将IRoleDao引用传入代理类
        int studentId = studentDaoProxy.save();// 代理类执行接口的方法
        System.out.println("id >>> " + studentId);
    }
}

// 同时实现的接口
interface IRoleDao {
    int save();
}

// 被代理类，实现IRoleDao接口
class StudentDao implements IRoleDao {
    @Override
    public int save() {
        System.out.println("保存成功");
        return 1;
    }
}

// 代理类，实现IRoleDao接口
class RoleDaoProxy implements IRoleDao {
    IRoleDao target;

    public RoleDaoProxy(IRoleDao target) {
        this.target = target;
    }

    @Override
    public int save() {
        System.out.println("开始事务");
        int id = target.save();
        System.out.println("结束事务");
        return id;
    }
}

动态代理

JDK代理

代理对象不需要实现接口，代理对象的生成是利用JDK的API，动态的在内存中构建代理对象（需要我们指定创建代理对象/目标对象实现的接口的类型）。

代理对象不需要实现接口，但是目标对象一定要实现接口，否则不能用动态代理。

代理类所在包：java.lang.reflect.Proxy。

JDK实现代理只需要使用newProxyInstance()方法，但是该方法需要接收三个参数，完整的写法是：

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

ClassLoader loader：指定当前目标对象使用类加载器，获取加载器的方法是固定的。

Class<?>[] interfaces：目标对象实现的接口的类型，使用泛型方式确认类型。

InvocationHandler h：事件处理，执行目标对象的方法时，会触发事件处理器的方法，会把当前执行目标对象的方法作为参数传入。

测试代码：

public class Demo {
    public static void main(String[] args) {
        // 创建被代理对象
        StudentDao target = new StudentDao();
        // 创建代理
        RoleDaoProxy proxy = new RoleDaoProxy(target);
        // 创建代理对象
        IRoleDao proxyInstance = (IRoleDao) proxy.getProxyInstance();
        // 执行代理对象的方法
        int id = proxyInstance.save();
        System.out.println("id >>> " + id);
    }
}

// 接口
interface IRoleDao {
    int save();
}

// 被代理类，实现接口
class StudentDao implements IRoleDao {
    @Override
    public int save() {
        System.out.println("保存成功");
        return 1;
    }
}

// 代理类，不需要实现接口
class RoleDaoProxy {
    Object target;

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

    public Object getProxyInstance() {
        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("开始事务");
                    Object object = method.invoke(target, args);
                    System.out.println("结束事务");
                    return object;
                }
            }
        );
    }
}

测试代码：

public class Demo {
    public static void main(String[] args) {
        Link link = (Link) Proxy.newProxyInstance(
                Link.class.getClassLoader(), 
                new Class[] { Link.class }, 
                new LinkInvocationHandler(new User(), new TestLink()));
        link.open();
        link.close();
    }
}

// 接口
interface Link {
    void open();
    void close();
}

// 被代理类
class TestLink implements Link {
    @Override
    public void open() {
        System.out.println("原生方法->自动打开连接");
    }
    @Override
    public void close() {
        System.out.println("原生方法->自动关闭连接");
    }
}

// 代理类
class User {
    public void release(TestLink link) {
        System.out.println("代理方法->用户回收连接");
    }
}

// 代理处理类
class LinkInvocationHandler implements InvocationHandler {
    User user;
    TestLink link;

    public LinkInvocationHandler(User user, TestLink link) {
        this.user = user;
        this.link = link;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        if (method.getName().equals("close")) {
            user.release(link);
        } else {
            method.invoke(link, args);
        }
        return null;
    }
}

CGLIB代理

上面的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对象，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口，这个时候就可以使用以目标对象子类的方式类实现代理，这种方法就叫做CGLIB代理。

CGLIB代理，也叫作子类代理，它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。

JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口，如果想代理没有实现接口的类，就可以使用cglib实现.

cglib是一个强大的高性能的代码生成包，它可以在运行期扩展java类与实现java接口。它广泛的被许多AOP的框架使用，例如SpringAOP和synaop，为他们提供方法的interception（拦截）。

cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类，不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

cglib子类代理实现方法：

1.需要引入cglib的jar文件，但是Spring的核心包中已经包括了cglib功能，所以直接引入spring-core-3.2.5.jar即可。

2.引入功能包后，就可以在内存中动态构建子类。

3.代理的类不能为final，否则报错。

4.目标对象的方法如果为final/static，那么就不会被拦截，即不会执行目标对象额外的业务方法。

测试代码：

public class Demo {
    public static void main(String[] args) {
        // 创建被代理对象
        StudentDao target = new StudentDao();
        // 创建代理
        RoleDaoProxy proxy = new RoleDaoProxy(target);
        // 创建代理对象
        StudentDao proxyInstance = (StudentDao) proxy.getProxyInstance();
        // 执行代理对象的方法
        int id = proxyInstance.save();
        System.out.println("id >>> " + id);
    }
}

// 被代理类，没有实现接口
class StudentDao {
    public int save() {
        System.out.println("保存成功");
        return 1;
    }
}

// 代理类，不需要实现接口
class RoleDaoProxy {
    Object target;

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

    public Object getProxyInstance() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object object, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                System.out.println("开始事务");
                Object result = proxy.invoke(target, args);
                System.out.println("结束事务");
                return result;
            }
        });
        return enhancer.create();
    }
}