Day04.动态代理扩展

16_代理模式：静态代理

目标

了解静态代理模式实现【了解】

路径

静态代理概述
静态代理案例

静态代理概述

静态代理：

是由程序员创建或工具生成代理类的源码，再编译成为字节码（字节码文件在没有运行java之前就存在了）
在编译时就已经将接口、代理类、被代理类的关系确定下来了
在程序运行之前就已经存在代理类的.class文件

不论是哪一种代理模式，都需要3个角色：

抽象角色（父接口：定义方法） //程序员自己定义（程序运行之前就存在了）
被代理角色（被代理类） //程序员自己定义（程序运行之前就存在了）
代理角色（代理类） //程序员自己定义（程序运行之前就存在了）

静态代理的实现方式：

被代理类和代理类，都实现父接口
被代理类，会作为代理类中的成员存在

静态代理案例

案例：经纪人代理明星

已知存在接口：

//1.抽象角色
interface Star {
    double liveShow(double money);
    void sleep();
}

定义被代理类：王宝强类，实现Star方法

//2.被代理：宝强
class BaoQiang implements Star {
    @Override
    public double liveShow(double money) {
        System.out.println("宝强赚了：" + money + "元");
        return money;
    }

    @Override
    public void sleep() {
        System.out.println("宝强在睡觉~~");
    }
}

定义代理类：经纪人宋喆类

//3.代理：宋喆
class SongZhe implements Star {
    //被代理对象
    private BaoQiang baoQiang;

    public SongZhe(BaoQiang baoQiang) {
        this.baoQiang = baoQiang;
    }

    //代理：就是被代理方法执行前，后做增强
    @Override
    public double liveShow(double money) {
        //前增强
        System.out.println("前置增强：宋喆接了一个跑男节目收到" + money + ",抽取佣金" + money * 0.8);

        double m = baoQiang.liveShow(money * 0.2); //被代理方法执行
        
        //后增强
        System.out.println("后置增强：宋喆帮宝强存了" + m + "元");
        return m;
    }

    @Override
    public void sleep() {
        System.out.println("宋喆帮宝强，找了一个6星级酒店~~");

        baoQiang.sleep();

        System.out.println("宋喆帮宝强退房");
    }
}

定义测试类：

public class Demo01 {
    public static void main(String[] args) {
        //被代理
        BaoQiang baoQiang = new BaoQiang();

        //代理
        SongZhe songZhe = new SongZhe(baoQiang);

        double v = songZhe.liveShow(100);
        System.out.println("v = " + v);

        System.out.println();
        System.out.println();

        songZhe.sleep();
    }
}

关系图：

宋喆和王宝强都有共同的父类型，具有相同的业务方法

静态代理和装饰模式的对比：

原则上的区别，代理为了控制对某个函数前后的操作，而装饰着模式是为了添加某一操作（其实目标没差太远）

小结

静态代理：

需要有三个角色：抽象角色(父接口)、被代理角色(被代理类)、代理角色(代理类)
- 被代理类和代理类，都是实现父接口
在程序执行之前，就要确定了三个角色关系，生成.class文件（在程序运行之前就已经生成了）
- 随着程序的执行，.class文件都会被加载到jvm中

17_代理模式：动态代理概述

目标

了解什么是动态代理

路径

动态代理概述

动态代理

在上面静态代理的例子中，代理类(SongZhe)是自己定义好的，在程序运行之前就已经编译完成

然而动态代理中，代理类是在程序运行时利用反射机制动态创建的，这种代理方式被成为动态代理

在实际开发过程中动态代理是通过JDK提供的Proxy类在程序运行时，运用反射机制动态创建而成

大白话：静态代理需要自己写代理类、动态代理不用自己写代理类

动态代理技术在框架中使用居多，例如：很快要学到的数据库框架MyBatis框架等后期学的一些主流框架技术（Spring，SpringMVC）中都使用了动态代理技术

虽然我们不需要自己定义代理类创建代理对象，但是我们要定义对被代理对象访问方法的拦截逻辑

代理类的作用，就是让被代理对象的某个方法执行之前或者执行之后加入其他增强逻辑（要在被代理对象的方法执行前进行拦截）

小结

动态代理：

不用程序员自己书写代理类，使用JDK提供的Proxy类实现代理
动态代理是在程序执行过程中，利用反射技术，动态的创建代理类对象

18_代理模式：动态代理流程图

目标

理解动态代理模式执行流程

路径

图解分析动态代理执行流程

19_代理模式：动态代理API

目标

熟悉动态代理相关API

路径

动态代理API介绍

动态代理API

在java中实现动态代理，关键要使用到一个Proxy类和一个InvocationHandler接口

Proxy类

java.lang.reflect.Proxy：是 Java 动态代理机制的主类(父类)，它提供了用于创建动态代理类和实例的静态方法

public static Object newProxyInstance(
                                      ClassLoader loader, 
                                      Class<?>[] interfaces, 
                                      InvocationHandler handle 
                                     ) 
**解释说明：    
- 返回值：     该方法返回就是动态生成的代理对象
- 参数列表说明：
  ClassLoader loader         ：定义代理类的类加载器
  Class<?>[] interfaces      ：代理类要实现的接口列表，要求与被代理类的接口一样
  InvocationHandler handle   ：就是具体实现代理逻辑的接口 
    
    
//参数的应用：
ClassLoader loader     //对象.getClass().getClassLoader()  
           //目标对象通过getClass方法获取类的所有信息后，调用getClassLoader()方法来获取类加载器
           /*获取类加载器后，可以通过这个类型的加载器，在程序运行时，将生成的代理类加载到JVM即Java              虚拟机中，以便运行时需要*/ 
    
Class<?>[] interfaces  //对象.getClass().getInterfaces() 
           //获取被代理类的所有接口信息，以便于生成的代理类可以具有代理类接口中的所有方法
    
    
InvocationHandler 
          //用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类方法的处理以及访问

InvocationHandler接口

java.lang.reflect.InvocationHandler是代理对象的实际处理代理逻辑的接口，具体代理逻辑在其 invoke 方法中实现

public Object invoke(Object proxy, Method method, Object[] args)
**解释说明：
- 返回值：方法被代理后执行的结果
- 参数列表说明：
  Object proxy   ：  就是代理对象（通常不使用）
  Method method  ：  代理对象调用的方法
  Object[] args  ：  被代理方法中的参数 （因为参数个数不定，所以用一个对象数组来表示）
                     如果方法不使用参数，则为 null
    
//所有代理对象调用的方法，执行是都会经过invoke
//因此如果要对某个方法进行代理增强，就可以在这个invoke方法中进行定义

20_代理模式：动态代理实现

目标

掌握动态代理模式代码书写逻辑

路径

案例：使用动态代理实现明星经纪人

案例

需求：将经纪人代理明星的案例使用动态代理实现

前置动作：

定义父接口
定义被代理类：王宝强

//父接口（抽象角色）
interface Star {
    double liveShow(double money);

    void sleep();
}

//被代理类：王宝强
class BaoQiang implements Star {
    @Override
    public double liveShow(double money) {
        System.out.println("宝强表演节目，赚了" + money + "元");
        return money;
    }

    @Override
    public void sleep() {
        System.out.println("宝强累了，去睡觉了！！");
    }
}

动态代理类生成：

public class Demo01 {
    public static void main(String[] args) {
        //创建被代理对象
        BaoQiang baoQiang = new BaoQiang();

        //创建代理对象
        //获取类加载器
        ClassLoader loader = baoQiang.getClass().getClassLoader();
        //获取被代理类的接口
        Class[] interfaces = baoQiang.getClass().getInterfaces();//Star
        //定义调用处理器（具体实现业务代理）
        InvocationHandler handler = new MyInvocationHandler(baoQiang);

        Object proxyObj = Proxy.newProxyInstance(loader, interfaces, handler);
        
        //proxyObj :即是Proxy的子类，也是Star的实现类
        Star starProxy = (Star) proxyObj;//多态

        double money = starProxy.liveShow(100);//这里一调用就会传入到invoke，invoke方法运行结束又会传回来
        
        System.out.println("money = " + money);

        starProxy.sleep();
    }
}

定义代理逻辑：

//具体实现代理逻辑
class MyInvocationHandler implements InvocationHandler {
    private BaoQiang baoQiang;

    public MyInvocationHandler(BaoQiang baoQiang) {
        this.baoQiang = baoQiang;
    }

    //代理对象调用的方法，都会经过这里
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //写代理逻辑
        String methodName = method.getName();
        System.out.println("调用的方法是：" + methodName + ",入参：" + Arrays.toString(args));

        //代理liveShow
        if (methodName.equals("liveShow")) {
            //前增强
            double m = (double) args[0];
            System.out.println("宋喆抽取佣金" + m * 0.8);
            
            Object result = method.invoke(baoQiang, m * 0.2);
            
            //后增强
            System.out.println("宋喆帮宝强存了" + result + "元到银行");
           
            return result;
        }

        //不写代理逻辑
        Object result = method.invoke(baoQiang, args);
        System.out.println("被代理调用结果" + result);
        return result;
    }
}