Java动态代理

动态代理

动态代理理解

动态代理： 基于反射机制。

买家---------------------淘宝商家-------------------------------生产厂家
用户---------------------代理对象-------------------------------目标对象

什么是动态代理

使用jdk的反射机制，创建对象的能力， 创建的是代理类的对象。 而不用你创建类文件。不用写java文件。
动态：在程序执行时，调用jdk提供的方法才能创建代理类的对象。

jdk动态代理，必须有接口，目标类必须实现接口， 没有接口时，需要使用cglib动态代理

知道动态代理能做什么

可以在不改变原来目标方法功能的前提下， 可以在代理中增强自己的功能代码。

使用代理模式的作用

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

实现代理的方式

静态代理 ：

1. 代理类是自己手工实现的，自己创建一个java类，表示代理类。
2. 同时你所要代理的目标类是确定的。

特点：

1. 实现简单

2. 容易理解。

缺点：

1. 当目标类增加了， 代理类可能也需要成倍的增加。 代理类数量过多。
2. 当你的接口中功能增加了， 或者修改了，会影响众多的实现类，厂家类，代理都需要修改。影响比较多。

动态代理

优点

1. 动态代理弥补了静态代理的缺点
2. 动态代理中目标类即使很多，代理类数量可以很少，
3. 当你修改了接口中的方法时，不会影响代理类。

理解

在程序执行过程中，使用jdk的反射机制，创建代理类对象， 并动态的指定要代理目标类。
换句话说： 动态代理是一种创建java对象的能力，让你不用创建TaoBao类，就能创建代理类对象。

在java中，要想创建对象：
1.创建类文件， java文件编译为class
2.使用构造方法，创建类的对象。

动态代理的实现：

1. jdk动态代理（理解）： 使用java反射包中的类和接口实现动态代理的功能。
   反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy.

2. cglib动态代理（了解）: cglib是第三方的工具库， 创建代理对象。
   cglib的原理是继承， cglib通过继承目标类，创建它的子类，在子类中重写父类中同名的方法， 实现功能的修改。

   因为cglib是继承，重写方法，所以要求目标类不能是final的， 方法也不能是final的。
   cglib的要求目标类比较宽松， 只要能继承就可以了。cglib在很多的框架中使用， 比如 mybatis ，spring框架中都有使用。

​ jdk动态代理：
​ 1. 反射， Method类，表示方法。类中的方法。 通过Method可以执行某个方法。
​
​ 2. jdk动态代理的实现
​ 反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy.
​

动态代理的三个类

InvocationHandler接口

InvocationHandler 接口（调用处理器）：唯一方法 invoke（）

invoke（）表示代理对象要执行的功能代码（代理类相当于中介）

这个invoke()是这个接口中的方法

代理类需要完成的功能：

1. 调用目标方法，执行目标方法的功能。
2. 功能增强，在目标方法调用时，增强功能。

代理类都用来干什么：

     //方法原型：
			public Object invoke(Object proxy, Method method, Object[] args)		
	//参数： 
	Object proxy:jdk创建的代理对象，无需赋值（jdk自动完成，不需要要管理）
	Method method:目标类中的方法，也不需要赋值，jdk提供method对象的
	Object[] args：目标类中方法的参数，也不需要赋值，jdk提供的。

怎么用这个接口呢

1. 创建类实现接口InvocationHandler
2. 重写invoke（）方法， 把原来静态代理中代理类要完成的功能，写在这。

Method类：

Method类：表示方法的， 确切的说就是目标类中的方法。
​ 作用：通过Method可以执行某个目标类的方法，Method.invoke();

这个invoke()是这类中的方法

//使用方法：
//通过这个method.invloke()方法可以执行任意对象的方法，而不需要知道这个方法的名称。
method.invoke(目标对象，方法的参数)
 Object ret = method.invoke(service2, "李四");  

参数：
    1.Object obj :表示对象的，要执行的这个对象的方法
    2.Object... arg : 表示方法执行时的参数值
    返回值：方法执行后的返回值。

说明： method.invoke（）就是用来执行目标方法的，
等同于 静态代理中的，代理类调用目标类中的方法，向厂家发送订单，告诉厂家，我买了u盘，厂家发货

Proxy类：

Proxy类：核心的对象，创建代理对象。
通过Proxy类，我们可以使用Proxy类的方法，代替new对象的使用。

Proxy类的方法： 静态方法 newProxyInstance()
作用是： 创建代理对象，
等同于 new 代理类（中介类）

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
参数：
1. /*ClassLoader loader : 类加载器，负责向内存中加载对象的。 
如何获取loader对象呢：
    使用反射获取对象的ClassLoader
    例如一个类（目标对象的类加载器），a.class      
    a.getCalss().getClassLoader(): 就可以获取loader这个值*/
        
2./*Class<?>[] interfaces: 接口,目标对象实现的接口，也是 反射 获取的。*/

3./*InvocationHandler h : 我们自己写的，代理类要完成的功能。*/ 

这个静态方法的返回值：就是这个目标对象的代理对象

通常使用方式：Proxy.newProxyInstance(参数，参数，参数)							

实现动态代理的步骤：

步骤

1. 创建接口，定义目标类要完成的功能
2. 创建目标类实现接口
3. 创建InvocationHandler接口的实现类，在invoke方法中完成代理类的功能
   1. 调用目标方法
   2. 增强功能
4. 使用Proxy类的静态方法，创建代理对象。 并把返回值转为接口类型。

实例

目标接口

package com.bjpowernode.service;

//目标接口
public interface UsbSell {

    float sell(int amount);

    void print();
}

目标类

package com.bjpowernode.factory;

import com.bjpowernode.service.UsbSell;

//目标类
public class UsbKingFactory implements UsbSell {
    @Override
    public float sell(int amount) {
        //目标方法
        System.out.println("目标类中，执行sell目标方法");
        return 85.0f;
    }

    @Override
    public void print() {

    }
}

代理类

package com.bjpowernode.handler;

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

//必须实现InvocationHandler接口，完成代理类要做的功能（1.调用目标方法，2.功能增强）
public class MySellHandler implements InvocationHandler {

    private Object target = null;

    //动态代理：目标对象是活动的，不是固定的，需要传入进来。
    //传入是谁，就给谁创建代理。
    public MySellHandler(Object target) {
        //给目标对象赋值
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        Object res  = null;
        //向厂家发送订单，告诉厂家，我买了u盘，厂家发货
        //float price = factory.sell(amount); //厂家的价格。
        res =  method.invoke(target,args); //执行目标方法



        //商家 需要加价， 也就是代理要增加价格。
        //price = price + 25; //增强功能，代理类在完成目标类方法调用后，增强了功能。
        if( res != null ){
            Float price = (Float)res;
            price = price + 25;
            res = price;
        }

        //在目标类的方法调用后，你做的其它功能，都是增强的意思。
        System.out.println("淘宝商家，给你返一个优惠券，或者红包");
        //记录数据库

        //增加的价格
        return res;

    }
}

用户类

package com.bjpowernode;

import com.bjpowernode.factory.UsbKingFactory;
import com.bjpowernode.handler.MySellHandler;
import com.bjpowernode.service.UsbSell;

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

public class MainShop {

    public static void main(String[] args) {
        //创建代理对象，使用Proxy
        //1. 创建目标对象
        // UsbKingFacotry  factory = new UsbKingFactory();
        UsbSell factory = new UsbKingFactory();
        //2.创建InvocationHandler对象
        InvocationHandler handler = new MySellHandler(factory);

        //3.创建代理对象
        UsbSell proxy = (UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(),
                factory.getClass().getInterfaces(),
                handler);

        //com.sun.proxy.$Proxy0 : 这是jdk动态代理创建的对象类型。
        System.out.println("proxy:"+proxy.getClass().getName());
        //4.通过代理执行方法
        float price = proxy.sell(1);
        System.out.println("通过动态代理对象，调用方法："+price);
    }
}