Java-JDK动态代理

第一章:代理的介绍

动态代理(理解) 基于反射机制
1.什么是动态代理?

2.动态代理能够做什么?

1.什么是代理?

代理,在我们日常生活之中就有体现,代购,中介,换ip,商家等等.

比如有一家美国的大学,可以对全世界招生.留学中介(代理 )

留学中介(代理):帮助这家美国的学校招生,中介是学校的代理中介是代替学校完成招生功能
代理特点

中介和代理他们要做的事情是一致的:招生
中介是学校代理,学校是目标
家长-------->中介(学校介绍,办理入学手续)---------->美国学校
中介是代理,收取费用

2.为什么要找中介

为什么要找中介?
1.中介是专业的,方便.
2.家长现在不能自己去找学校。家长没有能力访问学校.或者美国学校不接收个人来访

买东西都是商家卖, 商家是某个商品的代理, 你个人买东西,肯定不会让你接触到厂家的.

第二章:静态代理

2.1 使用代理模式的作用

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

2.2 实现代理的方式

1.静态代理:

1)代理类是自己手工实现的,自己创建一个java类,表示代理类

2)同时你所要代理的目标

特点：1）实现简单2）容易理解。
模拟一个用户购买u盘的行为。
用户是客户端类
商家：代理，代理某个品牌的u盘。
厂家：目标类。
三者的关系：用户（客户端）-—-商家（代理）-—-厂家（目标）
商家和厂家都是卖u盘的，他们完成的功能是一致的，都是卖u盘。

实现步骤:

实现步骤
1.创建一个接口,定义卖u盘的方法,表示你的厂家和商家做的事情
2.创建厂家类,实现1步骤的接口
3.创建商家,就是代理,也需要实现1步骤中的接口
4.创建客户端类,调用商家的方法买一个u盘

2.3 具体实现

第一步：创建一个接口，定义方法，表示真实角色和代理角色需要实现的方法

public interface usbSell {
    /**
     * 定义一个方法 参数 amount:表示一次购买的数量,暂时不用
     * 返回值表示一个u盘的价格
     * @param amount
     * @return
     */
    float sell(int amount);
}

第二步：创建真实角色，实现第一步的接口

public class UsbKingFactory implements usbSell {
    /**
     * 定义一个方法 参数 amount:表示一次购买的数量,暂时不用
     * 返回值表示一个u盘的价格
     *
     * @param amount
     * @return
     */
    @Override
    public float sell(int amount) {

        return 85.0f*amount;
    }
}

第三步：创建代理角色，实现1的接口

//京东是一个商家,代理金士顿U盘的销售
public class JingDong implements usbSell {
    //      声明 商家代理的厂家具体是谁
    private UsbKingFactory factory=new UsbKingFactory();
    @Override
    //    实现销售U盘功能
    public float sell(int amount) {
        //        向厂家发送订单,告诉厂家,我买了U盘,厂家发货
//        发送给工厂,我需要的订单,返回报价
        float price = factory.sell(amount);
//        商家需要加价也就是代理要增加价格
        price = price + 25;
//在目标类的方法调用后,你做的其他功能,都是增强的意思
        System.out.println("淘宝再给你返回一个优惠券,或者红包");
//        增加的价格
        return price;
    }
}

第四步：创建客户访问类，调用代理角色实现真实角色的方法

public class Client {
    public static void main(String[] args) {
        //             创建代理的商家京东对象
        JingDong jingDong = new JingDong();

        float price=jingDong.sell(5);
        System.out.println("购买5个产品在京东，购买价格为："+price);
    }
}

所以我们再次总结代理类完成的功能:

目标类中方法的调用
功能增强
所属我们只有一个代理商,我们实际上可以写多个代理商。

2.4 静态代理的优缺点

我们再次总结一下静态代理的优缺点

优点:

实现简单

缺点:当你的项目中,目标类的代理类很多的时候,有一下的缺点

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

第三章 动态代理

1)什么是动态代理?

​ 使用jdk的反射机制,创建对象的能力,创建的是代理类的的对象.而不用我们创建类文件,不用写java文件, 什么叫动态?在程序执行时,调用jdk提供的方法才能创建代理类的对象

2)知道动态代理能做什么?

3.1 静态代理和动态代理模式的对比

在静态代理中目标很多的时候,可以使用动态代理,避免静态代理的缺点

动态代理中目标类即使很多,

• 代理类数量可以很少,
• 当你修改了接口中的方法时,不会影响代理类。

动态代理:在程序执行过程中,使用jdk的反射机制,创建代理类对象,并动态的指定要代理目标类。

换句话说:动态代理是一种创建java对象的能力,让你不用创建 代理类就能创建代理类对象,除去了中间商。

在java中,要想创建对象

1. 创建类文件,java 文件编译为class
2. 使用构造方法,创建类的对象

3.2 动态代理的介绍

1. 动态代理是指代理类对象在程序运行时由JVM根据反射机制动态生成的。动态代理不需要定义代理类的，java源文件。
2. 动态代理其实就是jdk运行期间，动态创建class字节码并加载到JVM。
3. 动态代理的实现方式常用的有两种：使用JDK代理，与通过CGLlB动态代理。

动态代理的实现:
1.jdk动态代理(理解):使用java反射包中的类和接口实现动态代理的功能,反射包java.lang.reflect,里面有三个类:

• InvocationHandler
• Method
• Proxy

2.cglib动态代理(了解): cglib是第三方的工具库,创建代理对象

1. cglib的原理是继承，cglib通过继承目标类，创建它的子类，在子类中重写父类中同名的方法，实现功能的修改。
2. 因为cglib是继承，重写方法，所以要求目标类不能是fina1的，方法也不能是final的。cglib的要求目标类比较宽松，只要能继承就可以了。cglib在很多的框架中使用，比如mybatis，spring框架中都有使用。

3.3反射回顾案例

正常接口类与接口类的实现逻辑是：
接口类

public interface HelloService {

    // 根 name 打招呼
    public void sayHello(String name);
    //public void sayHello(Integer i);
}

接口实现类

public class HelloServiceImpl  implements HelloService {
    @Override
    public void sayHello(String name) {
        System.out.println("你好："+name);
    }
}

测试类：

public class TestApp {
    public static void main(String[] args){
        HelloService service = new HelloServiceImpl();
        service.sayHello("张三");
        }
}

通过反射机制执行该方法的测试类如下

• 获取对应类的class对象，获取相应的method对象管理中的方法即可getMethod(“方法名”,返回类型.class);该函数返回一个method对象
• method类中的invoke方法：invoke(对象, 方法执行的参数值);返回值是一个object，invoke需要抛出异常

//        获取方法名称对应的Method类对象
//         public Method getM   ethod(String name, Class<?>... parameterTypes)
//        加入,该方法的参数有多个该怎么办?
//        parameterTypes参数是一个类对象数组，按声明的顺序标识方法的形式参数类型。
public Object invoke(Object obj, Object... args)
通过Metho可以执行sayhello方法的调用
        /*
        *  public Object invoke(Object obj, Object... args)
        *       表示执行方法的调用
        *   参数:
        *       1.Object,表示对象,要执行这个对象的方法
        *       2.Object...args,方法执行时的参数值
        * 返回值:
        *       Object:方法执行后的返回值
        * */

    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
//使用反射机制执行sayHello方法。 核心Method（类中的方法）
        HelloService target=new HelloServiceImpl();
//获取sayHello方法对应的Method类对象
        Method method=HelloService.class.getMethod("sayHello", String.class);
//通过Method可以执行sayHello方法调用
        method.invoke(target,"李四");
        //表达的意思就是 执行target对象sayHello,参数是李四
    }

如果此时有另一个抽象类改写该接口，只需要在测试类下面加一下函数即可

    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
//使用反射机制执行sayHello方法。 核心Method（类中的方法）
        HelloService target=new HelloServiceImpl();
        HelloService target2=new HelloServiceImpl2();

//获取sayHello方法对应的Method类对象
        Method method=HelloService.class.getMethod("sayHello", String.class);
//通过Method可以执行sayHello方法调用
        method.invoke(target2,"李四");
        //表达的意思就是 执行target对象sayHello,参数是李四
    }

3.4原理实现

反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy

• InvocationHandler（调用处理器）就一个方法invoke()，表示代理对象要执行的代理类方法。也就是中介类，调用目标方法以及增强其功能

 public Object invoke(Object proxy, Method method, Object[] args)

参数：

• Object proxy:jdk创建的代理对象，无需赋值。
• Method method:目标类中的方法，jdk提供method对象的
• Object[] args：目标类中方法的参数， jdk提供的

InvocationHandler 接口：重写具体invoke的方法，表明接口功能：
具体如何调用该方法：

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

---

• Method类：目标类中的方法Method.invoke();为method的方法

该invoke与上面的invoke不同，上方的invoke是接口方法
具体函数调用method.invoke(目标对象，方法的参数)
比如上方的函数Object ret = method.invoke(service2, “李四”);
等同于静态代理中的float price = factory.sell(amount); //厂家的价格。

---

• Proxy类：核心的对象，创建代理对象。之前创建对象都是 new 类的构造方法()
  静态方法 newProxyInstance()
  创建代理对象， 等同于静态代理中的TaoBao taoBao = new TaoBao();
  该方法函数的原型是

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

参数说明:

1. ClassLoader loader 类加载器，负责向内存中加载对象的。
   使用反射获取对象的ClassLoader。比如类a，a.getCalss().getClassLoader(), 目标对象的类加载器
2. Class<?>[] interfaces： 接口， 目标对象实现的接口，也是反射获取的
3. InvocationHandler h : 我们自己写的，代理类要完成的功能
4. 返回值是代理类对象Object，得到一个目标对象

具体实现动态代理的步骤为：
1、创建接口，定义目标类要完成的功能
2、创建目标类实现接口（真实角色）
3、创建InvocationHandler接口的实现类，在invoke方法中完成代理类的功能（调用目标方法，增强功能）——（代理角色）
4、使用Proxy类的静态方法，创建代理对象，并把返回值转为接口类型。

3.5实现案例

接口类：

public interface UsbSell {
    float sell(int amount);
    void print();
}

接口的实现类——真实角色

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

    @Override
    public void print() {
        System.out.println("目标类中的print方法被调用！");
    }
}

此处与静态代理不同的是，动态代理改写InvocationHandler，实现代理类的功能

• 创建一个目标对象，而且需要给一个构造函数

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;
        //等价于静态代理中的 float price=factory.sell(amount);
        res = method.invoke(target,args);

        if(method.getName().equals("sell")) {
            //增强功能
            //price=price+25;
            if (res != null) {
                Float price = (Float) res + 25 * (int) args[0];
                res = price;
            }
            System.out.println("赠送京东优惠券");
            return res;
        }
        else
        {
            return null;
        }
    }

具体的测试类

先创建代理对象，使用proxy
以下的创建代理对象是固定的参数

/**
 * 动态代理：
 *  特点：字节码随用随创建，随用随加载
 *  作用：不修改源码的基础上对方法增强
 *  分类：
 *      基于接口的动态代理
 *      基于子类的动态代理
 *  基于接口的动态代理：
 *      涉及的类：Proxy
 *      提供者：JDK官方
 *  如何创建代理对象：
 *      使用Proxy类中的newProxyInstance方法
 *  创建代理对象的要求：
 *      被代理类最少实现一个接口，如果没有则不能使用
 *  newProxyInstance方法的参数：
 *      ClassLoader：类加载器
 *          它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
 *      Class[]：字节码数组
 *          它是用于让代理对象和被代理对象有相同方法。固定写法。
 *      InvocationHandler：用于提供增强的代码
 *          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
 *          此接口的实现类都是谁用谁写。
 */

public static void main(String[] args) {
    //创建代理对象
    //1.创建目标对象，2.创建InvocationHandler对象 3.创建代理对象
    //1.创建目标对象
    UsbSell factory=new UsbSellImpl();
    //2.创建InvocationHandler对象
    InvocationHandler handler=new MySellHandler(factory);
    //3.创建代理对象
    UsbSell proxy = (UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(),
            factory.getClass().getInterfaces(),
            handler);

    System.out.println("proxy"+proxy.getClass().getName());
    float price=proxy.sell(10);
    System.out.println("购买10个产品通过动态代理对象，调用方法的价格是"+price);
    proxy.print();
}

动态代理的执行步骤

1. 创建目标对象，通过接口以及多态
2. 创建InvocationHandler对象
3. 创建代理类对象，返回值是一个接口类的目标类对象（获取类的加载器，获取类的接口，InvocationHandler对象），该步骤是固定值
4. 执行代理类中的方法

具体代码执行的步骤是

• 通过proxy对象（jdk自带的，他的类是com.sun.proxy.$Proxy0
  通过调用方法传参proxy.sell(1);到invoke中，原型为public Object invoke(Object proxy,
  Method method, Object[] args) throws Throwable
  sell对应该参数中的method，args代表参数为1。此时的sell对应的是接口中的方法参数
• 通过method类的invoke改写接口，调用该目标类的方法，以及增加额外的功能。具体调用目标类方法为
  method.invoke(target,args);。target对应的方法是改写后的接口方法sell
• 调用改写后的接口sell，得到的返回值为85，在增加额外的功能，变成110.返回110的参数给执行代理的方法

动态代理模板

1. 创建目标对象 接口类 接口对象 =new 接口实现类();
2. 创建InvocationHandler对象InvocationHandler handler = new
   MySellHandler(接口类对象);
3. 创建代理对象接口类 proxy = (接口类)
   Proxy.newProxyInstance(factory.getClass().getClassLoader(),
   factory.getClass().getInterfaces(),handler);
4. 通过代理执行方法proxy.方法();