JDK动态代理模式这篇就够了

关注

原创 2022-03-24 20:26:18 486 阅读 AI 写同款· GEO 优化 ›

代理模式（静态代理、JDK 动态代理、CGLIB 动态代理）房屋中介代理：客户手里没有房源信息，找一个中介商品代购：这些代购者可以去哪到比较低成本的商品，拥有自己的渠道代理模式（Proxy Pattern）：是 23 中设计模式中的一种，属于结构型的模式。指一个对象本身不做实际的操作，而是通过其他对象来得到自己想要得到的结果。**意义：**目标对象只需要关心自己的实现细节，通过代理对象来实现功能的增强，可以扩展目标对象的功能。体现了非常重要的编程思想：不能随便修改源码，通过修改代理的方式来实现功能的扩展。阅读详情

JDK动态代理

第一章代理的介绍

介绍:我们需要掌握的程度

动态代理(理解) 基于反射机制

掌握的程度:

1.什么是动态代理?

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

1.1 什么是代理

代理,在我们日常生活之中就有体现,代购,中介,换ip,商家等等.
比如有一家美国的大学,可以对全世界招生.留学中介(代理 )
留学中介(代理):帮助这家美国的学校招生,中介是学校的代理中介是代替学校完成招生功能
代理特点
1. 中介和代理他们要做的事情是一致的:招生
2. 中介是学校代理,学校是目标
3. 家长-------->中介(学校介绍,办理入学手续)---------->美国学校
4. 中介是代理，不能白干活，需要收取费用
5. 代理不让你访问到目标

1.2 为什么要找中介

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

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

1.3 代理在开发中的应用

1.你有a类，本来是调用c类的方法，完成某个功能。但是c不让a调用。

a——不能调用c的方法

在a和c直接创建一个b代理，c让b访问

a——访问b——访问c

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d5t7z5Hp-1648124617810)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220324103732980.png)]

2.实际例子：登录，注册有验证码，验证码是手机短信

中国移动、联通能发短信

中国移动联通有子公司或者关联公司，他们面向社会提供短信的发送功能

3.张三项目发送短信——子公司或者关联公司——中国移动、联通

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tMAmvfki-1648124617811)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220324103923767.png)]

第二章静态代理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2P1WTaWK-1648124617811)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220324104224384.png)]

2.1 实现静态代理的方式

2.1.1 静态代理

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

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

特点：1.实现简单

2.容易理解

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

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

2.1.2 实现步骤

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

2.3 具体实现

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-omhUDZHI-1648124617812)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220324111535407.png)]

1.创建一个接口，定义卖u盘的方法,表示厂家和商家做的事情

package com.gz.service;

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

2.创建厂家类，实现1的接口

package com.gz.factory;

import com.gz.service.UsbSell;

//目标类:金士顿厂家,不接受用户的单独购买
public class UsbKinFactory implements UsbSell {

    @Override
    public float sell(int count) {
        //一个128G的U盘是85元.
        //后期根据amount,可以实现不同的价格,例如10000个,单价是80,50000个75
        return 85.0f;
    }
}

3.创建商家（代理），也需要实现1接口

package com.gz.shangjia;

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

4.创建客户类，调用商家的方法买U盘

package com.gz;

import com.gz.shangjia.TaoBaoKin;
import com.gz.shangjia.WeiShang;

public class Main {

    public static void main(String[] args) {
   // write your code here
        //             创建代理的商家淘宝对象
        TaoBaoKin taoBaoKin = new TaoBaoKin();
        //        我只向淘宝买一件产品,得到报价
        float money = taoBaoKin.sell(1);
        System.out.println("淘宝买一个金士顿U盘价格："+money);

        WeiShang weiShang = new WeiShang();
        float sell = weiShang.sell(1);
        System.out.println("微商买一个金士顿U盘价格："+sell);

    }
}

2.4 使用代理的作用

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

2.5静态代理的优缺点

优点:
1. 实现简单
2. 容易简单
缺点:当你的项目中,目标类的代理类很多的时候,有一下的缺点
1. 当目标类增加了,代理类可能也需要成倍的增加
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BUP9M6lk-1648124617813)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220324112348643.png)]
2. 当你的接口中功能在增加了,或者修改了,会影响众多的实现类,厂家类,代理都需要修改,影响比较多.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E2Zpdibs-1648124617814)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220324112253369.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vO8F9rVw-1648124617816)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220324112423290.png)]

第三章动态代理

2.1 静态和动态模式的对比

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

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

动态代理的特点：
1. 动态代理中目标类即使很多，代理类数量可以很少
2. 当你修改了接口中的方法时,不会影响代理类。
动态代理的作用：

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

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

2.2 动态代理的介绍

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yKQcbMDD-1648124617817)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220324184245436.png)]

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

动态代理的实现:

jdk动态代理(理解):使用java反射包中的类和接口实现动态代理的功能,反射包java.lang.reflect,里面有三个类:InvocationHandler,Method,Proxy
cglib动态代理(了解): cglib是第三方的工具库,创建代理对象
cglib的原理是继承，cglib通过继承目标类，创建它的子类，在子类中重写父类中同名的方法，实现功能的修改。
因为cglib是继承，重写方法，所以要求目标类不能是fina1的，方法也不能是final的。cglib的要求目标类比较宽松，只要能继承就可以了。cglib在很多的框架中使用，比如mybatis，spring框架中都有使用。

2.3 JDK动态代理

jdk动态代理:
1.反射, Method类,表示方法。类中的方法。通过Method可以执行某个方法

2.jdk动态代理的实现
反射包java.lang. reflect,里面有三个类：InvocationHandler，Method，Proxy

2.3.1 Interface InvocationHandler

public interface InvocationHandler

InvocationHandler是由代理实例的调用处理程序实现的接口。
每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。

1）InvocationHandler接口(调用处理器)：就一个方法 invoke()
 invoke():表示代理对象要执行的功能代码。你的代理类要完成的功能就写在invoke()方法中。

代理类完成的功能
1. 调用目标方法,执行目标方法的功能
2. 功能增强,在目标方法调用时,增加功能

方法原型:

参数：object proxy：jdk创建的代理对象，无需赋值。
                Method method:目标类中的方法，jdk提供method对象的
                object[]args:目标类中方法的参数，jdk提供的。
Object invoke(Object proxy,方法 method,Object[] args)throws 
    
    Throwable处理代理实例上的方法调用并返回结果。

2.3.2 Method类

2）Method类:表示方法的,确切的说就是目标类中的方法。
作用:通过 Method可以执行某个目标类的方法, method. invoke(目标对象,方法的参数);

object ret= method. invoke(service22,"李四")

说明:method.invoke()就是为了用来执行目标方法的,等同于静态代理中的

   //        向厂家发送订单,告诉厂家,我买了U盘,厂家发货
    //        发送给工厂,我需要的订单,返回报价
            float price = factory.sell(amount);

2.3.3 Proxy类

3）proxy类：核心的对象，创建代理对象。之前创建对象都是new类的构造方法()
现在我们是使用proxy类的方法，代替new的使用。
方法：静态方法 newProxyInstance();
作用：创建代理对象，等同于静态代理中的TaoBao taoBao=new TaoBao()

我们来观察方法原型

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

参数含义:

ClassLoader loader 类加载器,负责向内存中加载对象的,使用反射机制获取对象的ClassLoader,如何获取? 类 a, a.getCalss().getClassLoader(),目标对象的类加载器。

这里我们细分:每一个类都继承Object类,在Object中有一个getClass方法,表示类对象的运行时类的Class对象。而Class类里面有一个public ClassLoader getClassLoader()方法
Class<?>[] interfaces: 接口,目标对象实现的接口,也是反射获取的
InvocationHandler h : 我们自己写的,代理类要完成的功能

返回值：也就是代理对象

第四章实现动态代理步骤

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

第一步：创建接口,定义目标所需功能

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

第二步：创建目标类实现接口

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

我们写了接口类,定义了功能,写了代理类,实现了接口功能,按照以前的操作,现在就需要写一个真正的代理类,创建对象.

第三步：创建Invocationhandler实现类

1.调用目标的方法

2.增强功能

public class MyHandle implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return null;
    }
}

我们就在以前代理类的实现方法上进行修改

//之前的代理类
  public class TaoBao 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 MyHandle(Object target) {
        this.target = target;
    }
invoke里面的设置
                Object res =null;
            //        向厂家发送订单,告诉厂家,我买了U盘,厂家发货
            //        发送给工厂,我需要的订单,返回报价
//            float price = factory.sell(amount);
            res = method.invoke(target,args);       //待执行目标方法,执行后返回值

第四步：创建代理对象,并把返回值转换成接口类型

public class MainShop {
    public static void main(String[] args){ 
//            1.创建对象,使用Proxy
//            2.创建目标对象
        UsbSell factory = new UsbKingFactory();
//        3.创建Invocationhandler对象
        InvocationHandler myHandle = new MyHandle(factory);

//        4.创建代理对象
        UsbSell proxy = (UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(),
                factory.getClass().getInterfaces(),
                myHandle);
//        通过代理执行方法
        float price = proxy.sell(1);
        System.out.println("通过动态代理对象,调用方法:" +price);
    }
}

执行成功.和之前动态代理模式一样

第五章动态代理的执行流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NaxR9YCD-1648124617818)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220324192011783.png)]

5.1 执行流程

当执行poxy.sell(1)时候调用的是哪里呢？是执行我们的proxy在创建时，指定的这个handler他里面的invoke()方法。(handler里面的invoke()方法的形参)此时sell()会赋给method，参数1会赋给args

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0HfCKxBt-1648124617819)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220324193917141.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P9BqH7C3-1648124617819)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220324201643212.png)]
然后就到了invoke()方法里面，之后到了method.invoke(target,args)，这里所执行的是目标类的方法，谁把target传给了invoke就执行谁的方法。这里我们传的是目标类，因此他会去调用目标类中的方法，目标类方法执行完成之后会有一个返回值，返回给调用目标类的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mWR7mUHx-1648124617820)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220324201421415.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f9RzUga5-1648124617821)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220324201852500.png)]
然后hadler里面的invoke方法结束之后，会返回一个值给客户端的proxy.sell()方法

5.2 动态代理模板

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

第六章项目中的应用

我们需要知道代理能做什么?

在不改变原来目标方法功能的前提下,可以在代理中增强自己的功能代码,程序开发中的意思,

比如:你所在的项目,有一个功能是其他人(公司其他部门,其他小组的人)写好的,你可以使用

//比如,同事开发一个GoNong类
GoNong.class ,
GoNong gn=new GoNong()
    //我们需要增加一个print方法

我们发现这个功能现在还存在缺点,不能完全满足我项目的需要,我需要在print()执行过后,需要自己再增加代理,使用什么方法那,肯定是代理,因为别人不会让我们看源文件

执行步骤:

1.我们先建立一个接口功能,很简单的一个功能

public interface HelloService {
    /**
     * 打印报表,报表
     * @param name
     * @return
     */
    int print (String name);
}

2.我们再加个接口实现类

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

3.我们如果相对上述功能进行修改,我们不可能直接去在原方法上进行修改

我们设置一个类来使用这个接口

public class MyApp {
    public static void main(String[] args){
        GoNeng gn = new GoNeng();
        int i = gn.print("nihao1");
        System.out.println("num" +i);

    }
}

问题是如果我们想修改这个功能改怎么办?在不修改源代码的基础上,我们可以创建一个代理类,来增强这个类方法,

3.设置一个代理类实现功能的增强和代理

public class MyInvocationHandler implements InvocationHandler {
    private Object target=null;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//        调用目标方法,执行print()得到2
     Object res  =  method.invoke(target,args);  //返回为2的结果
        //我们可以把结果再乘以2
        if (res!=null)
        {
            Integer num  = (Integer) res;
            res = num*2; 
        }

            return null;
    }
}

5.我们仍回到主方法里面进行测试

public class MyApp {
    public static void main(String[] args){
//        GoNeng gn = new GoNeng();
//        int i = gn.print("nihao1");
//        System.out.println("num" +i);
        GoNeng goNeng = new GoNeng();
        InvocationHandler handler = new MyInvocationHandler(goNeng);
        HelloService proxy = (HelloService) Proxy.newProxyInstance(goNeng.getClass().getClassLoader(), goNeng.getClass().getInterfaces(),
                handler);
        int num = proxy.print("市场");
        System.out.println("我们期望得到的 num =="+num);
    }
}

测试System.out.println("动态代理类参数接口"+goNeng.getClass().getInterfaces()[0].getName());

动态代理类参数接口com.rango.service.HelloService
其他人写好的这个方法!
我们期望得到的 num ==4

完结

动态代理,必须要有接口出现,如果没有,我们可以使用cglib实现

收录于

后端框架

标签

#代理模式

GAN网络（论文阅读）：Generative Adversarial Nets 当判别器效果比较好时，D(G(z))值为0，则log(1-D(G(z)))值为0，当判别器效果不好，会输出一个大于0 的数，则log(1-D(G(z)))值就为一个负数，在极端情况下，会得到负无穷大，此时判别失误。在价值函数的第二项中存在问题，在早期G比较弱的时，生成的数据和真实数据相差很大，D就容易训练的比较好，很容易区分，就会导致log(1-D(G(z)))变成0 ，这样很难求梯度来优化G，所以更新G时，将优化函数改为log(D(G(z)))。最终使G赢，即G生成的数据D判别不出来。阅读详情