关于代理的一些知识

最新推荐文章于 2023-05-26 15:25:26 发布

抓娃男孩

最新推荐文章于 2023-05-26 15:25:26 发布

阅读量196

点赞数

分类专栏：静态和动态代理文章标签：代理模式 java

本文链接：https://blog.csdn.net/weixin_46055944/article/details/124948141

版权

静态和动态代理专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

代理模式
动态代理原理实现
动态代理案例
动态代理步骤流程
多个方法如何分别增强
总结
加餐：说说Cglib动态代理

代理模式

（1）概念

代理就是帮别人做事情，如：工厂的中介，中介负责为工厂招收工人，那么中介就是工厂的代理；客户通过商家购买东西，商家向厂家购买货物，商家就是工厂的代理
在开发中存在a类需要调用c类的方法，完成某一个功能，但是c禁止a调用。这时，可以在a和c之间创建一个b类代理，a类访问b类，b类访问c类。例如：登录的时候需要进行短信验证，这个时候代理就是中国移动的子公司来完成短信的发送功能
代理模式就是为其他对象提供一种代理来控制这个对象的访问，在某些情况下一个对象不适合或不能直接引用另一个对象，而代理对象可以在客户类和目标对象直接起到中介的作用

（2）举例

如果设计一个类该类中含有加减乘除四个方法，现在需要给每一个方法添加测试方法执行时间的代码，如果不使用代理的话，就需要对每一个方法进行修改，需要修改多次。违背了开闭原则（OCP，对扩展开放，修改关闭）和单一职责（SRP）

（3）作用

功能增强：在原有的功能上增加额外的功能
控制访问：代理类不让你访问目标类

（4）实现代理的方式

①静态代理

代理类是自己手动创建的，所需要代理的目标类是确定的，实现简单容易理解

静态代理：
概念：1)代理类是自己手工实现的,自己创建一个java类,表示代理类
2)同时你所要代理的目标
优点：1）实现简单 2）容易理解。
静态代理缺点：如果有多个类需要代理，那么就需要创建多个代理类分别代理目标对象，工作量较大，不利于维护。（例如：下面例子中创建了一个厂家类，那么该类只能代表一个厂家，当建立了其它品牌的厂家后，还需要为该厂家创建代理类）当接口的方法增加或修改的时候，很多类都需要修改。因为，目标类和代理类都实现了相同的接口。
实例：模拟一个用户购买u盘的行为。
用户是客户端类
商家：代理，代理某个品牌的u盘。
厂家：目标类。
三者的关系：用户（客户端）-—-商家（代理）-—-厂家（目标）
商家和厂家都是卖u盘的，他们完成的功能是一致的，都是卖u盘
实现步骤：
1.创建一个接口,定义卖u盘的方法,表示你的厂家和商家做的事情
2.创建厂家类,实现1步骤的接口
3.创建商家,就是代理,也需要实现1步骤中的接口
4.创建客户端类,调用商家的方法买一个u盘

实现步骤：
1.创建一个接口,定义卖u盘的方法,表示你的厂家和商家做的事情

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

2.创建厂家类,实现1步骤的接口

package com.rango.factory;
import com.rango.service.usbSell;
//目标类:金士顿厂家,不接受用户的单独购买
public class UsbKingFactory implements usbSell {
    /**
     * 定义一个方法 参数 amount:表示一次购买的数量,暂时不用
     * 返回值表示一个u盘的价格
     *
     * @param amount
     * @return
     */
    @Override
//一个128G的U盘是85元.
//    后期根据amount,可以实现不同的价格,例如10000个,单击是80,50000个75
    public float sell(int amount) {
        return 85.0f*amount;
    }
}

3.创建商家,就是代理,也需要实现1步骤中的接口

import com.rango.factory.UsbKingFactory;
import com.rango.service.usbSell;
//淘宝是一个商家,代理金士顿U盘的销售
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;
    }
}

4.创建客户端类,调用商家的方法买一个u盘

import com.rango.business.TaoBao;
public class shopMain {
    public static void main(String[] args){
//             创建代理的商家淘宝对象
        TaoBao taoBao = new TaoBao();
//        我只向淘宝买一件产品,得到报价
        float price = taoBao.sell(2);
        System.out.println("购买一件产品.淘宝的报价为: "+price);
    }
}

②动态代理

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

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

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

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

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

2）动态代理能做什么？
可以在不改变原来目标方法功能的前提下，可以在代理中增强自己的功能代码。
在实际项目中的应用：
比如:你所在的项目,有一个功能是其他人(公司其他部门,其他小组的人)写好的,你可以使用
//比如,同事开发一个GoNong类 GoNong.class , GoNong gn=new GoNong() //我们需要增加一个print方法
我们发现这个功能现在还存在缺点,不能完全满足我项目的需要,我需要在print()执行过后,需要自己再增加代码,使用什么方法那,肯定是代理,因为别人不会让我们看源文件。我们无法在源文件上进行修改

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

动态代理的实现:

jdk动态代理(理解):使用java反射包中的类和接口实现动态代理的功能。反射包java.lang.reflect,里面有三个类:InvocationHandler、Method、Proxy
cglib（code generation library）动态代理(了解): cglib是第三方的工具库,创建代理对象
cglib的原理是继承，cglib通过继承目标类，创建它的子类，在子类中
重写父类中同名的方法，实现功能的修改。
因为cglib是继承，重写方法，所以要求目标类不能是final的，方法也不能是final的。cglib的要求目标类比较宽松，只要能继承就可以了。cglib在很多的框架中使用，比如mybatis，spring框架中都有使用。
需要导入jar包：核心包和依赖包（spring_core.jar已经集成了这两个包，因此，导入此包即可）子类是在调用的时候才生成的。使用目标对象的子类的方式实现的代理，它是在内存中构建一个子类对象从而实现对目标对象功能的扩展，能够在运行时动态生成字节码，可以解决目标对象没有实现接口的问题

入门案例

接口类

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对象
invoke 是method类中的方法：invoke(对象, 方法执行的参数值);返回值是一个object，invoke需要抛出异常

具体意思是执行method对象类的方法，具体设置该方法的参数

public class TestApp {
    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);
/**
    invoke是Method类中的一个方法，表示执行方法的调用
    参数1：Object ：表示对象，要执行这个对象的方法
    参数2：Object ... args：方法执行时传入的参数
   invoke方法的返回值是个Object对象

*/
//通过Method可以执行sayHello方法调用
Object ret = method.invoke(target, "李四");
//表达的意思就是 执行target对象sayHello,参数是李四
	}
}

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

HelloService service2 = new HelloServiceImpl2();
// 执行service2对象method（sayHello）方法，参数是“李四”
Object ret = method.invoke(service2, "李四");

动态代理原理实现

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

InvocationHandler （调用处理器）就一个方法invoke（），表示代理对象要执行的代理类方法。也就是中介类，调用目标方法以及增强其功能。我们自己的代理类要完成的功能就写在invoke方法中

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

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

InvocationHandler 接口：表示你的代理要干什么
具体如何调用该方法（怎么用）：

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

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

通过Method可以执行目标类中的方法，Method.invoke() 就是用来执行目标方法的
该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)
参数说明:

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

具体实现动态代理的步骤为：

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

动态代理案例

接口类

//目标接口
public interface UsbSell {

    float sell(int amount);

    void print();
}

改下接口的实现类（目标类）

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

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

    @Override
    public void print() {

    }
}

创建InvocationHandler接口的实现类

//必须实现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;
    }
}

具体的测试类
- 先创建代理对象，使用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);
    }
}

动态代理步骤流程

动态代理的执行步骤

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

具体代码执行的步骤是

通过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的参数给执行代理的方法

动态代理模板

创建目标对象接口类接口对象 =new 接口实现类();
创建InvocationHandler对象InvocationHandler handler = new MySellHandler(接口类对象);
创建代理对象接口类 proxy = (接口类) Proxy.newProxyInstance(factory.getClass().getClassLoader(), factory.getClass().getInterfaces(),handler);
通过代理执行方法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);

多个方法如何分别增强

以下是InvocationHandler接口的实现类，多个方法的增强思路是在invoke里面做分别判断


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); //执行目标方法

          String name = method.getName();
          if (name.equals( "buy")){
                       //buy方法做增强      
    //price = price + 25; //增强功能，代理类在完成目标类方法调用后，增强了功能。
            if( res != null ){
                Float price = (Float)res;
                price = price + 25;
                res = price;
                }
             //这里如果需要返回的话，也可以直接return
              return  返回值;
          }
         if (name.equals( "print")){
           //print方法做增强   
               //这里如果需要返回的话，也可以直接return
              return  返回值;
          }                 
        //返回结果
        return res;
    }
}

总结

通俗一点来说，动态代理中的代理类不需要用new来创建，而静态代理中的代理类需要用new来创建。这应该是代码上最直观的区别。并且静态代理中需要有多个代理类，而动态代理中是一个万能的代理类，可以代理一切商家。此外，jdk动态代理必须要有接口，如果要代理是一个类，那么jdk动态代理就用不了了，此时可以用cglib代理

加餐：说说Cglib动态代理

什么是CGLib

CGLIB是一个强大的、高性能的代码生成代码库。其被广泛应用于AOP框架（Spring、dynaop）中，用以提供方法拦截操作。Hibernate作为一个比较受欢迎的ORM框架，同样使用CGLIB来代理单端（多对一和一对一）关联（延迟提取集合使用的另一种机制）。CGLIB作为一个开源项目，其代码托管在github，地址为：https://github.com/cglib/cglib

CGLib动态代理的优势

CGLIB动态代理相比于JDK动态代理更加强大，JDK动态代理虽然简单易用，但是其有一个致命缺陷是，只能对接口进行代理。如果要代理的类为一个普通类、没有接口，那么Java动态代理就没法使用了。

步骤

添加cgliib依赖
创建增强器Enhancer类对象
调用Enhancer类对象的setSuperclass(Class cls)方法设置需要增强类的对象，参数为需要增强的类。
调用Enhancer类对象的回调方法enhancer.setCallback(MethodInterceptor interceptor)，与jdk动态代理一样，有两种方法。
获取增强之后的代理对象

示例

cgliib依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
</dependency>

这是我需要增强的类，为了与jdk动态代理区别开来,是一个没有实现接口的类

package spring5;

public class Book {
    public int add(int a, int b) {
        return a+b;
    }
}

测试代码

    @Test
    public void testCGLib(){
        //创建增强器Enhancer类对象
        Enhancer enhancer = new Enhancer();

        //设置需要增强类的对象
        enhancer.setSuperclass(Book.class);

        //调用回调方法，这里使用的是匿名内部类的方法
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                Object res = (Integer)methodProxy.invokeSuper(o,objects)+100;
                return res;
            }
        });
        
        //获取增强后的类对象
        Book book = (Book) enhancer.create();
        
        //调用方法
        System.out.println(book.add(1,2));
    }

抓娃男孩

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
关于代理的一些知识

文章目录代理模式（1）概念（2）举例（3）作用（4）实现代理的方式①静态代理②动态代理入门案例动态代理原理实现动态代理案例动态代理步骤流程多个方法如何分别增强总结加餐：说说Cglib动态代理什么是CGLibCGLib动态代理的优势步骤示例代理模式（1）概念代理就是帮别人做事情，如：工厂的中介，中介负责为工厂招收工人，那么中介就是工厂的代理；客户通过商家购买东西，商家向厂家购买货物，商家就是工厂的代理在开发中存在a类需要调用c类的方法，完成某一个功能，但是c禁止a调用。这时，可以在a和c之间创建一个
复制链接

扫一扫