动态代理

代理模式

代理模式是指，为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户类和目标对象之
间起到中介的作用。

使用代理对象，是为了在不修改目标对象的基础上，增强主业务逻辑。客户类真正的想要访问的对象是目标对象，但客户类真正可以访问的对象是代理对象。客户类对目标对象的访问是通过访问代理对象来实现的

1.使用代理模式的作用

1. 功能增强：在原有的功能上增加了额外的功能。新增加的功能叫做功能增强。
2. 控制访问：代理类不让你访问目标。例如商家不让用户访问厂家。

2.实现代理的方式

1. 静态代理
2. 动态代理

静态代理

静态代理是指，代理类在程序运行前就已经定义好.java 源文件，其与目标类的关系在程序运行前就已经确立。在程序运行前代理类已经编译为.class 文件。

1.静态代理的缺点

（1） 代码复杂，难于管理
代理类和目标类实现了相同的接口，每个代理都需要实现目标类的方法，这样就出现了大量的代
码重复。如果接口增加一个方法，除了所有目标类需要实现这个方法外，所有代理类也需要实现
此方法。增加了代码维护的复杂度。

（2） 代理类依赖目标类，代理类过多
代理类只服务于一种类型的目标类，如果要服务多个类型。势必要为每一种目标类都进行代理，
静态代理在程序规模稍大时就无法胜任了，代理类数量过多。

动态代理

1.概述

动态代理是指代理类对象在程序运行时由JVM根据反射机制动态生成的。动态代理不需要定义代理类的.java源文件。

2.动态代理的实现方式

1. 使用 JDK 的 Proxy
2. 与通过 CGLIB 生成代理

3.JDK动态代理

Jdk 的动态代理要求目标对象必须实现接口，这是 java 设计上的要求。 jdk动态代理是基于Java的反射机制实现的。使用jdk中接口和类实现代理对象的动态创建。从 jdk1.3 以来，java语言通过java.lang.reflect包提供三个类支持代理模式Proxy,Method和InvocationHandler。

1. InvocationHandler接口：InvocationHandler接口叫做调用处理器，该接口的实现类的invoke方法负责调用目标接口中的方法，并增强功能。实现了InvocationHandler接口的类用于加强目标类的主业务逻辑

// 该接口中的唯一方法
// 在 invoke 方法中可以截取对目标方法的调用。在这里进行功能增强

proxy:代表生成的代理对象，JDK运行时赋值，在方法中直接使用
method：代表目标方法
args:代表目标方法的参数，JDK运行时赋值
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return null;
    }

2. Method类：invoke()方法的第二个参数为Method类对象，该类有一个方法也叫 invoke()，可以调用目标方法。

public Object invoke ( Object obj, Object... args) 
obj：表示目标对象
args：表示目标方法参数，就是InvocationHandler
接口中invoke 方法的第三个参数

3. Proxy类:通 过 JDK 的 java.lang.reflect.Proxy 类 实 现 动 态 代 理 ， 会 使 用 其 静 态 方 法
   newProxyInstance()，依据目标对象、业务接口及调用处理器三者，自动生成一个动态代理对
   象。

loader：目标类的类加载器，通过目标对象的反射可获取
interfaces：目标类实现的接口数组，通过目标对象的反射可获取
handler：调用处理器，即实现了InvocationHandler接口的实现类对象。
 public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)

4. 示例1：

1、新建一个接口，作为目标接口
    /*
    定义目标接口
     */
    public interface UsbSell {
        float sell(int amount);
    }
2、为接口创建一个实现类，是目标类
    /**
     * 定义目标接口实现类
     */
    public class UsbFactory implements UsbSell {
        @Override
        public float sell(int amount) {
            return 90.0F;
        }
    }

3、创建类实现 java.lang.reflect.InvocationHandler 接口，调用目标方法并增加其他功能代码
    /**
 * 定义调用处理程序
 */
public class MyHandler implements InvocationHandler {
    private Object target = null; // 目标对象

    public MyHandler() {
    }

    public MyHandler(Object target) {
        // 使用构造方法传入目标对象，给目标对象提供代理功能
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 执行目标方法
        Object ret = method.invoke(target, args);
        // 在目标方法执行之后，增强功能
        float price = (float)ret;
        ret =  price + 20;
        System.out.println("优惠活动！");
        return ret;
    }
}
4、创建动态代理对象，使用 Proxy.newProxyInstance()方法，并把返回值强制转为接口类型。
        // 创建调用处理器
        UsbFactory factory = new UsbFactory();
        MyHandler handler = new MyHandler(factory);
        // 创建JDK动态代理
        UsbSell taobao = (UsbSell)Proxy.newProxyInstance(factory.getClass().getClassLoader(),
                factory.getClass().getInterfaces(),
                handler);
        float price = taobao.sell(1);
        System.out.println(price);

5. 示例2：为业务方法增加打印日志功能
   1. 业务接口和实现类如下

   public interface UserService {
       void login();
   }
   public class UserServiceImpl implements UserService {
       @Override
       public void login() {
           System.out.println("login success！");
       }
   }
   

   2. 调用处理器如下

   public class UserInvocationHandler implements InvocationHandler {
       // 目标对象
       private Object tarket;
   
       public UserInvocationHandler() {
   
       }
       public UserInvocationHandler(Object tarket) {
           this.tarket = tarket;
       }
       @Override
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           // 调用目标对象的方法
           method.invoke(tarket, null);
           // 增强功能
           System.out.println("login time：" + new Date());
           return null;
       }
   }
   

   3. 测试

   public static void main(String[] args) {
         // 创建目标对象
         UserServiceImpl userService = new UserServiceImpl();
         // 创建调用处理器
         UserInvocationHandler handler = new UserInvocationHandler(userService);
         // 创建代理对象
         UserService proxy = (UserService) Proxy.newProxyInstance(UserServiceImpl.class.getClassLoader(),
                 UserServiceImpl.class.getInterfaces(),
                 handler);
         proxy.login();
     }
   

4.CGLIB动态代理

在运行期扩展 Java 类与实现 Java接口。它广泛的被许多 AOP 的框架使用，例如 Spring AOP。CGLIB 代理的原理是生成目标类的子类，而子类是增强过的，这个子类对象就是代理对象。所以，使用 CGLIB 生成动态代理，要求目标类必须能够被继承，即不能是 final 的类。cglib 的代理效率高于 Jdk