设计模式【3】------>代理模式

一、什么是代理模式

• 通过代理控制对象的访问，可以在这个对象调用方法之前、调用方法之后去处理/添加新的功能。(也就是AOP的微实现)
• 代理在原有代码乃至原业务流程都不修改的情况下，直接在业务流程中切入新代码，增加新功能，这也和Spring的（面向切面编程）很相似

二、代理模式的结构

1. 抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
2. 真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
3. 代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。

结构图

三、代理模式应用场景

• Spring AOP、日志打印、异常处理、事务控制、权限控制等

四、代理的分类

• 静态代理(静态定义代理类)
• 动态代理(动态生成代理类，也称为Jdk自带动态代理)
• Cglib 、javaassist（字节码操作库）

五、三种代理的区别

1. 静态代理：简单代理模式，是动态代理的理论基础。常见使用在代理模式
2. jdk动态代理：使用反射完成代理。需要有顶层接口才能使用，常见是mybatis的mapper文件是代理。
3. cglib动态代理：也是使用反射完成代理，可以直接代理类（jdk动态代理不行），使用字节码技术，不能对 final类进行继承。（需要导入jar包）

六、用代码演示三种代理

1、静态代理

什么是静态代理

• 由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

代码演示：

我有一段这样的代码：（如何能在不修改UserDao接口类的情况下开事务和关闭事务呢）

public class UserDao {
    public void save() {
        System.out.println("保存数据方法");
    }
}

public class Test {
    public static void main(String[] args) {
        UserDao userDao = new UserDao();
        userDao.save();
    }
}

修改代码，添加代理类

/**
 * 代理类
 */
public class UserDaoProxy extends UserDao {

    private UserDao userDao;

    public UserDaoProxy(UserDao userDao){
        this.userDao=userDao;
    }

    @Override
    public void save(){
        System.out.println("开启事务------>");
        userDao.save();
        System.out.println("关闭事务------>");
    }

}

public class Test {
    public static void main(String[] args){
        UserDao userDao = new UserDao();
        UserDaoProxy userDaoProxy = new UserDaoProxy(userDao);
        userDaoProxy.save();
    }
}

• 缺点：每个需要代理的对象都需要自己重复编写代理，很不舒服，
• 优点：但是可以面相实际对象或者是接口的方式实现代理

2、动态代理

什么是动态代理

• 动态代理也叫做，JDK代理、接口代理。

• 动态代理的对象，是利用JDK的API，动态的在内存中构建代理对象（是根据被代理的接口来动态生成代理类的class文件，并加载运行的过程），这就叫动态代理

public interface UserDao {
    void save();
}

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("保存数据方法");
    }
}

下面是代理类，可重复使用，不像静态代理那样要自己重复编写代理

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

/**
 * 每次生成动态代理类对象时,实现了InvocationHandler接口的调用处理器对象
 */
public class InvocationHandlerImpl implements InvocationHandler {

    // 这其实业务实现类对象，用来调用具体的业务方法
    private Object target;

    // 通过构造函数传入目标对象
    public InvocationHandlerImpl(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("调用开始处理");
        //下面invoke()方法是以反射的方式来创建对象，第一个参数是要创建的对象，第二个是构成方法的参数，由第二个参数来决定创建对象使用哪个构造方法
        Object result = method.invoke(target, args);
        System.out.println("调用结束处理");
        return result;
    }
}

import java.lang.reflect.Proxy;

/**
 * JDK动态代理测试
 */
public class Test {
    public static void main(String[] args){

        //被代理对象
        UserDao userDaoImpl = new UserDaoImpl();
        InvocationHandlerImpl handler = new InvocationHandlerImpl(userDaoImpl);

        //类加载器
        ClassLoader classLoader = userDaoImpl.getClass().getClassLoader();
        Class<?>[] interfaces = userDaoImpl.getClass().getInterfaces();

        //主要装载器、一组接口及调用处理动态代理实例
        UserDao userDao = (UserDao)Proxy.newProxyInstance(classLoader,interfaces,handler);
        userDao.save();
    }
}

打印结果

• 缺点：必须是面向接口，目标业务类必须实现接口
• 优点：不用关心代理类，只需要在运行阶段才指定代理哪一个对象

3、CGLIB动态代理

CGLIB动态代理原理：

• 利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

什么是CGLIB动态代理

• CGLIB动态代理和jdk代理一样，使用反射完成代理，不同的是他可以直接代理类（jdk动态代理不行，他必须目标业务类必须实现接口），CGLIB动态代理底层使用字节码技术，CGLIB动态代理不能对 final类进行继承。（CGLIB动态代理需要导入jar包）

代码演示：

public interface UserDao {
    void save();
}

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("保存数据方法");
    }
}

Cglib动态代理

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * 代理主要类
 */
public class CglibProxy implements MethodInterceptor {

    private Object targetObject;

    // 这里的目标类型为Object，则可以接受任意一种参数作为被代理类，实现了动态代理
    public Object getInstance(Object target) {
        // 设置需要创建子类的类
        this.targetObject = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    //代理实际方法
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开启事物");
        Object result = proxy.invoke(targetObject, args);
        System.out.println("关闭事物");
        // 返回代理对象
        return result;
    }
}

测试类

/**
 * Cglib动态代理测试
 */
public class Test {
    public static void main(String[] args){
        CglibProxy cglibProxy = new CglibProxy();
        UserDao userDao = (UserDao) cglibProxy.getInstance(new UserDaoImpl());
        userDao.save();
    }
}

打印结果

代理模式的应用场景

• 当无法或不想直接引用某个对象或访问某个对象存在困难时，可以通过代理对象来间接访问。使用代理模式主要有两个目的：一是保护目标对象，二是增强目标对象。

 七、代理模式的优缺点

优点：

1. 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
2. 代理对象可以扩展目标对象的功能；
3. 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度，增加了程序的可扩展性

缺点：

1. 代理模式会造成系统设计中类的数量增加
2. 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；
3. 增加了系统的复杂度；