Spring 动态代理（一） - 代理模式

最新推荐文章于 2024-06-29 13:23:46 发布
最新推荐文章于 2024-06-29 13:23:46 发布
阅读量3k 收藏 10
点赞数 3
分类专栏： java 文章标签： java 动态代理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lilongjiu/article/details/77017620
版权

java 代理模式

1. 静态代理

1.1 概念

静态代理模式其实很常见，比如买火车票这件小事：黄牛相当于是火车站的代理，我们可以通过黄牛买票，但只能去火车站进行改签和退票。在代码实现中相当于为一个委托对象realSubject提供一个代理对象proxy，通过proxy可以调用realSubject的部分功能，并添加一些额外的业务处理，同时可以屏蔽realSubject中未开放的接口。

  • RealSubject 是委托类，Proxy 是代理类；
  • Subject 是委托类和代理类的接口；
  • request() 是委托类和代理类的共同方法；

这里写图片描述

1.2 静态代理实现
interface Subject {

    void request();
}

class RealSubject implements Subject {

    @Override
    public void request(){

        System.out.println("RealSubject");
    }
}

class Proxy implements Subject {

    private Subject subject;

    public Proxy(Subject subject){
        this.subject = subject;
    }

    @Override
    public void request(){

        System.out.println("begin");

        subject.request();

        System.out.println("end");
    }
}

public class ProxyTest {

    public static void main(String args[]) {

        RealSubject subject = new RealSubject();

        Proxy proxy = new Proxy(subject);

        proxy.request();
    }
}

输出：
begin
RealSubject
end

静态代理实现中，一个委托类对应一个代理类，代理类在编译期间就已经确定。

2. java动态代理

2.1 概念

动态代理中，代理类并不是在Java代码中实现，而是在运行时期生成，相比静态代理，动态代理可以很方便的对委托类的方法进行统一处理，如添加方法调用次数、添加日志功能等等。

java动态代理核心类：

  • java.lang.reflect.Proxy
  • java.lang.reflect.InvocationHandler


实际使用：

  • 实现 InvocationHandler 的 invoke 方法
  • 调用 Proxy.newProxyInstance 生成代理类

2.2 java动态代理实现

比如公司员工准备出差，需要办理签证，办理签证需要准备各种材料，一些公司有专门的签证科，帮员工办理签证。

  • 申请签证接口
public interface Subject {

    //申请签证
    public void applyVisa();
}
  • 实际申请签证的人
public class RealSubject implements Subject {

    //代理人为员工申请签证
    @Override
    public void applyVisa() {
        System.out.println("apply visa for staff");
    }

    public void otherMethod(){

    }
}
  • 签证科代理员工，准备收集员工材料，代员工申请签证
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 {

        //准备材料
        System.out.println("prepare materials");

        //申请签证
        Object object = method.invoke(target, args);

        //通知员工领取签证
        System.out.println("notice staff to receive visa");

        return object;
    }

    public Object getProxy() {

        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

        Class<?> [] interfaces = target.getClass().getInterfaces();

        return Proxy.newProxyInstance(classLoader, interfaces, this);
    }

}
  • java动态代理demo
public class Test {

    public static void main(String[] args) throws Exception {

        RealSubject realSubject = new RealSubject();

        MyInvocationHandler handler = new MyInvocationHandler(realSubject);

        Subject subject = (Subject) handler.getProxy();

        subject.applyVisa();


        //输出jdk动态代理类文件
        byte[] classFile = ProxyGenerator.generateProxyClass("com.sun.proxy.$Proxy.1", subject.getClass().getInterfaces());

        FileOutputStream out = new FileOutputStream("com.sun.proxy.$Proxy.1.class");

        out.write(classFile);

        out.flush();
    }
}

输出：
prepare materials
apply visa for staff
notice staff to receive visa

  • 使用反编译软件打开com.sun.proxy.$Proxy.1.class

    1. 可以看到代理类继承Proxy，并且实现了Subject接口。
    2. 代理类的 applyVisa 执行的是 InvocationHandler 的 invoke 方法
package com.sun.proxy.$Proxy;

import com.lilongjiu.study.java.proxy.Subject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class 1
  extends Proxy
  implements Subject
{
  private static Method m1;
  private static Method m2;
  private static Method m3;
  private static Method m0;

  public 1(InvocationHandler paramInvocationHandler)
  {
    super(paramInvocationHandler);
  }

  public final boolean equals(Object paramObject)
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final String toString()
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final void applyVisa()
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final int hashCode()
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m3 = Class.forName("com.lilongjiu.study.java.proxy.Subject").getMethod("applyVisa", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }
}
  • jdk动态代理使用的局限性

通过反射类Proxy和InvocationHandler回调接口实现的jdk动态代理，要求委托类必须实现一个接口，但事实上并不是所有类都有接口，对于没有实现接口的类，便无法使用该方方式实现动态代理。

jdk动态代理生成的代理与被代理对象并没有继承关系，只是实现了相同的接口

3.cglib 动态代理

3.1 概念

CGLib采用了底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑

cglib动态代理核心类：

  • net.sf.cglib.proxy.Enhancer
  • net.sf.cglib.proxy.MethodInterceptor


实际使用：

  • Enhancer 设置代理类，设置回调方法拦截器
  • 实现 MethodInterceptor 的 intercept 方法

3.2 cglib动态代理实现
package com.lilongjiu.study.java.proxy;


import net.sf.cglib.core.DebuggingClassWriter;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * Created by lilongjiu.
 */
public class CgLibProxy implements MethodInterceptor {

    public Object getProxy(Class<?> clazz)
    {
        Enhancer enhancer = new Enhancer();

        //设置代理类
        enhancer.setSuperclass(clazz);

         //设置回调拦截
        enhancer.setCallback(this);

        return enhancer.create();

    }

    @Override
    public Object intercept(Object object, Method method, Object[] arg2,
                            MethodProxy proxy) throws Throwable
    {
        //准备材料
        System.out.println("prepare materials");

        //申请签证
        Object result = proxy.invokeSuper(object, arg2);

        //通知员工领取签证
        System.out.println("notice staff to receive visa");

        return result;
    }

    public static void main(String[] args)
    {
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/Users/lilongjiu/02workspace/temp");

        CgLibProxy proxy = new CgLibProxy();

        Subject subject = (Subject)proxy.getProxy(RealSubject.class);

        subject.applyVisa();
    }
}


* 可以看到cglib生成的代理类，继承了代理对象，代理与被代理对象是继承关系。 

package com.lilongjiu.study.java.proxy;

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class RealSubject$$EnhancerByCGLIB$$72d04edb
  extends RealSubject
  implements Factory
{
  private boolean CGLIB$BOUND;
  public static Object CGLIB$FACTORY_DATA;
  private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
  private static final Callback[] CGLIB$STATIC_CALLBACKS;
  private MethodInterceptor CGLIB$CALLBACK_0;
  private static Object CGLIB$CALLBACK_FILTER;
  private static final Method CGLIB$applyVisa$0$Method;
  private static final MethodProxy CGLIB$applyVisa$0$Proxy;
  private static final Object[] CGLIB$emptyArgs;
  private static final Method CGLIB$otherMethod$1$Method;
  private static final MethodProxy CGLIB$otherMethod$1$Proxy;
  private static final Method CGLIB$equals$2$Method;
  private static final MethodProxy CGLIB$equals$2$Proxy;
  private static final Method CGLIB$toString$3$Method;
  private static final MethodProxy CGLIB$toString$3$Proxy;
  private static final Method CGLIB$hashCode$4$Method;
  private static final MethodProxy CGLIB$hashCode$4$Proxy;
  private static final Method CGLIB$clone$5$Method;
  private static final MethodProxy CGLIB$clone$5$Proxy;

  /* Error */
  static void CGLIB$STATICHOOK1()
  {
    // Byte code:
    //   0: new 22  java/lang/ThreadLocal
    //   3: dup
    //   4: invokespecial 25    java/lang/ThreadLocal:<init>    ()V
    //   7: putstatic 27    com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$THREAD_CALLBACKS    Ljava/lang/ThreadLocal;
    //   10: iconst_0
    //   11: anewarray 76   java/lang/Object
    //   14: putstatic 47   com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$emptyArgs   [Ljava/lang/Object;
    //   17: ldc -109
    //   19: invokestatic 153   java/lang/Class:forName (Ljava/lang/String;)Ljava/lang/Class;
    //   22: astore_0
    //   23: bipush 8
    //   25: anewarray 97   java/lang/String
    //   28: dup
    //   29: iconst_0
    //   30: ldc -102
    //   32: aastore
    //   33: dup
    //   34: iconst_1
    //   35: ldc -101
    //   37: aastore
    //   38: dup
    //   39: iconst_2
    //   40: ldc -100
    //   42: aastore
    //   43: dup
    //   44: iconst_3
    //   45: ldc -99
    //   47: aastore
    //   48: dup
    //   49: iconst_4
    //   50: ldc -98
    //   52: aastore
    //   53: dup
    //   54: iconst_5
    //   55: ldc -97
    //   57: aastore
    //   58: dup
    //   59: bipush 6
    //   61: ldc -96
    //   63: aastore
    //   64: dup
    //   65: bipush 7
    //   67: ldc -95
    //   69: aastore
    //   70: ldc -93
    //   72: invokestatic 153   java/lang/Class:forName (Ljava/lang/String;)Ljava/lang/Class;
    //   75: dup
    //   76: astore_1
    //   77: invokevirtual 167  java/lang/Class:getDeclaredMethods  ()[Ljava/lang/reflect/Method;
    //   80: invokestatic 173   net/sf/cglib/core/ReflectUtils:findMethods  ([Ljava/lang/String;[Ljava/lang/reflect/Method;)[Ljava/lang/reflect/Method;
    //   83: dup
    //   84: iconst_0
    //   85: aaload
    //   86: putstatic 74   com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$equals$2$Method   Ljava/lang/reflect/Method;
    //   89: aload_1
    //   90: aload_0
    //   91: ldc -101
    //   93: ldc -102
    //   95: ldc -82
    //   97: invokestatic 180   net/sf/cglib/proxy/MethodProxy:create   (Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lnet/sf/cglib/proxy/MethodProxy;
    //   100: putstatic 78  com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$equals$2$Proxy    Lnet/sf/cglib/proxy/MethodProxy;
    //   103: dup
    //   104: iconst_1
    //   105: aaload
    //   106: putstatic 93  com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$toString$3$Method   Ljava/lang/reflect/Method;
    //   109: aload_1
    //   110: aload_0
    //   111: ldc -99
    //   113: ldc -100
    //   115: ldc -75
    //   117: invokestatic 180  net/sf/cglib/proxy/MethodProxy:create   (Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lnet/sf/cglib/proxy/MethodProxy;
    //   120: putstatic 95  com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$toString$3$Proxy    Lnet/sf/cglib/proxy/MethodProxy;
    //   123: dup
    //   124: iconst_2
    //   125: aaload
    //   126: putstatic 106 com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$hashCode$4$Method   Ljava/lang/reflect/Method;
    //   129: aload_1
    //   130: aload_0
    //   131: ldc -97
    //   133: ldc -98
    //   135: ldc -74
    //   137: invokestatic 180  net/sf/cglib/proxy/MethodProxy:create   (Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lnet/sf/cglib/proxy/MethodProxy;
    //   140: putstatic 108 com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$hashCode$4$Proxy    Lnet/sf/cglib/proxy/MethodProxy;
    //   143: dup
    //   144: iconst_3
    //   145: aaload
    //   146: putstatic 124 com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$clone$5$Method   Ljava/lang/reflect/Method;
    //   149: aload_1
    //   150: aload_0
    //   151: ldc -95
    //   153: ldc -96
    //   155: ldc -73
    //   157: invokestatic 180  net/sf/cglib/proxy/MethodProxy:create   (Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lnet/sf/cglib/proxy/MethodProxy;
    //   160: putstatic 126 com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$clone$5$Proxy    Lnet/sf/cglib/proxy/MethodProxy;
    //   163: pop
    //   164: iconst_4
    //   165: anewarray 97  java/lang/String
    //   168: dup
    //   169: iconst_0
    //   170: ldc -72
    //   172: aastore
    //   173: dup
    //   174: iconst_1
    //   175: ldc -71
    //   177: aastore
    //   178: dup
    //   179: iconst_2
    //   180: ldc -70
    //   182: aastore
    //   183: dup
    //   184: iconst_3
    //   185: ldc -71
    //   187: aastore
    //   188: ldc -68
    //   190: invokestatic 153  java/lang/Class:forName (Ljava/lang/String;)Ljava/lang/Class;
    //   193: dup
    //   194: astore_1
    //   195: invokevirtual 167 java/lang/Class:getDeclaredMethods  ()[Ljava/lang/reflect/Method;
    //   198: invokestatic 173  net/sf/cglib/core/ReflectUtils:findMethods  ([Ljava/lang/String;[Ljava/lang/reflect/Method;)[Ljava/lang/reflect/Method;
    //   201: dup
    //   202: iconst_0
    //   203: aaload
    //   204: putstatic 45  com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$applyVisa$0$Method   Ljava/lang/reflect/Method;
    //   207: aload_1
    //   208: aload_0
    //   209: ldc -71
    //   211: ldc -72
    //   213: ldc -67
    //   215: invokestatic 180  net/sf/cglib/proxy/MethodProxy:create   (Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lnet/sf/cglib/proxy/MethodProxy;
    //   218: putstatic 49  com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$applyVisa$0$Proxy    Lnet/sf/cglib/proxy/MethodProxy;
    //   221: dup
    //   222: iconst_1
    //   223: aaload
    //   224: putstatic 63  com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$otherMethod$1$Method   Ljava/lang/reflect/Method;
    //   227: aload_1
    //   228: aload_0
    //   229: ldc -71
    //   231: ldc -70
    //   233: ldc -66
    //   235: invokestatic 180  net/sf/cglib/proxy/MethodProxy:create   (Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lnet/sf/cglib/proxy/MethodProxy;
    //   238: putstatic 65  com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$otherMethod$1$Proxy    Lnet/sf/cglib/proxy/MethodProxy;
    //   241: pop
    //   242: return
    //   243: athrow
  }

  final void CGLIB$applyVisa$0()
  {
    super.applyVisa();
  }

  public final void applyVisa()
  {
    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
    if (tmp4_1 == null)
    {
      tmp4_1;
      CGLIB$BIND_CALLBACKS(this);
    }
    if (this.CGLIB$CALLBACK_0 != null) {
      return;
    }
    super.applyVisa();
  }

  final void CGLIB$otherMethod$1()
  {
    super.otherMethod();
  }

  public final void otherMethod()
  {
    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
    if (tmp4_1 == null)
    {
      tmp4_1;
      CGLIB$BIND_CALLBACKS(this);
    }
    if (this.CGLIB$CALLBACK_0 != null) {
      return;
    }
    super.otherMethod();
  }

  final boolean CGLIB$equals$2(Object paramObject)
  {
    return super.equals(paramObject);
  }

  public final boolean equals(Object paramObject)
  {
    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
    if (tmp4_1 == null)
    {
      tmp4_1;
      CGLIB$BIND_CALLBACKS(this);
    }
    MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
    if (tmp17_14 != null)
    {
      Object tmp41_36 = tmp17_14.intercept(this, CGLIB$equals$2$Method, new Object[] { paramObject }, CGLIB$equals$2$Proxy);
      tmp41_36;
      return tmp41_36 == null ? false : ((Boolean)tmp41_36).booleanValue();
    }
    return super.equals(paramObject);
  }

  final String CGLIB$toString$3()
  {
    return super.toString();
  }

  public final String toString()
  {
    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
    if (tmp4_1 == null)
    {
      tmp4_1;
      CGLIB$BIND_CALLBACKS(this);
    }
    MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
    if (tmp17_14 != null) {
      return (String)tmp17_14.intercept(this, CGLIB$toString$3$Method, CGLIB$emptyArgs, CGLIB$toString$3$Proxy);
    }
    return super.toString();
  }

  final int CGLIB$hashCode$4()
  {
    return super.hashCode();
  }

  public final int hashCode()
  {
    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
    if (tmp4_1 == null)
    {
      tmp4_1;
      CGLIB$BIND_CALLBACKS(this);
    }
    MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
    if (tmp17_14 != null)
    {
      Object tmp36_31 = tmp17_14.intercept(this, CGLIB$hashCode$4$Method, CGLIB$emptyArgs, CGLIB$hashCode$4$Proxy);
      tmp36_31;
      return tmp36_31 == null ? 0 : ((Number)tmp36_31).intValue();
    }
    return super.hashCode();
  }

  final Object CGLIB$clone$5()
    throws CloneNotSupportedException
  {
    return super.clone();
  }

  protected final Object clone()
    throws CloneNotSupportedException
  {
    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
    if (tmp4_1 == null)
    {
      tmp4_1;
      CGLIB$BIND_CALLBACKS(this);
    }
    MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
    if (tmp17_14 != null) {
      return tmp17_14.intercept(this, CGLIB$clone$5$Method, CGLIB$emptyArgs, CGLIB$clone$5$Proxy);
    }
    return super.clone();
  }

  /* Error */
  public static MethodProxy CGLIB$findMethodProxy(net.sf.cglib.core.Signature arg0)
  {
    // Byte code:
    //   0: aload_0
    //   1: invokevirtual 129   java/lang/Object:toString   ()Ljava/lang/String;
    //   4: dup
    //   5: invokevirtual 130   java/lang/Object:hashCode   ()I
    //   8: lookupswitch    default:+132->140, -508378822:+60->68, -299588156:+72->80, 332556358:+84->92, 1826985398:+96->104, 1913648695:+108->116, 1984935277:+120->128
    //   68: ldc -124
    //   70: invokevirtual 133  java/lang/Object:equals (Ljava/lang/Object;)Z
    //   73: ifeq +68 -> 141
    //   76: getstatic 126  com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$clone$5$Proxy    Lnet/sf/cglib/proxy/MethodProxy;
    //   79: areturn
    //   80: ldc -121
    //   82: invokevirtual 133  java/lang/Object:equals (Ljava/lang/Object;)Z
    //   85: ifeq +56 -> 141
    //   88: getstatic 65   com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$otherMethod$1$Proxy    Lnet/sf/cglib/proxy/MethodProxy;
    //   91: areturn
    //   92: ldc -119
    //   94: invokevirtual 133  java/lang/Object:equals (Ljava/lang/Object;)Z
    //   97: ifeq +44 -> 141
    //   100: getstatic 49  com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$applyVisa$0$Proxy    Lnet/sf/cglib/proxy/MethodProxy;
    //   103: areturn
    //   104: ldc -117
    //   106: invokevirtual 133 java/lang/Object:equals (Ljava/lang/Object;)Z
    //   109: ifeq +32 -> 141
    //   112: getstatic 78  com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$equals$2$Proxy    Lnet/sf/cglib/proxy/MethodProxy;
    //   115: areturn
    //   116: ldc -115
    //   118: invokevirtual 133 java/lang/Object:equals (Ljava/lang/Object;)Z
    //   121: ifeq +20 -> 141
    //   124: getstatic 95  com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$toString$3$Proxy    Lnet/sf/cglib/proxy/MethodProxy;
    //   127: areturn
    //   128: ldc -113
    //   130: invokevirtual 133 java/lang/Object:equals (Ljava/lang/Object;)Z
    //   133: ifeq +8 -> 141
    //   136: getstatic 108 com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$hashCode$4$Proxy    Lnet/sf/cglib/proxy/MethodProxy;
    //   139: areturn
    //   140: pop
    //   141: aconst_null
    //   142: areturn
  }

  public RealSubject$$EnhancerByCGLIB$$72d04edb()
  {
    CGLIB$BIND_CALLBACKS(this);
  }

  public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] paramArrayOfCallback)
  {
    CGLIB$THREAD_CALLBACKS.set(paramArrayOfCallback);
  }

  public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] paramArrayOfCallback)
  {
    CGLIB$STATIC_CALLBACKS = paramArrayOfCallback;
  }

  private static final void CGLIB$BIND_CALLBACKS(Object paramObject)
  {
    72d04edb local72d04edb = (72d04edb)paramObject;
    if (!local72d04edb.CGLIB$BOUND)
    {
      local72d04edb.CGLIB$BOUND = true;
      Object tmp23_20 = CGLIB$THREAD_CALLBACKS.get();
      if (tmp23_20 == null)
      {
        tmp23_20;
        CGLIB$STATIC_CALLBACKS;
      }
      local72d04edb.CGLIB$CALLBACK_0 = (tmp31_28 == null ? tmp31_28 : (MethodInterceptor)((Callback[])tmp23_20)[0]);
    }
  }

  public Object newInstance(Callback[] paramArrayOfCallback)
  {
    CGLIB$SET_THREAD_CALLBACKS(paramArrayOfCallback);
    CGLIB$SET_THREAD_CALLBACKS(null);
    return new 72d04edb();
  }

  public Object newInstance(Callback paramCallback)
  {
    CGLIB$SET_THREAD_CALLBACKS(new Callback[] { paramCallback });
    CGLIB$SET_THREAD_CALLBACKS(null);
    return new 72d04edb();
  }

  /* Error */
  public Object newInstance(Class[] arg1, Object[] arg2, Callback[] arg3)
  {
    // Byte code:
    //   0: aload_3
    //   1: invokestatic 209    com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$SET_THREAD_CALLBACKS    ([Lnet/sf/cglib/proxy/Callback;)V
    //   4: new 2   com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb
    //   7: dup
    //   8: aload_1
    //   9: dup
    //   10: arraylength
    //   11: tableswitch    default:+24->35, 0:+17->28
    //   28: pop
    //   29: invokespecial 210  com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:<init> ()V
    //   32: goto +17 -> 49
    //   35: goto +3 -> 38
    //   38: pop
    //   39: new 216    java/lang/IllegalArgumentException
    //   42: dup
    //   43: ldc -38
    //   45: invokespecial 221  java/lang/IllegalArgumentException:<init>   (Ljava/lang/String;)V
    //   48: athrow
    //   49: aconst_null
    //   50: invokestatic 209   com/lilongjiu/study/java/proxy/RealSubject$$EnhancerByCGLIB$$72d04edb:CGLIB$SET_THREAD_CALLBACKS    ([Lnet/sf/cglib/proxy/Callback;)V
    //   53: areturn
  }

  public Callback getCallback(int paramInt)
  {
    CGLIB$BIND_CALLBACKS(this);
    switch (paramInt)
    {
    case 0: 
      break;
    }
    return null;
  }

  public void setCallback(int paramInt, Callback paramCallback)
  {
    switch (paramInt)
    {
    case 0: 
      this.CGLIB$CALLBACK_0 = ((MethodInterceptor)paramCallback);
      break;
    }
  }

  public Callback[] getCallbacks()
  {
    CGLIB$BIND_CALLBACKS(this);
    return new Callback[] { this.CGLIB$CALLBACK_0 };
  }

  public void setCallbacks(Callback[] paramArrayOfCallback)
  {
    this.CGLIB$CALLBACK_0 = ((MethodInterceptor)paramArrayOfCallback[0]);
  }

  static {}
}

Spring 动态代理（一） - 代理模式

Spring 动态代理（二） - ProxyFactoryBean

Spring 动态代理（三） - BeanNameAutoProxyCreator

Spring 动态代理（四）- 动态代理核心类 - ProxyCreatorSupport

Spring 动态代理（五） - 自定义BeanTypeAutoProxyCreator

李懿名
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring——动态代理
ly000666的博客
05-22 8060
动态代理(理解)：基于反射机制。 掌握程度： 1.什么是动态代理？ ​ 使用jdk的反射机制，创建对象的能力，创建的是代理类的对象。而不用你创建类文件。不用谢java文件。 ​ 动态：在程序执行时，调用JDK提供的方法才能创建代理类的对象。 ​ jdk动态代理，必须有接口，目标类必须实现接口，没有接口时，需要使用cylib动态代理。 2.知道动态代理能做什么？ ​ 可以在不改变原来目标方法功能的前提下，可以在代理中增强自己的功能代码。 ​ 程序开发中的意思。 ​ 比如：你所在的项目中，有一个功能是其他人
Java Spring代理模式AOP-IOC分析
10-01
Java Spring代理模式AOP-IOC分析 一、代理模式概述 在软件设计中，代理模式是一种常用的设计模式。...本文对Java Spring代理模式AOP-IOC进行了分析和讨论，并提供了一个示例项目来演示如何使用Spring实现AOP和IOC。
设计模式之代理模式分析使用
热门推荐
张彦峰的博客
05-21 164万+
代理模式原理和使用分析总结
Spring动态代理详解
最新发布
Xwz的博客
06-29 695
私有成员变量rent：它是Rent接口的一个实现，代表被代理的对象。setRent 方法：用于设置代理的目标对象。getProxy 方法：利用ProxynewProxyInstance方法生成代理对象。这个方法需要三个参数：类加载器，接口数组（代理类需要实现的接口），以及一个InvocationHandler实例（当前对象this）。invoke 方法：这是代理实例的方法调用时实际执行的代码。invoke方法可以在调用目标方法前后添加自定义逻辑，本例中只是简单地调用了目标对象的相应方法。//租房。
Spring AOP基础之代理模式.静态代理和动态代理
张晨光老师的播客
09-29 1214
/args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。动态代理和静态代理的角色是一样的，动态代理的代理类是动态生成的，不是像静态代理那样是直接写死的。代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。体现一个重要的思想：在不改变原有代码的情况下，实现对原有功能的增强。
Spring的AOP之代理模式
长安不及十里的博客
08-03 4998
关于两者之间的性能的话，网上有人对于不通版本的jdk进行测试，经过多次试验，测试结果大致是这样的，在1.6和1.7的时候，JDK动态代理的速度要比CGLib动态代理的速度要慢，但是并没有教科书上的10倍差距，在JDK1.8的时候，JDK动态代理的速度已经比CGLib动态代理的速度快很多了，但是JDK动态代理和CGLIB动态代理的适用场景还是不一样的哈！动态代理生成的代理类通常是在运行时通过字节码生成技术生成的，因此在创建代理对象时，需要一个 ClassLoader 来加载这个新生成的代理类。
13-Spring动态代理
前路无畏的博客
11-03 1万+
上一篇：12-静态代理设计模式-为了引出spring动态代理https://blog.csdn.net/fsjwin/article/details/109461867 spring的动态代理很高端吗？ 其实本质上就是对静态代理的抽离，封装，试听高端的，目的就一个，更有利于程序员的使用，下面来介绍一下spring动态代理。 1.Spring动态代理的概念 概念：通过代理类为原始类(目标类)增加额外功能 好处：利于原始类(目标类)的维护 从这点看和静态代理一样一样的 2.Spring动态代理相关依赖的引入 &
spring的代理模式
weixin_43723296的博客
07-07 3628
1、何为代理模式 如何实现在不修改源码的基础上实现代码功能的增强呢？spring为我们提供了代理模式。所谓的代理模式通俗来说就是一个中介，它给某一个对象提供一个代理对象，并由代理对象控制原对象的引用，从而实现在不修改源码的基础上实现代码功能的增强。2、分类 按照代理创建的时期进行分类，可以分为两类：静态代理、动态代理。 静态代理的代理类=原始类+增强（额外功能）+和原始类实现同一个接口，即基于接口的代理。 动态代理又分为jdk动态代理，其也是基于接口的
Spring框架中的代理模式
YiGeiGiaoGiao的博客
11-21 1239
代理模式
Spring中的静态代理和动态代理
PIKapikaaaa的博客
07-05 1590
Spring中的静态代理和动态代理
Spring的代理模式
楠黎倾风的博客
11-04 2万+
对spring代理模式的详细解说以及实现
Spring AOP理论 +代理模式详解
weixin_45080272的博客
11-06 2249
面向切面思想，是Spring的三大核心思想之一（两外两个：IOC-控制反转、DI-依赖注入）。那么AOP为何那么重要呢？在我们的程序中，经常存在一些系统性的需求，比如权限校验、日志记录、统计等，这些代码会散落穿插在各个业务逻辑中，非常冗余且不利于维护。例如下面这个示意图：有多少业务操作，就要写多少重复的校验和日志记录代码，这显然是无法接受的。
java Spring代理模式AOP-IOC结合
10-01
动态代理是一种更加灵活的代理模式实现方式，我们可以使用 JDK 内置的 Proxy 类或 CGLIB 库来实现动态代理。动态代理可以在运行时生成代理类，无需手动创建代理类。 四、AOP（Aspect Oriented Programming） AOP ...
Spring整合JDBC实现转账业务-动态代理模式
06-01
在本示例中，我们将深入探讨如何利用Spring框架与JDBC的整合来实现转账业务，并通过动态代理模式来优化事务管理。动态代理模式是Java中一种强大的设计模式，它允许我们在运行时创建对象的代理，以拦截方法调用并执行...
代理模式-静态动态代理-jdk动态代理-cglib动态代理
11-12
代理模式是一种设计模式，它允许我们在不修改原有对象的情况下，为对象添加新的功能或行为。在Java中，代理模式有多种实现方式，包括静态代理、JDK动态代理和CGLIB动态代理。 **静态代理** 静态代理是最早也是最...
Spring代理模式解析
12-06
Spring框架中的代理模式是其核心特性之一，它在AOP（面向切面编程）中扮演着重要角色。本文将深入探讨Spring代理模式的工作原理，并通过实际示例来帮助理解。 一、Spring代理模式概述 代理模式是一种设计模式，它...
idea使用junit5 版本问题
lilongjiu的专栏
09-14 3915
idea 使用junit5 引入版本junit5文档 IntelliJ IDEA Version Bundled JUnit 5 Version 2016.2 M2 2016.3.1 M3 2017.1.2 M4 2017.2.1 M5 2017.2.3 RC2
Idea（Mac） 安装 PlantUML
lilongjiu的专栏
09-23 3427
IntelliJ IDEA PlantUML Graphviz
深入学习Java Spring代理模式AOP-IOC及实现方式
本文将从静态代理、动态代理、AOP和IOC等多个方面对Java Spring代理模式进行分析，帮助读者更深入地理解和掌握这一核心概念。 一、为什么需要代理模式 代理模式是一种解耦的设计模式，它可以将业务逻辑和横切关注...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值