动态代理

第一章：代理模式

代理模式是指，为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，

一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户类和目标对象之

间起到中介的作用。

1.什么是代理

代理：代购，中介，换ip，商家等等

例如有一家美国的大学，可以对全世界招生。

留学中介（代理）：帮助这家美国的学校招生，中介是学校的代理，中介是代替学校完成招生功能。

2.代理的特点

1、中介和代理他们要做的事情是一致的：招生。
2、中介是学校代理，学校是目标。
3、家长 ---> 中介（学校介绍，办入学手续）----> 美国学校。
4、中介是代理，不能白干活，需要收取费用。
5、代理不让你访问到目标。

3.为什么要找代理（中介）

a、中介是专业的，方便
b、家长现在不能自己去找学校。家长没有能力访问学校。或者美国学校不接收个人来访。

在开发中也会有这样的情况，你有a类，想是调用c类的方法，完成某个功能。但是c不让a调用。

a不能调用c的方法。
你可以在a和c直接创建一个b代理， c让b访问。
a ---> 访问b ---> 访问c

4.使用代理模式的作用

a.功能增强：在你原有的功能上，增加了额外的功能。新增加的功能，叫做功能增强。

b.控制访问：代理类不让你访问目标，例如商家不让用户访问厂家。

5.实现代理的方式

1、分类

a.静态代理

b.动态代理

2、需求

模拟一个用户购买u盘的行为。

用户是客户端类
商家：代理，代理某个品牌的u盘。
厂家：目标类。

三者的关系：用户（客户端）---商家（代理）---厂家（目标）
商家和厂家都是卖u盘的，他们完成的功能是一致的，都是卖u盘。

第二章：静态代理

1.静态代理实现步骤

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

2.静态代理接口和目标类的创建

代理接口

 // 接口，表示功能的
public interface UsbSell {
     // 定义方法 参数 amount：表示一次购买的数量，暂时用
     // 返回值表示一个u盘的价格
     float sell(int amount);

 }

目标类

// 目标类，金士顿厂家,不接受用户的单独购买
public class UsbKingFactory implements UsbSell {
    @Override
    public float sell(int amount) {
        return 85f;
    }
}

// 目标类，闪迪厂家,不接受用户的单独购买
public class UsbSanFactory implements UsbSell {
    @Override
    public float sell(int amount) {
        return 75f;
    }
}

创建代理类

public class TaoBao implements UsbSell {

    // 声明厂家
    private UsbKingFactory factory = new UsbKingFactory();

    private UsbSanFactory factory02 = new UsbSanFactory();

    @Override
    // 功能实现
    public float sell(int amount) {

        // 向厂家发送订单
        float price = factory02.sell(amount);
        // 商家获取利润
        price = price + 25;
        System.out.println("亲，5星好评加25字长评可以获取2元现金红包");
        return price;
    }
}

public class WeChaShop implements UsbSell {
    // 代理的是 金士顿 定义目标厂商类
    private UsbKingFactory factory = new UsbKingFactory();

    @Override
    public float sell(int amount) {
        // 调用目标方法
        float price = factory.sell(amount);
        // 利润低，不返回红包了
        price = price + 10;
        return price;
    }
}

4.定义测试类

public class Shop {
    public static void main(String[] args) {
        // 创建代理的商家对象

        TaoBao taoBao = new TaoBao();
        float price = taoBao.sell(1);
        System.out.println("通过淘宝的商家购买的价格：" + price);

       /* WeChaShop weChaShop = new WeChaShop();
        float price = weChaShop.sell(1);
        System.out.println("通过微商购买的价格：" + price);*/
    }
}

运行结果如下

5.静态代理的优缺点

优点：

1、实现简单

2、容易理解。
缺点：

条件：当你的项目中，目标类和代理类很多时候，有以下的缺点：
1、当目标类增加了，代理类可能也需要成倍的增加。代理类数量过多。
2、当你的接口中功能增加了，或者修改了，会影响众多的实现类，厂家类，代理都需要修改。
影响比较多。

第三章：动态代理

1.什么是动态代理

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

2.动态代理的分类

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

2、cglib动态代理（了解）: cglib是第三方的工具库，创建代理对象。

cglib的原理是继承， cglib通过继承目标类，创建它的子类，在子类中
重写父类中同名的方法，实现功能的修改。

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

3.回顾Method

1、定义一个接口

1 public interface HelloService {
2     // 目的 和name打招呼
3     public void sayHello(String name);
4 }

2、定义一个类实现这个接口

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

3、测试代码

public class TestApp {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        /*HelloService service = new HelloServiceImpl();
        service.sayHello("张三");*/

        // 使用反射机制
        HelloService service = new HelloServiceImpl();
        // 获取sayHello名称对应的Method对象
        Method method = HelloService.class.getMethod("sayHello", String.class);

        // 表达的意思就是 执行service对象的sayHello，参数是“李四”
        Object obj = method.invoke(service,"李四");

    }
}

运行结果：

小结：

第四章：动态代理的实现

动态代理的实现步骤

1、创建接口，定义目标类要完成的功能
2、创建目标类实现接口
3、创建InvocationHandler接口的实现类，在invoke方法中完成代理类的功能
4、调用目标方法，增强功能

5、使用Proxy类的静态方法，创建代理对象。并把返回值转为接口类型。

1.jdk动态代理反射包类列表

方法原型：public Object invoke(Object proxy, Method method, Object[] args)
参数：

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

1、InvocationHandler 接口：表示你的代理要干什么。
怎么用：

a.创建类实现接口InvocationHandler

b.重写invoke（）方法，把原来静态代理中代理类要完成的功能，写在这。

2、Method类：表示方法的，确切的说就是目标类中的方法。
作用：通过Method可以执行某个目标类的方法，Method.invoke();
method.invoke(目标对象，方法的参数)
Object ret = method.invoke(service2, "李四");

说明： method.invoke（）就是用来执行目标方法的，等同于静态代理中的
//向厂家发送订单，告诉厂家，我买了u盘，厂家发货
float price = factory.sell(amount); //厂家的价格。

3、Proxy类：核心的对象，创建代理对象。之前创建对象都是 new 类的构造方法()
现在我们是使用Proxy类的方法，代替new的使用。

方法：静态方法 newProxyInstance()
作用是：创建代理对象，等同于静态代理中的TaoBao taoBao = new TaoBao();

参数：
a.ClassLoader loader 类加载器，负责向内存中加载对象的。使用反射获取对象的ClassLoader
类a , a.getCalss().getClassLoader(), 目标对象的类加载器
b.Class<?>[] interfaces：接口，目标对象实现的接口，也是反射获取的。
c.InvocationHandler h : 我们自己写的，代理类要完成的功能。

3.jdk动态代理的实现

1、定义目标接口

// 目标接口
public interface UsbSell {
    float sell(int amount);
}

2、定义目标类

// 目标类
public class UsbKingFactory implements UsbSell {
    @Override
    public float sell(int amount) {
        return 85f;
    }
}

3、定义一个类实现InvocationHandler接口

// 必须实现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 {
        // 向厂家发送订单
        // float price = factory02.sell(amount);

        Object res = null;
        res = method.invoke(target,args);

         // 商家获取利润
         // price = price + 25;
        if (res != null) {
            Float price = (Float) res;
            price = price + 25;
            res = price;
        }
        System.out.println("亲，5星好评加25字长评可以获取2元现金红包");

        return res;
    }
}

4、创建代理对象完成代理

public class MainShop {
    public static void main(String[] args) {
        // 创建代理对象，使用Proxy

        // 1、创建目标对象
        UsbSell factory = new UsbKingFactory();

        // 2、创建InvocationHandler对象
        InvocationHandler handler = new MySellHandler(factory);

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

        // 4、通过代理执行方法
        float price = proxy.sell(1);
        System.out.println("通过动态代理对象，调用方法：" + price);
    }
}

运行结果

4.jdk动态代理的执行流程

第五章：动态代理在项目中的应用

1、定义一个接口，完成打印报表功能

public interface HelloService {

    // 打印报表
    int print(String name);
}

2、定义一个类，实现了这个功能（这个类是别人写好的，你无权改动）

public class GoNeng implements HelloService {
    @Override
    public int print(String name) {
        System.out.println("其他人写好的功能方法");
        return 2;
    }
}

3、现在，你想用这个类，但是这个类的功能不能够满足你的需求。你不能改动原先的代码

这个时候，那就可以使用动态代理来增强程序的功能。

例如：把返回的结果乘以2

public class MyInvocationHandler implements InvocationHandler {

    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

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

        // 调用目标方法，执行print得到2
        Object obj = method.invoke(target,args);

        // 功能增强（乘2）
        if (obj != null) {
            Integer num = (Integer) obj;
            num = num * 2;
            obj = num;
        }
        return obj;
    }
}

4、这个时候你就可以调用你写的增强的方法

public class MyApp {
    public static void main(String[] args) {

        /*GoNeng goNeng = new GoNeng();
        int num = goNeng.print("销售");
        System.out.println("num="+num);*/

        GoNeng goNeng = new GoNeng();
        InvocationHandler handler = new MyInvocationHandler(goNeng);

        HelloService proxy = (HelloService) Proxy.newProxyInstance(goNeng.getClass().getClassLoader(),
                goNeng.getClass().getInterfaces(),
                handler);
        int nums = proxy.print("销售");
        System.out.println("我们期望的nums=" + nums);
    }
}

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

posted @ 2021-05-09 13:15 小霖同学阅读(93) 评论(0) 收藏举报

刷新页面返回顶部

小zhou同学

愿所有自命不凡的人：既有诗与远方，也能在孤独前行的路上勇往直前。

动态代理

第一章：代理模式

1.什么是代理

2.代理的特点

3.为什么要找代理（中介）

4.使用代理模式的作用

5.实现代理的方式

第二章：静态代理

1.静态代理实现步骤

2.静态代理接口和目标类的创建

4.定义测试类

5.静态代理的优缺点

第三章：动态代理

1.什么是动态代理

2.动态代理的分类

3.回顾Method

第四章：动态代理的实现

动态代理的实现步骤

1.jdk动态代理反射包类列表

3.jdk动态代理的实现

4.jdk动态代理的执行流程

第五章：动态代理在项目中的应用

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

公告

小zhou同学

愿所有自命不凡的人：既有诗与远方，也能在孤独前行的路上勇往直前。

动态代理

第一章：代理模式

1.什么是代理

2.代理的特点

3.为什么要找代理（中介）

4.使用代理模式的作用

5.实现代理的方式

第二章：静态代理

1.静态代理实现步骤

2.静态代理接口和目标类的创建

4.定义测试类

5.静态代理的优缺点

第三章：动态代理

1.什么是动态代理

2.动态代理的分类

3.回顾Method

第四章：动态代理的实现

动态代理的实现步骤

1.jdk动态代理反射包类列表

3.jdk动态代理的实现

4.jdk动态代理的执行流程

第五章：动态代理在项目中的应用

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

公告

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