代理相关的知识集

目录

说到代理我们要先知道代理的分类

代理大方向分为两类:

Ⅰ静态代理

Ⅱ动态代理

        jdk动态代理

        cglib动态代理

下面我们来看看各种代理之间的区别和实现方式吧

        

静态代理            

静态代理的实现方法:

静态代理的实际应用:

动态代理

        JDK动态代理

                 实现原理:

说到代理我们要先知道代理的分类

        代理大方向分为两类:

                Ⅰ静态代理

                Ⅱ动态代理

                        jdk动态代理
                        cglib动态代理

下面我们来看看各种代理之间的区别和实现方式吧

 

        

            

静态代理            

静态代理是一种代理模式,它通过手动编写代理类的代码,将被代理对象的方法调用委托给代理类,从而实现对被代理对象的控制。静态代理的实现方法包括两个关键角色:代理类和被代理类。

静态代理的实现方法:

  1. 定义接口: 定义一个接口,包含被代理对象和代理对象都需要实现的方法。

    public interface Subject { 
        void request(); 
    }

  2. 实现被代理类: 被代理类实现接口,提供具体的业务逻辑。

    public class RealSubject implements Subject { 
        @Override 
        public void request(){ 
        System.out.println("RealSubject: Handling request."); 
        } 
    }
  3. 实现代理类: 代理类也实现接口,并在其中包含一个对被代理对象的引用,代理类中的方法实际上是对被代理对象方法的调用,可以在调用前后添加额外的逻辑。

    public class ProxySubject implements Subject {
        private RealSubject realSubject;
    
        public ProxySubject(RealSubject realSubject) {
            this.realSubject = realSubject;
        }
    
        @Override
        public void request() {
            System.out.println("ProxySubject: Before request.");
            realSubject.request();
            System.out.println("ProxySubject: After request.");
        }
    }

  4. 使用代理: 在客户端代码中使用代理对象。

    public class Client {
        public static void main(String[] args) {
            RealSubject realSubject = new RealSubject();
            ProxySubject proxy = new ProxySubject(realSubject);
            proxy.request();
        }
    }

静态代理的实际应用:

  • 安全检查: 在调用被代理对象的方法前进行权限或安全检查。
  • 日志记录: 在方法调用前后记录日志信息。
  • 性能监控: 统计方法的执行时间等性能指标。

动态代理

        JDK动态代理

                 实现原理:

                        使用 java.lang.reflect.Proxy 类和 java.lang.reflect.接口。

                        在运行时动态生成一个实现被代理接口的代理类。

                        通过 InvocationHandler 接口的 invoke 方法进行方法的调用处理。

                适用场景:

                        被代理类必须实现接口。

                        适用于横切关注点与业务逻辑之间耦合较弱的情况。

                实现方法:

        1.定义一个被代理类



/**
 * @author tong
 */
public class Calculator {

    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        return result;
    }

    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        return result;
    }

    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        return result;
    }

    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
}

       2.生产代理对象的工厂类 ProxyFactory:

/**
 * 动态代理有两种:
 * 1. jdk动态代理,要求必须有接口,最终生成的代理类和目标类实现相同的接口,在com.sun.proxy包下,类名为$proxy+数字 (例如:$proxy6)
 * 2. cglib动态代理,最终生成的代理类会继承目标类,并且和目标类在相同的包下
 */
public class ProxyFactory {
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }
    // 通过该方法可以生成任意目标类所对应的代理类
    public Object getProxy(){
        /**
         * newProxyInstance():创建一个代理实例
         * 其中有三个参数:
         * 1、classLoader:指定加载动态生成的代理类的类加载器(注:所有引入的第三方类库以及
        自己编写的java类 都是由 应用类加载器 负责加载的)
         【根类加载器(Bootstrap)> 扩展类加载器(Extension)> 系统类加载器(System)
         系统类加载器又称为应用类加载器】
         * 2、interfaces:获取目标对象实现的所有接口的class对象所组成的数组
         * 3、invocationHandler:设置代理对象实现目标对象的接口的方法的过程,即代理类中如何
        重写接口中的抽象方法
         */
        //第一个参数,获取代理对象的类加载器 (类加载器是程序中默认的类加载器,一般来说,Java
        应用的类都是由它来完成加载。所以,此处通过代理类或者被代理类获取到的类加载器都是同一个,
        或通过任何一个类获取到的类加载器都是同一个。)
        ClassLoader classLoader = this.getClass().getClassLoader();
        //第二个参数,被代理对象实现的所有接口数组
        Class[] interfaces = target.getClass().getInterfaces();
        //当通过代理类的对象发起对被重写的方法的调用时,都会转换为对如下的invoke方法的调用
        //代理实例的调用处理程序
        //第三个参数InvocationHandler的实现类,这里用了匿名内部类的方式
        InvocationHandler invocationHandler = new InvocationHandler() {
             //重写InvocationHandler的invoke方法,他有三个参数可以供我们使用
            @Override
            public Object invoke(Object proxy, Method method, Object[] args){
                /**
                 * proxy:表示代理对象
                 * method:表示要执行的方法(代理对象需要实现的抽象方法,即其中需要重写的和
        目标类同名的方法)
                 * args:表示要执行的方法的参数列表(method所对应方法的参数列表)
                 */
                Object result = null;
                try {
                    //method.getName(): 返回此method对象表示的方法的名称,作为字符串
                    System.out.println("[动态代理][日志] "+method.getName()+",参数:"+                     Arrays.toString(args));
                     //通过反射调用method对象所表示的方法,并获取该方法的返回值
                     //在具有指定参数的指定对象上调用此method对象表示的底层方法。
                     //此处就是通过target来确定调用的是具体哪个类中的方法
                     result = method.invoke(target, args);
                     System.out.println("[动态代理][日志] "+method.getName()+",结 果:"+ result);
                  } catch (Exception e) {
                   e.printStackTrace();
                   System.out.println("[动态代理][日志] "+method.getName()+",异常:"+e.getMessage());
                  } finally {
                      System.out.println("[动态代理][日志] "+method.getName()+",方法执行完毕");
                  }
                  return result;
               }   
            }; 
        //返回指定接口的代理类的实例,该实例将方法调用分派给指定的调用处理程序。
        return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
      }
}                                     

3.测试类ProxyTest

package com.tong.proxy;

import com.tong.spring.calculator.Calculator;
import com.tong.spring.calculator.proxy.ProxyFactory;
import org.junit.Test;

/**
 * @author tong
 */
public class ProxyTest {
    @Test
    public void testDynamicProxy(){
        ProxyFactory factory = new ProxyFactory(new Calculator());
        Calculator proxy = factory.getProxy();
        /*创建好了代理对象,代理对象就可以执行被代理类实现的接口的方法;当通过代理类的对象
        发起对被重写的方法的调用时,都会转换为对调用处理器实现类中的invoke方法的调用,
        invoke方法中就可以对被代理类进行功能增强.*/
        proxy.add(1, 5);
//        proxy.div(1,0);
    }
}

CGLIB动态代理

        实现原理

                使用第三方库,通过修改字节码生成目标类的子类。 
                在子类中对方法进行增强
                由于生成的是类的子类,因此可以代理没有实现接口的类。

        适用场景

                被代理类不需要实现接口。
                适用于横切关注点与业务逻辑之间耦合较紧密的情况。

        实现方式

        1.创建被代理类

package com.tong;

/**
 * @author tong
 * @Description:被代理类
 */
public class Star {
    public void sing() {
        System.out.println("唱.......");
    }

    public void dance() {
        System.out.println("跳......");
    }
}

2.生成代理工厂

package com.tong;

import com.oracle.jrockit.jfr.Producer;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * @author tong
 * @Description:生成代理类的工厂
 */
public class ProxyFactory {
    private Object target;

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

    // 通过该方法可以生成任意目标类所对应的代理类
    public static Object getProxy(Object target) {
        // proxy就是我们创建的代理对象,这个对象可以执行被代理类中所有的方法,并且我们可以
        在代理对象中对被代理类的方法进行增强
        Object proxy = Enhancer.create(target.getClass(), new MethodInterceptor() {
            /**
             * 这一步是整个过程的关键,代理类的实现要通过Enhancer类,我们需要通过Enhancer
        类中的create方法创建一个代理对象
             * @param o 是一个代理对象的引用 (即:增强对象)
             * @param method 是当前执行,即被拦截的被代理类方法
             * @param objects 是当前执行方法所用的参数,索引顺序即为方法定义时参数的顺序
             * @param methodProxy 指的是当前执行的方法的代理对象
             * @return 通过反射调用method对象所表示的方法, 并获取该方法的返回值
             */
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) {
                Object result = null;
                try {
                    // 提供增强代码
                    System.out.println("[cglib动态代理][日志] " + method.getName() +"
        ,参数:" + Arrays.toString(objects));
                    //通过反射调用method对象所表示的方法,并获取该方法的返回值
                    //在具有指定参数的指定对象上调用此method对象表示的底层方法。
                    //此处就是通过target来确定调用的是具体哪个类中的方法
                    result = method.invoke(target, objects);
                    System.out.println("[cglib动态代理][日志] " + method.getName() + ",
        结果
        :" + result);
                } catch (Exception e) {
                    e.printStackTrace();
                    System.out.println("[cglib动态代理][日志] " + method.getName() + ",
        异常:
        " + e.getMessage());
                } finally {
                    System.out.println("[cglib动态代理][日志] " + method.getName() + ",
        方法执行完毕");
                }
                return result;
            }
        });
        // 返回代理对象
        return proxy;
    }
}

3.生成测试类

package com.tong;

import org.junit.Test;

/**
 * @author tong
 * @Description:测试类
 */
public class ProxyTest {

    @Test
    public void test(){
        Star star = new Star();
        /* proxy就是我们创建的代理对象,这个对象可以执行被代理类中所有的方法,
        并且我们可以在代理对象中对被代理类的方法进行增强,
        注意这里使用了强转,因为getProxy方法的返回值是Object类型的对象*/
        Star proxy = (Star)ProxyFactory.getProxy(star);
        proxy.sing();
        System.out.println("-----------------分割线------------------");
        proxy.dance();
        System.out.println("-----------------分割线------------------");
        
    }
}

4.运行结果

代理相关的知识集_第1张图片

JDK动态代理和CGLIB动态代理的区别

实现原理:

①JDK 动态代理是基于接口的代理,生成的代理类实现了被代理接口。
②CGLIB 动态代理是通过生成目标类的子类,代理类继承了被代理类。

适用场景:

①JDK 动态代理适用于被代理类实现了接口的情况。
②CGLIB 动态代理适用于被代理类没有实现接口的情况。

性能:

①JDK 动态代理的性能较好,因为它是基于接口的代理,直接使用 java.lang.reflect 包中的方法。
②CGLIB 动态代理生成的字节码较大,可能在性能上略逊于 JDK 动态代理,但在某些场景下性能差异并不明显。

使用方式:

①JDK 动态代理需要实现 InvocationHandler 接口,并使用 Proxy.newProxyInstance 方法创建代理对象。
②CGLIB 动态代理直接使用第三方库,不需要实现接口,通过 Enhancer.create 方法创建代理对象。

总体来说,选择使用 JDK 动态代理还是 CGLIB 动态代理取决于具体的业务场景和需求。如果被代理类已经实现接口,推荐使用 JDK 动态代理;如果被代理类没有实现接口或者想要在运行时对类进行增强,可以考虑使用 CGLIB 动态代理。

静态代理和动态代理的区别

实现方式:

①静态代理: 手动编写代理类的代码。
②动态代理: 在运行时生成代理类的字节码,无需手动编写代理类。

灵活性:

①静态代理: 代理类在编译时就确定,不够灵活。
②动态代理: 代理类在运行时生成,可以根据需要动态地创建代理类。

维护成本:

①静态代理: 每添加一个被代理类,都需要手动编写一个对应的代理类。
②动态代理: 通过动态生成代理类,可以更容易地维护和扩展。

性能:

①静态代理: 在编译时就确定了代理类,运行时性能相对较好。
②动态代理: 生成代理类的过程可能会带来一些性能开销。

动态代理常用的实现方式有基于java.lang.reflect.Proxy和基于CGLIB的动态代理。在实际应用中,根据需要选择静态代理或动态代理。

 

你可能感兴趣的:(代理模式,java,开发语言)