紫色红色黑色
紫色红色黑色

动态代理

描述

动态代理是指在程序运行时生成代理类，通过操作代理类进而操作目标类。本文描述了JDK和cglib(Byte Code Generation Library)动态代理原理。两者都是生成代理类，来调用目标类的方法，但是JDK调用目标类方法使用反射，cglib调用时则使用FastClass方式，因此cglib调用比较快。

JDK流程：调用代理类的方法，调用InvocationHandler的invoke()，使用method.invoke()调用目标类方法。
cglib流程：调用代理类的代理方法，调用MethodInterceptor的interceptor()，调用FastClass的invoke()，调用代理类的目标方法，目标方法调用父类方法。

JDK动态代理

JDK动态代理是操作字节码生成一个继承Proxy、实现目标接口的代理类。代理类中调用Proxy的属性InvocationHandler的invoke()。在invoke()中使用method.invoke(target,args)调用目标方法。

1.先编写InvocationHandler实现类，实现类中有目标类对象。

public class IHelloInvocationHandler implements InvocationHandler {

    // 目标类对象
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("invoke before");
        method.invoke(target, args);
        System.out.println("invoke after");
        return null;
    }

2.测试demo

public static void main(String[] args) {

        IHello target = new IHelloImpl();
        Class aClass = target.getClass();

        ClassLoader classLoader = aClass.getClassLoader();
        Class[] interfaces = aClass.getInterfaces();

        IHelloInvocationHandler invocationHandler = new IHelloInvocationHandler(target);
        IHello o = (IHello) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
        o.sayHello();

        byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0.class", o.getClass().getInterfaces());

        String path = "/Users/lucy/Desktop/$Proxy0.class";
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(path);
            out.write(bytes);
            out.flush();
        } catch (java.io.IOException e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }

3.反编译代理类

/*
 * Decompiled with CFR 0.146.
 *
 * Could not load the following classes:
 *  $Proxy0.class
 *  com.redoor.proxy.jdk.IHello
 */
package $Proxy0;

import com.redoor.proxy.jdk.IHello;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

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

    public class(InvocationHandler invocationHandler) throws  {
        super(invocationHandler);
    }

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

    public final void sayHello() throws  {
        try {
            this.h.invoke((Object)this, m3, null);
            return;
        }
        catch (Error | RuntimeException throwable) {
            throw throwable;
        }
        catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

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

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

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.redoor.proxy.jdk.IHello").getMethod("sayHello", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            return;
        }
        catch (NoSuchMethodException noSuchMethodException) {
            throw new NoSuchMethodError(noSuchMethodException.getMessage());
        }
        catch (ClassNotFoundException classNotFoundException) {
            throw new NoClassDefFoundError(classNotFoundException.getMessage());
        }
    }
}

cglib动态代理

cglib动态代理调用流程。o.sayHello()调用代理类的代理方法。该方法调用MethodInterceptor的intercept()。然后调用MethodProxy.invokerSuper()。在调用FastClass的invoke()。在调用代理类中的父类方法。

1.编写MethodInterceptor

public class UserMethodInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        System.out.println("intercept before");
        Object o1 = methodProxy.invokeSuper(o, objects);
        System.out.println("intercept after");

        return o1;
    }
}

2.测试demo

public static void main(String[] args) {

    // 指定cglib生成类的目录位置
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/Users/lucy/Desktop/cglibProxy");

    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(User.class);
    enhancer.setCallback(new UserMethodInterceptor());

    User o = (User) enhancer.create();
    o.sayHello();

}

3.反编译生成类
可以看到在/Users/lucy/Desktop/cglibProxy/com/redoor/proxy/cglib目录下生成了3个类，第2个类代理类，就是目标类的子类。第1个类是代理类的FastClass，第3个类是目标类的FastClass。

FastClass是对方法建立索引，使用索引去调用方法。避免使用反射，提高调用速率。

User$$EnhancerByCGLIB$$3668a66c$$FastClassByCGLIB$$cb19fc35.class
User$$EnhancerByCGLIB$$3668a66c.class
User$$FastClassByCGLIB$$5801fa18.class
  • 反编译代理类
    可以看到cglib为每个代理方法生成了两个方法。第一个是调用父类方法，也就是调用目标类方法。第二个是代理类方法，首先判断MethodInterceptor是否存在，如果存在就调用methodInterceptor.intercept()。
/*
 * Decompiled with CFR 0.146.
 *
 * Could not load the following classes:
 *  com.redoor.proxy.cglib.User
 *  net.sf.cglib.core.ReflectUtils
 *  net.sf.cglib.core.Signature
 *  net.sf.cglib.proxy.Callback
 *  net.sf.cglib.proxy.Factory
 *  net.sf.cglib.proxy.MethodInterceptor
 *  net.sf.cglib.proxy.MethodProxy
 */
package com.redoor.proxy.cglib;

import com.redoor.proxy.cglib.User;
import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
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 User$$EnhancerByCGLIB$$3668a66c
extends User
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$sayHello$0$Method;
    private static final MethodProxy CGLIB$sayHello$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$equals$1$Method;
    private static final MethodProxy CGLIB$equals$1$Proxy;
    private static final Method CGLIB$toString$2$Method;
    private static final MethodProxy CGLIB$toString$2$Proxy;
    private static final Method CGLIB$hashCode$3$Method;
    private static final MethodProxy CGLIB$hashCode$3$Proxy;
    private static final Method CGLIB$clone$4$Method;
    private static final MethodProxy CGLIB$clone$4$Proxy;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class class_ = Class.forName("com.redoor.proxy.cglib.User$$EnhancerByCGLIB$$3668a66c");
        Class class_2 = Class.forName("java.lang.Object");
        Method[] arrmethod = ReflectUtils.findMethods((String[])new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (Method[])class_2.getDeclaredMethods());
        CGLIB$equals$1$Method = arrmethod[0];
        CGLIB$equals$1$Proxy = MethodProxy.create(class_2, class_, (String)"(Ljava/lang/Object;)Z", (String)"equals", (String)"CGLIB$equals$1");
        CGLIB$toString$2$Method = arrmethod[1];
        CGLIB$toString$2$Proxy = MethodProxy.create(class_2, class_, (String)"()Ljava/lang/String;", (String)"toString", (String)"CGLIB$toString$2");
        CGLIB$hashCode$3$Method = arrmethod[2];
        CGLIB$hashCode$3$Proxy = MethodProxy.create(class_2, class_, (String)"()I", (String)"hashCode", (String)"CGLIB$hashCode$3");
        CGLIB$clone$4$Method = arrmethod[3];
        CGLIB$clone$4$Proxy = MethodProxy.create(class_2, class_, (String)"()Ljava/lang/Object;", (String)"clone", (String)"CGLIB$clone$4");
        class_2 = Class.forName("com.redoor.proxy.cglib.User");
        CGLIB$sayHello$0$Method = ReflectUtils.findMethods((String[])new String[]{"sayHello", "()V"}, (Method[])class_2.getDeclaredMethods())[0];
        CGLIB$sayHello$0$Proxy = MethodProxy.create(class_2, class_, (String)"()V", (String)"sayHello", (String)"CGLIB$sayHello$0");
    }

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

    public final void sayHello() {
        MethodInterceptor methodInterceptor = this.CGLIB$CALLBACK_0;
        if (methodInterceptor == null) {
            User$$EnhancerByCGLIB$$3668a66c.CGLIB$BIND_CALLBACKS((Object)this);
            methodInterceptor = this.CGLIB$CALLBACK_0;
        }
        if (methodInterceptor != null) {
            Object object = methodInterceptor.intercept((Object)this, CGLIB$sayHello$0$Method, CGLIB$emptyArgs, CGLIB$sayHello$0$Proxy);
            return;
        }
        super.sayHello();
    }

    final boolean CGLIB$equals$1(Object object) {
        return super.equals(object);
    }

    public final boolean equals(Object object) {
        MethodInterceptor methodInterceptor = this.CGLIB$CALLBACK_0;
        if (methodInterceptor == null) {
            User$$EnhancerByCGLIB$$3668a66c.CGLIB$BIND_CALLBACKS((Object)this);
            methodInterceptor = this.CGLIB$CALLBACK_0;
        }
        if (methodInterceptor != null) {
            Object object2;
            return methodInterceptor.intercept((Object)this, CGLIB$equals$1$Method, new Object[]{object}, CGLIB$equals$1$Proxy) == null ? false : (Boolean)object2;
        }
        return super.equals(object);
    }

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

    public final String toString() {
        MethodInterceptor methodInterceptor = this.CGLIB$CALLBACK_0;
        if (methodInterceptor == null) {
            User$$EnhancerByCGLIB$$3668a66c.CGLIB$BIND_CALLBACKS((Object)this);
            methodInterceptor = this.CGLIB$CALLBACK_0;
        }
        if (methodInterceptor != null) {
            return (String)methodInterceptor.intercept((Object)this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy);
        }
        return super.toString();
    }

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

    public final int hashCode() {
        MethodInterceptor methodInterceptor = this.CGLIB$CALLBACK_0;
        if (methodInterceptor == null) {
            User$$EnhancerByCGLIB$$3668a66c.CGLIB$BIND_CALLBACKS((Object)this);
            methodInterceptor = this.CGLIB$CALLBACK_0;
        }
        if (methodInterceptor != null) {
            Object object;
            return methodInterceptor.intercept((Object)this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy) == null ? 0 : ((Number)object).intValue();
        }
        return super.hashCode();
    }

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

    protected final Object clone() throws CloneNotSupportedException {
        MethodInterceptor methodInterceptor = this.CGLIB$CALLBACK_0;
        if (methodInterceptor == null) {
            User$$EnhancerByCGLIB$$3668a66c.CGLIB$BIND_CALLBACKS((Object)this);
            methodInterceptor = this.CGLIB$CALLBACK_0;
        }
        if (methodInterceptor != null) {
            return methodInterceptor.intercept((Object)this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy);
        }
        return super.clone();
    }

    public static MethodProxy CGLIB$findMethodProxy(Signature signature) {
        switch (signature.toString().hashCode()) {
            case -508378822: {
                String string;
                if (!string.equals("clone()Ljava/lang/Object;")) break;
                return CGLIB$clone$4$Proxy;
            }
            case 1535311470: {
                String string;
                if (!string.equals("sayHello()V")) break;
                return CGLIB$sayHello$0$Proxy;
            }
            case 1826985398: {
                String string;
                if (!string.equals("equals(Ljava/lang/Object;)Z")) break;
                return CGLIB$equals$1$Proxy;
            }
            case 1913648695: {
                String string;
                if (!string.equals("toString()Ljava/lang/String;")) break;
                return CGLIB$toString$2$Proxy;
            }
            case 1984935277: {
                String string;
                if (!string.equals("hashCode()I")) break;
                return CGLIB$hashCode$3$Proxy;
            }
            default: {
            }
        }
        return null;
    }

    public User$$EnhancerByCGLIB$$3668a66c() {
        User$$EnhancerByCGLIB$$3668a66c user$$EnhancerByCGLIB$$3668a66c = this;
        User$$EnhancerByCGLIB$$3668a66c.CGLIB$BIND_CALLBACKS((Object)user$$EnhancerByCGLIB$$3668a66c);
    }

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

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

    private static final void CGLIB$BIND_CALLBACKS(Object object) {
        User$$EnhancerByCGLIB$$3668a66c user$$EnhancerByCGLIB$$3668a66c = (User$$EnhancerByCGLIB$$3668a66c)((Object)object);
        if (!user$$EnhancerByCGLIB$$3668a66c.CGLIB$BOUND) {
            user$$EnhancerByCGLIB$$3668a66c.CGLIB$BOUND = true;
            Object object2 = CGLIB$THREAD_CALLBACKS.get();
            if (object2 != null || (object2 = CGLIB$STATIC_CALLBACKS) != null) {
                user$$EnhancerByCGLIB$$3668a66c.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])object2)[0];
            }
        }
    }

    public Object newInstance(Callback[] arrcallback) {
        User$$EnhancerByCGLIB$$3668a66c.CGLIB$SET_THREAD_CALLBACKS(arrcallback);
        User$$EnhancerByCGLIB$$3668a66c.CGLIB$SET_THREAD_CALLBACKS(null);
        return new User$$EnhancerByCGLIB$$3668a66c();
    }

    public Object newInstance(Callback callback) {
        User$$EnhancerByCGLIB$$3668a66c.CGLIB$SET_THREAD_CALLBACKS(new Callback[]{callback});
        User$$EnhancerByCGLIB$$3668a66c.CGLIB$SET_THREAD_CALLBACKS(null);
        return new User$$EnhancerByCGLIB$$3668a66c();
    }

    /*
     * Unable to fully structure code
     * Enabled aggressive block sorting
     * Lifted jumps to return sites
     */
    public Object newInstance(Class[] var1_1, Object[] var2_2, Callback[] var3_3) {
        User$$EnhancerByCGLIB$$3668a66c.CGLIB$SET_THREAD_CALLBACKS(var3_3);
        switch (var1_1.length) {
            case 0: {
                ** break;
            }
        }
        throw new IllegalArgumentException("Constructor not found");
        // 1 sources:
        User$$EnhancerByCGLIB$$3668a66c.CGLIB$SET_THREAD_CALLBACKS(null);
        return new User$$EnhancerByCGLIB$$3668a66c();
    }

    public Callback getCallback(int n) {
        MethodInterceptor methodInterceptor;
        User$$EnhancerByCGLIB$$3668a66c.CGLIB$BIND_CALLBACKS((Object)this);
        switch (n) {
            case 0: {
                User$$EnhancerByCGLIB$$3668a66c user$$EnhancerByCGLIB$$3668a66c;
                methodInterceptor = user$$EnhancerByCGLIB$$3668a66c.CGLIB$CALLBACK_0;
                break;
            }
            default: {
                methodInterceptor = null;
            }
        }
        return methodInterceptor;
    }

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

    public Callback[] getCallbacks() {
        User$$EnhancerByCGLIB$$3668a66c.CGLIB$BIND_CALLBACKS((Object)this);
        User$$EnhancerByCGLIB$$3668a66c user$$EnhancerByCGLIB$$3668a66c = this;
        return new Callback[]{this.CGLIB$CALLBACK_0};
    }

    public void setCallbacks(Callback[] arrcallback) {
        Callback[] arrcallback2 = arrcallback;
        Callback[] arrcallback3 = arrcallback2;
        User$$EnhancerByCGLIB$$3668a66c user$$EnhancerByCGLIB$$3668a66c = this;
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)arrcallback2[0];
    }

    static {
        User$$EnhancerByCGLIB$$3668a66c.CGLIB$STATICHOOK1();
    }
}
  • 反编译代理类的FastClass
/*
 * Decompiled with CFR 0.146.
 *
 * Could not load the following classes:
 *  net.sf.cglib.core.Signature
 *  net.sf.cglib.proxy.Callback
 *  net.sf.cglib.reflect.FastClass
 */
package com.redoor.proxy.cglib;

import com.redoor.proxy.cglib.User$$EnhancerByCGLIB$$3668a66c;
import java.lang.reflect.InvocationTargetException;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.reflect.FastClass;

public class User$$EnhancerByCGLIB$$3668a66c$$FastClassByCGLIB$$cb19fc35
extends FastClass {
    public User$$EnhancerByCGLIB$$3668a66c$$FastClassByCGLIB$$cb19fc35(Class class_) {
        super(class_);
    }

    public int getIndex(Signature signature) {
        switch (signature.toString().hashCode()) {
            case -2055565910: {
                String string;
                if (!string.equals("CGLIB$SET_THREAD_CALLBACKS([Lnet/sf/cglib/proxy/Callback;)V")) break;
                return 9;
            }
            case -1882565338: {
                String string;
                if (!string.equals("CGLIB$equals$1(Ljava/lang/Object;)Z")) break;
                return 15;
            }
            case -1457535688: {
                String string;
                if (!string.equals("CGLIB$STATICHOOK1()V")) break;
                return 14;
            }
            case -1411842725: {
                String string;
                if (!string.equals("CGLIB$hashCode$3()I")) break;
                return 17;
            }
            case -894172689: {
                String string;
                if (!string.equals("newInstance(Lnet/sf/cglib/proxy/Callback;)Ljava/lang/Object;")) break;
                return 4;
            }
            case -623122092: {
                String string;
                if (!string.equals("CGLIB$findMethodProxy(Lnet/sf/cglib/core/Signature;)Lnet/sf/cglib/proxy/MethodProxy;")) break;
                return 12;
            }
            case -508378822: {
                String string;
                if (!string.equals("clone()Ljava/lang/Object;")) break;
                return 3;
            }
            case -419626537: {
                String string;
                if (!string.equals("setCallbacks([Lnet/sf/cglib/proxy/Callback;)V")) break;
                return 7;
            }
            case 291273791: {
                String string;
                if (!string.equals("CGLIB$sayHello$0()V")) break;
                return 13;
            }
            case 560567118: {
                String string;
                if (!string.equals("setCallback(ILnet/sf/cglib/proxy/Callback;)V")) break;
                return 20;
            }
            case 811063227: {
                String string;
                if (!string.equals("newInstance([Ljava/lang/Class;[Ljava/lang/Object;[Lnet/sf/cglib/proxy/Callback;)Ljava/lang/Object;")) break;
                return 6;
            }
            case 973717575: {
                String string;
                if (!string.equals("getCallbacks()[Lnet/sf/cglib/proxy/Callback;")) break;
                return 11;
            }
            case 1221173700: {
                String string;
                if (!string.equals("newInstance([Lnet/sf/cglib/proxy/Callback;)Ljava/lang/Object;")) break;
                return 5;
            }
            case 1230699260: {
                String string;
                if (!string.equals("getCallback(I)Lnet/sf/cglib/proxy/Callback;")) break;
                return 10;
            }
            case 1306468936: {
                String string;
                if (!string.equals("CGLIB$toString$2()Ljava/lang/String;")) break;
                return 16;
            }
            case 1535311470: {
                String string;
                if (!string.equals("sayHello()V")) break;
                return 19;
            }
            case 1584330438: {
                String string;
                if (!string.equals("CGLIB$SET_STATIC_CALLBACKS([Lnet/sf/cglib/proxy/Callback;)V")) break;
                return 8;
            }
            case 1800494055: {
                String string;
                if (!string.equals("CGLIB$clone$4()Ljava/lang/Object;")) break;
                return 18;
            }
            case 1826985398: {
                String string;
                if (!string.equals("equals(Ljava/lang/Object;)Z")) break;
                return 0;
            }
            case 1913648695: {
                String string;
                if (!string.equals("toString()Ljava/lang/String;")) break;
                return 1;
            }
            case 1984935277: {
                String string;
                if (!string.equals("hashCode()I")) break;
                return 2;
            }
            default: {
            }
        }
        return -1;
    }

    public int getIndex(String string, Class[] arrclass) {
        Class[] arrclass2 = arrclass;
        block0 : switch (string.hashCode()) {
            case -2012993625: {
                String string2;
                if (!string2.equals("sayHello")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 0: {
                        return 19;
                    }
                }
                break;
            }
            case -1983192202: {
                String string2;
                if (!string2.equals("CGLIB$sayHello$0")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 0: {
                        return 13;
                    }
                }
                break;
            }
            case -1776922004: {
                String string2;
                if (!string2.equals("toString")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 0: {
                        return 1;
                    }
                }
                break;
            }
            case -1295482945: {
                String string2;
                if (!string2.equals("equals")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 1: {
                        arrclass2 = arrclass2;
                        if (!arrclass2[0].getName().equals("java.lang.Object")) break block0;
                        return 0;
                    }
                }
                break;
            }
            case -1053468136: {
                String string2;
                if (!string2.equals("getCallbacks")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 0: {
                        return 11;
                    }
                }
                break;
            }
            case -124978609: {
                String string2;
                if (!string2.equals("CGLIB$equals$1")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 1: {
                        arrclass2 = arrclass2;
                        if (!arrclass2[0].getName().equals("java.lang.Object")) break block0;
                        return 15;
                    }
                }
                break;
            }
            case -60403779: {
                String string2;
                if (!string2.equals("CGLIB$SET_STATIC_CALLBACKS")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 1: {
                        arrclass2 = arrclass2;
                        if (!arrclass2[0].getName().equals("[Lnet.sf.cglib.proxy.Callback;")) break block0;
                        return 8;
                    }
                }
                break;
            }
            case -29025555: {
                String string2;
                if (!string2.equals("CGLIB$hashCode$3")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 0: {
                        return 17;
                    }
                }
                break;
            }
            case 85179481: {
                String string2;
                if (!string2.equals("CGLIB$SET_THREAD_CALLBACKS")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 1: {
                        arrclass2 = arrclass2;
                        if (!arrclass2[0].getName().equals("[Lnet.sf.cglib.proxy.Callback;")) break block0;
                        return 9;
                    }
                }
                break;
            }
            case 94756189: {
                String string2;
                if (!string2.equals("clone")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 0: {
                        return 3;
                    }
                }
                break;
            }
            case 147696667: {
                String string2;
                if (!string2.equals("hashCode")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 0: {
                        return 2;
                    }
                }
                break;
            }
            case 161998109: {
                String string2;
                if (!string2.equals("CGLIB$STATICHOOK1")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 0: {
                        return 14;
                    }
                }
                break;
            }
            case 495524492: {
                String string2;
                if (!string2.equals("setCallbacks")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 1: {
                        arrclass2 = arrclass2;
                        if (!arrclass2[0].getName().equals("[Lnet.sf.cglib.proxy.Callback;")) break block0;
                        return 7;
                    }
                }
                break;
            }
            case 1154623345: {
                String string2;
                if (!string2.equals("CGLIB$findMethodProxy")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 1: {
                        arrclass2 = arrclass2;
                        if (!arrclass2[0].getName().equals("net.sf.cglib.core.Signature")) break block0;
                        return 12;
                    }
                }
                break;
            }
            case 1543336189: {
                String string2;
                if (!string2.equals("CGLIB$toString$2")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 0: {
                        return 16;
                    }
                }
                break;
            }
            case 1811874389: {
                String string2;
                if (!string2.equals("newInstance")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 1: {
                        arrclass2 = arrclass2;
                        switch (arrclass2[0].getName().hashCode()) {
                            case -845341380: {
                                String string3;
                                if (!string3.equals("net.sf.cglib.proxy.Callback")) break block0;
                                return 4;
                            }
                            case 1730110032: {
                                String string3;
                                if (!string3.equals("[Lnet.sf.cglib.proxy.Callback;")) break block0;
                                return 5;
                            }
                            default: {
                                break;
                            }
                        }
                        break block0;
                    }
                    case 3: {
                        arrclass2 = arrclass2;
                        if (!arrclass2[0].getName().equals("[Ljava.lang.Class;")) break block0;
                        arrclass2 = arrclass2;
                        if (!arrclass2[1].getName().equals("[Ljava.lang.Object;")) break block0;
                        arrclass2 = arrclass2;
                        if (!arrclass2[2].getName().equals("[Lnet.sf.cglib.proxy.Callback;")) break block0;
                        return 6;
                    }
                }
                break;
            }
            case 1817099975: {
                String string2;
                if (!string2.equals("setCallback")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 2: {
                        arrclass2 = arrclass2;
                        if (!arrclass2[0].getName().equals("int")) break block0;
                        arrclass2 = arrclass2;
                        if (!arrclass2[1].getName().equals("net.sf.cglib.proxy.Callback")) break block0;
                        return 20;
                    }
                }
                break;
            }
            case 1905679803: {
                String string2;
                if (!string2.equals("getCallback")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 1: {
                        arrclass2 = arrclass2;
                        if (!arrclass2[0].getName().equals("int")) break block0;
                        return 10;
                    }
                }
                break;
            }
            case 1951977610: {
                String string2;
                if (!string2.equals("CGLIB$clone$4")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 0: {
                        return 18;
                    }
                }
                break;
            }
            default: {
                break;
            }
        }
        return -1;
    }

    public int getIndex(Class[] arrclass) {
        switch (arrclass.length) {
            case 0: {
                return 0;
            }
        }
        return -1;
    }

    public Object invoke(int n, Object object, Object[] arrobject) throws InvocationTargetException {
        User$$EnhancerByCGLIB$$3668a66c user$$EnhancerByCGLIB$$3668a66c = (User$$EnhancerByCGLIB$$3668a66c)((Object)object);
        try {
            switch (n) {
                case 0: {
                    return new Boolean(user$$EnhancerByCGLIB$$3668a66c.equals(arrobject[0]));
                }
                case 1: {
                    return user$$EnhancerByCGLIB$$3668a66c.toString();
                }
                case 2: {
                    return new Integer(user$$EnhancerByCGLIB$$3668a66c.hashCode());
                }
                case 3: {
                    return user$$EnhancerByCGLIB$$3668a66c.clone();
                }
                case 4: {
                    return user$$EnhancerByCGLIB$$3668a66c.newInstance((Callback)arrobject[0]);
                }
                case 5: {
                    return user$$EnhancerByCGLIB$$3668a66c.newInstance((Callback[])arrobject[0]);
                }
                case 6: {
                    return user$$EnhancerByCGLIB$$3668a66c.newInstance((Class[])arrobject[0], (Object[])arrobject[1], (Callback[])arrobject[2]);
                }
                case 7: {
                    user$$EnhancerByCGLIB$$3668a66c.setCallbacks((Callback[])arrobject[0]);
                    return null;
                }
                case 8: {
                    User$$EnhancerByCGLIB$$3668a66c.CGLIB$SET_STATIC_CALLBACKS((Callback[])arrobject[0]);
                    return null;
                }
                case 9: {
                    User$$EnhancerByCGLIB$$3668a66c.CGLIB$SET_THREAD_CALLBACKS((Callback[])arrobject[0]);
                    return null;
                }
                case 10: {
                    return user$$EnhancerByCGLIB$$3668a66c.getCallback(((Number)arrobject[0]).intValue());
                }
                case 11: {
                    return user$$EnhancerByCGLIB$$3668a66c.getCallbacks();
                }
                case 12: {
                    return User$$EnhancerByCGLIB$$3668a66c.CGLIB$findMethodProxy((Signature)arrobject[0]);
                }
                case 13: {
                    user$$EnhancerByCGLIB$$3668a66c.CGLIB$sayHello$0();
                    return null;
                }
                case 14: {
                    User$$EnhancerByCGLIB$$3668a66c.CGLIB$STATICHOOK1();
                    return null;
                }
                case 15: {
                    return new Boolean(user$$EnhancerByCGLIB$$3668a66c.CGLIB$equals$1(arrobject[0]));
                }
                case 16: {
                    return user$$EnhancerByCGLIB$$3668a66c.CGLIB$toString$2();
                }
                case 17: {
                    return new Integer(user$$EnhancerByCGLIB$$3668a66c.CGLIB$hashCode$3());
                }
                case 18: {
                    return user$$EnhancerByCGLIB$$3668a66c.CGLIB$clone$4();
                }
                case 19: {
                    user$$EnhancerByCGLIB$$3668a66c.sayHello();
                    return null;
                }
                case 20: {
                    user$$EnhancerByCGLIB$$3668a66c.setCallback(((Number)arrobject[0]).intValue(), (Callback)arrobject[1]);
                    return null;
                }
            }
        }
        catch (Throwable throwable) {
            throw new InvocationTargetException(throwable);
        }
        throw new IllegalArgumentException("Cannot find matching method/constructor");
    }

    public Object newInstance(int n, Object[] arrobject) throws InvocationTargetException {
        try {
            switch (n) {
                case 0: {
                    return new User$$EnhancerByCGLIB$$3668a66c();
                }
            }
        }
        catch (Throwable throwable) {
            throw new InvocationTargetException(throwable);
        }
        throw new IllegalArgumentException("Cannot find matching method/constructor");
    }

    public int getMaxIndex() {
        return 20;
    }
}
  • 反编译目标类的FastClass
/*
 * Decompiled with CFR 0.146.
 *
 * Could not load the following classes:
 *  com.redoor.proxy.cglib.User
 *  net.sf.cglib.core.Signature
 *  net.sf.cglib.reflect.FastClass
 */
package com.redoor.proxy.cglib;

import com.redoor.proxy.cglib.User;
import java.lang.reflect.InvocationTargetException;
import net.sf.cglib.core.Signature;
import net.sf.cglib.reflect.FastClass;

public class User$$FastClassByCGLIB$$5801fa18
extends FastClass {
    public User$$FastClassByCGLIB$$5801fa18(Class class_) {
        super(class_);
    }

    public int getIndex(Signature signature) {
        switch (signature.toString().hashCode()) {
            case 1535311470: {
                String string;
                if (!string.equals("sayHello()V")) break;
                return 0;
            }
            case 1826985398: {
                String string;
                if (!string.equals("equals(Ljava/lang/Object;)Z")) break;
                return 1;
            }
            case 1913648695: {
                String string;
                if (!string.equals("toString()Ljava/lang/String;")) break;
                return 2;
            }
            case 1984935277: {
                String string;
                if (!string.equals("hashCode()I")) break;
                return 3;
            }
            default: {
            }
        }
        return -1;
    }

    public int getIndex(String string, Class[] arrclass) {
        Class[] arrclass2 = arrclass;
        block0 : switch (string.hashCode()) {
            case -2012993625: {
                String string2;
                if (!string2.equals("sayHello")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 0: {
                        return 0;
                    }
                }
                break;
            }
            case -1776922004: {
                String string2;
                if (!string2.equals("toString")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 0: {
                        return 2;
                    }
                }
                break;
            }
            case -1295482945: {
                String string2;
                if (!string2.equals("equals")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 1: {
                        arrclass2 = arrclass2;
                        if (!arrclass2[0].getName().equals("java.lang.Object")) break block0;
                        return 1;
                    }
                }
                break;
            }
            case 147696667: {
                String string2;
                if (!string2.equals("hashCode")) break;
                arrclass2 = arrclass2;
                switch (arrclass2.length) {
                    case 0: {
                        return 3;
                    }
                }
                break;
            }
            default: {
                break;
            }
        }
        return -1;
    }

    public int getIndex(Class[] arrclass) {
        switch (arrclass.length) {
            case 0: {
                return 0;
            }
        }
        return -1;
    }

    public Object invoke(int n, Object object, Object[] arrobject) throws InvocationTargetException {
        User user = (User)object;
        try {
            switch (n) {
                case 0: {
                    user.sayHello();
                    return null;
                }
                case 1: {
                    return new Boolean(user.equals(arrobject[0]));
                }
                case 2: {
                    return user.toString();
                }
                case 3: {
                    return new Integer(user.hashCode());
                }
            }
        }
        catch (Throwable throwable) {
            throw new InvocationTargetException(throwable);
        }
        throw new IllegalArgumentException("Cannot find matching method/constructor");
    }

    public Object newInstance(int n, Object[] arrobject) throws InvocationTargetException {
        try {
            switch (n) {
                case 0: {
                    return new User();
                }
            }
        }
        catch (Throwable throwable) {
            throw new InvocationTargetException(throwable);
        }
        throw new IllegalArgumentException("Cannot find matching method/constructor");
    }

    public int getMaxIndex() {
        return 3;
    }
}

问题

cfr反编译cglib生成类时有点问题

引用

https://www.jianshu.com/p/269afd0a52e6
https://www.jianshu.com/p/269afd0a52e6
https://zhuanlan.zhihu.com/p/35144462
https://www.throwable.club/2018/12/16/cglib-dynamic-proxy-analyze/

你可能感兴趣的:(动态代理)

  • 重修设计模式-结构型-代理模式 丶白泽 重修设计模式设计模式代理模式系统安全
    重修设计模式-结构型-代理模式在不改变原始类代码的情况下，通过引入代理类来给原始类附加功能。代理模式通过创建一个代理对象，使得客户端对目标对象的访问都通过代理对象间接进行，从而可以在不修改目标对象的前提下，增加额外的功能操作，如权限控制、日志记录、事务处理等。代理模式又分为静态代理和动态代理。静态代理（StaticProxy）：在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前
  • 第 2-2 课：深入探究底层原理，应用更加得心应手 Java大联盟 案例上手Spring全家桶SpringSpringBootSpringCloudSpringMVCSpringSpringBootSpring
    前言上一讲我们学习了SpringMVC框架的使用，为了更好地理解这个框架，本讲来仿写一个SpringMVC框架，用到的技术比较简单，只需要XML解析+反射就可以完成，不需要JDK动态代理。自己手写框架的前提是必须理解框架的底层原理和运行机制，因此我们还是先来回顾一下SpringMVC的实现原理。SpringMVC实现原理SpringMVC的核心组件和工作流程的内容具体可以参考第2-1讲的内容，通过
  • 代理模式详解：静态代理与动态代理的实现 Disper_ 代理模式
    静态代理eg:我们在商店买商品，而商店的商品又来源于厂商，此时商店的作用便是代理1.定义服务接口publicinterfaceUserService{voidselect();voidupdate();}2.实现服务接口的类publicclassUserServiceImplimplementsUserService{@Overridepublicvoidselect(){System.out.p
  • Java基础 -- 05反射reflect mmlz00 Java基础Java基础反射reflectProxy动态代理
    目录引序说不通1：注解说不通2：匿名内部类说不通3：动态代理反射：反射定义强调：类对象又强调：static类静态成员再三强调：synchronized修饰符类对象：知晓类结构类结构之：内部成员内部成员--构造函数内部成员--数据成员内部成员--方法成员静态代理：动态代理：反射+注解反射+泛型+注解getGenericSuperclass()用法引序引序：开始反射概念学习之前，先来段引序。请牢记：计
  • spring如何解决bean的循环依赖 fantasyYan2 springspringjava后端
    通过三级缓存解决循环依赖问题。其中一级缓存用于存储完整的bean；二级缓存用于存储已经完成aop动态代理的bean，防止重复创建动态代理；三级缓存存储未实现aop动态代理和为实现依赖注入的bean。getBean()时先从一级缓存取，没有取二级，最后取三级。举个例子：A依赖B，B依赖A。首先创建A发现缓存中没有A，如图实例化A，然后发现A依赖B，把A放入三级缓存。开始创建B，发现B不在缓存中，实例
  • 类的加载，反射，动态代理基础 流年划破容颜_cc55
    1类的加载当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。加载：1就是指将class文件读入内存，并为之创建一个Class对象。2任何类被使用时系统都会建立一个Class对象。连接：1验证是否有正确的内部结构，并和其他类协调一致2准备负责为类的静态成员分配内存，并设置默认初始化值3解析将类的二进制数据中的符号引用替换为直接引用4初始化就
  • 2024金九银十208道Java中高级高频面试题（含答案） 2401_85125308 java开发语言
    12.什么是集合?集合和数组的区别。13.常用的集合类有哪些？它们的区别是什么？14.集合如何安全地批量删除元素?15.java怎么实现动态代理?有什么意义?16.什么是死锁?死锁产生的原因是什么?如何避免死锁？17.synchronized的作用。18.volatile关键字的作用19.线程怎么保持同步？20.什么是CAS?21.乐观锁与悲观锁?乐观锁的实现方式？22.Lock与synchron
  • AOP面向切面编程 科马 javaspringjava后端
    AOP面向切面编程如何理解面向切面编程举例理解：核心概念：SpringAOP两种配置风格基于注解的`@AspectJ`风格基于XML的Schema风格代理机制JDK动态代理CGLIB代理编程方式创建代理配置AspectJ加载时织入如何理解面向切面编程面向切面编程（Aspect-OrientedProgramming，简称AOP）是一种编程范式，它允许开发者将横切关注点（如日志记录、事务管理等）与业
  • Spring之AOP底层源码解析（上） 阿立聊代码 spring代理模式
    动态代理代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。比如，现在存在一个UserService类：public class UserService  { public void test() {  System.out.println("test..."); }}此时，我们new一个UserService对象，然后执行test()方法，结果是
  • 代理模式&桥接模式 flandersfields 设计模式
    代理模式的原理与实现：在不改变原始类（或叫被代理类）的情况下，通过引入代理类来给原始类附加功能。一般情况下，我们让代理类和原始类实现同样的接口。但是，如果原始类并没有定义接口，并且原始类代码并不是我们开发维护的。在这种情况下，我们可以通过让代理类继承原始类的方法来实现代理模式。动态代理的原理与实现：静态代理需要针对每个类都创建一个代理类，并且每个代理类中的代码都有点像模板式的“重复”代码，增加了维
  • 【Java设计模式】动态代理模式：实现无缝对象拦截 道长不会写代码 Java设计模式java设计模式代理模式
    文章目录【Java设计模式】动态代理模式：实现无缝对象拦截一、概述二、详细解释及实际示例三、Java中动态代理模式的编程示例四、何时在Java中使用动态代理模式五、动态代理模式在Java中的实际应用六、动态代理模式的优点和权衡七、源码下载【Java设计模式】动态代理模式：实现无缝对象拦截一、概述动态代理设计模式旨在提供一种灵活的代理机制，能够在运行时为各种接口动态创建代理，从而实现对对象的受控访问
  • Java反射机制详解 ๑҉ 晴天 javajava开发语言
    引言Java反射机制（Reflection）是Java语言中一个强大的工具，它允许程序在运行时检查和操作类的结构和行为。反射机制主要用于框架开发、调试工具、动态代理、以及需要在运行时动态操作对象的场景。本文将详细介绍Java反射机制的基本原理、使用方法、性能影响以及一些实际应用场景，并提供相关代码示例。什么是反射？反射指的是程序在运行时可以访问、检测和修改它自己的状态或行为。Java反射机制提供了
  • 23种设计模式之代理模式 記億揺晃着的那天 设计模式代理模式
    文章目录代理模式Spring中那些地方使用了代理模式代理的分类模版方法模式也能添加额外的功能，与代理模式有什么区别静态代理-简单实现jdk动态代理-简单实现Spring是如何实现jdk动态代理的cglib动态代理-简单实现Spring是如何实现cglib动态代理的jdk动态代理和cglib动态代理有什么区别Spring是如何选择jdk动态代理或者cglib动态代理的总结-静态代理、动态代理代理模式
  • 设计模式-代理学习（篇一） weixin_40923061 设计模式代理动态代理
    代理静态代理静态代理需求为了将业务代码与扩展逻辑分离，有利于开发仅关注业务逻辑部分。另外，模块水平扩展更方便，添加业务实例后，只要更新代理就好了。2.静态代理实现略（由于静态代理可维护性差，而且硬编码冗余代码多，一般不采用）动态代理动态代理需求静态代理需要创建代理类（实现业务接口）并实现业务接口所有方法，由代理类创建实例。通过调用代理类实例的方法去调用委托类实例的方法，但当扩展业务接口中的方法时，
  • Spring AOP中的动态代理：JDK动态代理和CGLIB动态代理 裘马轻狂大帅
    静态代理模式 所谓静态代理就是AOP框架会在编译阶段生成AOP代理类，因此也称为编译时增强。ApsectJ是静态代理的实现之一，也是最为流行的。静态代理由于在编译时就生成了代理类，效率相比动态代理要高一些。AspectJ可以单独使用，也可以和Spring结合使用。动态代理模式 与静态代理不同，动态代理就是说AOP框架不会去修改编译时生成的字节码，而是在运行时在内存中生成一个AOP代理对象，这个AO
  • day07 Spring 事务与集成 MyBatis 灰灰.X mybatisspringjava
    理解AOP是什么，为什么使用AOP，Spring与它是什么关系。AOP是一种面向切面(where,when,what)编程思想想给某些类的某些方法加功能,不用去修改其代码,只要编写配置即可,底层最终使用动态代理帮我们加功能和方法,以后在写多个方法的时候,出现相同的代码的时候,考虑使用AOP来解决spring是AOP思想之一,实际使用的时候需要添加spring-aop和aspectjweaver两个
  • Spring的AOP概念详解 刘zy_9527 springjava后端
    AOP详解：1.介绍：面向切面编程，是一种将非业务代码与业务代码进行分离的一种思想，在实际开发中,往往有许多重复操作,例如事务提交,权限验证,保存口志等功能需要在业务代码重复调用，面向切面编程,就是将非业务代码进行抽取,然后在不修改原来代码的前提下，为我们的业务代码,添加额外的功能.面向切面编程的好处就是:减少重复,专注业务；注意：面向切面编程只是面向对象编程的一种补充2.核心原理：使用动态代理的
  • jdk动态代理与cglib动态代理： 爱为斯坦 JAVAjava开发语言动态代理
    最近在用java实现redis，在使用动态代理时遇到了一点问题，即使用jdk动态代理（Invocationhandler）时，如果代理对象是一个接口的实现类，那么此时动态代理获取到的method对象是接口中的，而不是实现类的，现象是：我在实现类中对接口方法上新增了注解，但是此刻method反射获取不到注解信息，于是大概整理了一下这两者的区别JDK动态代理：获取的是接口中的方法信息，因此如果注解是在
  • Java反射机制 Dream-kid java开发语言
    前言Java反射机制是Java语言提供的一种强大功能，允许在运行时动态检查和操作类的结构。与传统编程方式不同，反射使得程序能够在编译期不确定类型和方法的情况下，对类的构造函数、方法、字段等进行操作。这种灵活性在许多高级编程场景中至关重要，尤其是在框架开发、动态代理、依赖注入、测试工具和序列化等领域。通过反射，开发者可以编写出更加通用、灵活的代码，使应用程序具备更强的动态特性。然而，反射的使用也带来
  • java实用工具类hutool 华木公子
    cn.hutoolhutool-all5.5.8Hutool工具详细教程地址:###模块介绍1.hutool-aopJDK动态代理封装，提供非IOC下的切面支持；2.hutool-bloomFilter布隆过滤，提供一些Hash算法的布隆过滤；3.hutool-cache简单缓存实现；4.hutool-core核心，包括Bean操作,日期，各种Util等等；5.hutool-cron定时任务模块，
  • springboot整合aop实现日志记录 walkerShen
    知识概况定义：在软件业，AOP为AspectOrientedProgramming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高
  • AOP大致流程 阿立聊代码 springjava开发语言AOP
    AOP大致流程AOP就是进行动态代理，在创建一个Bean的过程中，Spring在最后一步会去判断当前正在创建的这个Bean是不是需要进行AOP，如果需要则会进行动态代理。如何判断当前Bean对象需不需要进行AOP:找出所有的切面Bean遍历切面中的每个方法，看是否写了@Before、@After等注解如果写了，则判断所对应的Pointcut是否和当前Bean对象的类是否匹配如果匹配则表示当前Bea
  • MyBatis系列（二）——MyBatis的动态代理和映射文件动态配置 moutory
    前言我们在上一篇文章中讲了MyBatis的入门操作，但在入门操作篇中MyBatis在使用上还是有着一定的不便和冗余，本篇文章将对MyBatis的动态代理和如何在映射文件中编写动态sql进行讲解，希望对各位读者有所帮助。想要了解更多MyBaits系列文章，可以从下面的传送门阅读：MyBatis系列（一）——MyBatis的介绍和CRUD一、MyBatis的动态代理（一）回顾传统的实现mapper接口
  • 设计模式 - 代理模式 Shooter-s 设计模式代理模式java动态规划
    简介代理模式是软件设计模式中的一种，它提供了一个代理对象来代表另一个对象。这样做的目的是为了控制对原始对象的访问，即在不直接暴露原始对象的情况下，通过代理对象间接操作原始对象。代理模式有多种实现方式，其中最常见的是静态代理和动态代理。静态代理在静态代理中，代理类是预先定义好的，它与被代理类实现相同的接口，并且在内部持有被代理类的引用。由于代理类和被代理类需要实现相同的接口，因此如果接口有很多方法，
  • 《深度解读代理模式：静态代理与动态代理的详尽剖析》 Nonullpoint. 代理模式设计模式java
    代理模式一、引言在Java开发中，代理模式是一种非常重要的设计模式，它为其他对象提供一种代理，以控制对这个对象的访问，在访问对象和目标对象之间起到中介作用。Java中的代理按照代理类生成时机不同分为静态代理和动态代理，而动态代理又有JDK代理和CGLib代理两种。本文将详细探讨代理模式的概念、角色、静态代理与动态代理的实现以及它们的优缺点和对比。二、代理模式的角色抽象角色（Subject）：通过接
  • Java设计模式之代理模式：静态代理VS动态代理，与其他模式的对比分析和案例解析 J老熊 Java设计模式深度讲解和案例示范java设计模式代理模式面试系统架构
    一、代理模式简介代理模式（ProxyPattern）是一种结构型设计模式，它提供了一个代理对象，用来控制对另一个对象的访问。这种模式通常用于在访问对象时引入额外的功能，而不改变对象的接口。代理模式的核心思想是为其他对象提供一种代理，以控制对这个对象的访问。在现实生活中，代理模式的典型例子是房屋中介。购房者并不会直接联系房主，而是通过中介进行房屋的购买，这个中介相当于代理。二、代理模式的结构代理模式
  • Java | 实现一个 ORM 真的很简单 双鬼带单
    实现一个ORM到底多简单TableofContents实现一个ORM到底多简单原理ORM实现1.通过注解来将JavaBean和数据库字段关联2.反射工具类3.简单的model示例4.注解解析5.数据库操作6.结合反射实现查询操作使用动态代理实现@Query@Select类似功能1.动态代理2.注解3.表设计4.model5.repository7.大体流程8.代理使用9.将生成代理放入Spring
  • 对GRPC的通用封装 固安李庆海
    写在前面简介通过封装将grpc的技术使用难度降低到普通Java程序的开发。cn.com.yd.commons.grpc提供了4种形式的服务接口定义以适应不同的应用场景。cn.com.yd.commons.grpc将请求参数和响应参数定义为bytes以统一因业务不同而导致的差异性；使用cglib进行动态代理，在grpc的方法中执行具体的业务处理。在具体应用中应将此工程使用Maven打包后作为依赖引入
  • class初始化过程 南园故剑00
    1.JVM类加载机制分为五个部分：加载、验证、准备、解析、初始化加载：加载时类加载过程中的一个阶段，这个阶段会在内存中生成一个代表这个类的class对象，作为方法区这个类的各种数据的入口。这里不一定非得从一个class文件获取，这里即可以从ZIP包中获取(比如jar包和war包中读取)，也可以在运行时计算生成(动态代理)，也可以由其他文件生成(比如将jsp文件转换成对应的class类)验证：确保c
  • xposed方面的备忘录 牵手生活
    Xposed摘要验证Xposed模块自身是否被启用Java反射机制、动态代理（过滤器Filter和拦截器Interceptor）xposedAPI文档xposedAPI文档：https://api.xposed.info/reference/packages.html鸿蒙harmonyos采用太极xposed插件AndroidStudio修改代码运行没变化没生效的问题->android11(Ins
  • 项目中 枚举与注解的结合使用 飞翔的马甲 javaenumannotation
    前言：版本兼容，一直是迭代开发头疼的事，最近新版本加上了支持新题型，如果新创建一份问卷包含了新题型，那旧版本客户端就不支持，如果新创建的问卷不包含新题型，那么新旧客户端都支持。这里面我们通过给问卷类型枚举增加自定义注解的方式完成。顺便巩固下枚举与注解。 一、枚举 1.在创建枚举类的时候，该类已继承java.lang.Enum类，所以自定义枚举类无法继承别的类，但可以实现接口。
  • 【Scala十七】Scala核心十一：下划线_的用法 bit1129 scala
    下划线_在Scala中广泛应用，_的基本含义是作为占位符使用。_在使用时是出问题非常多的地方，本文将不断完善_的使用场景以及所表达的含义   1. 在高阶函数中使用 scala> val list = List(-3,8,7,9) list: List[Int] = List(-3, 8, 7, 9) scala> list.filter(_ > 7) r
  • web缓存基础：术语、http报头和缓存策略 dalan_123 Web
    对于很多人来说，去访问某一个站点，若是该站点能够提供智能化的内容缓存来提高用户体验，那么最终该站点的访问者将络绎不绝。缓存或者对之前的请求临时存储，是http协议实现中最核心的内容分发策略之一。分发路径中的组件均可以缓存内容来加速后续的请求，这是受控于对该内容所声明的缓存策略。接下来将讨web内容缓存策略的基本概念，具体包括如如何选择缓存策略以保证互联网范围内的缓存能够正确处理的您的内容，并谈论下
  • crontab 问题 周凡杨 linuxcrontabunix
      一： 0481-079   Reached   a   symbol   that   is   not   expected.   背景： */5   *   *   *   *  /usr/IBMIHS/rsync.sh 
  • 让tomcat支持2级域名共享session g21121 session
    tomcat默认情况下是不支持2级域名共享session的，所有有些情况下登陆后从主域名跳转到子域名会发生链接session不相同的情况，但是只需修改几处配置就可以了。 打开tomcat下conf下context.xml文件 找到Context标签,修改为如下内容 如果你的域名是www.test.com <Context sessionCookiePath="/path&q
  • web报表工具FineReport常用函数的用法总结（数学和三角函数） 老A不折腾 Webfinereport总结
      ABS ABS(number):返回指定数字的绝对值。绝对值是指没有正负符号的数值。 Number:需要求出绝对值的任意实数。 示例: ABS(-1.5)等于1.5。 ABS(0)等于0。 ABS(2.5)等于2.5。   ACOS ACOS(number):返回指定数值的反余弦值。反余弦值为一个角度，返回角度以弧度形式表示。 Number:需要返回角
  • linux 启动java进程 sh文件 墙头上一根草 linuxshelljar
    #!/bin/bash #初始化服务器的进程PId变量 user_pid=0; robot_pid=0; loadlort_pid=0; gateway_pid=0; ######### #检查相关服务器是否启动成功 #说明： #使用JDK自带的JPS命令及grep命令组合，准确查找pid #jps 加 l 参数，表示显示java的完整包路径 #使用awk，分割出pid
  • 我的spring学习笔记5-如何使用ApplicationContext替换BeanFactory aijuans Spring 3 系列
    如何使用ApplicationContext替换BeanFactory？ package onlyfun.caterpillar.device; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.xml.XmlBeanFactory; import
  • Linux 内存使用方法详细解析 annan211 linux内存Linux内存解析
    来源 http://blog.jobbole.com/45748/ 我是一名程序员，那么我在这里以一个程序员的角度来讲解Linux内存的使用。 一提到内存管理，我们头脑中闪出的两个概念，就是虚拟内存，与物理内存。这两个概念主要来自于linux内核的支持。 Linux在内存管理上份为两级，一级是线性区，类似于00c73000-00c88000，对应于虚拟内存，它实际上不占用
  • 数据库的单表查询常用命令及使用方法(-) 百合不是茶 oracle函数单表查询
        创建数据库;       --建表 create table bloguser(username varchar2(20),userage number(10),usersex char(2));       创建bloguser表,里面有三个字段     &nbs
  • 多线程基础知识 bijian1013 java多线程threadjava多线程
    一．进程和线程 进程就是一个在内存中独立运行的程序，有自己的地址空间。如正在运行的写字板程序就是一个进程。 “多任务”：指操作系统能同时运行多个进程（程序）。如WINDOWS系统可以同时运行写字板程序、画图程序、WORD、Eclipse等。 线程：是进程内部单一的一个顺序控制流。 线程和进程 a.       每个进程都有独立的
  • fastjson简单使用实例 bijian1013 fastjson
    一.简介         阿里巴巴fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法，把JSON Parse的性能提升到极致，是目前Java语言中最快的JSON库；包括“序列化”和“反序列化”两部分，它具备如下特征：     
  • 【RPC框架Burlap】Spring集成Burlap bit1129 spring
    Burlap和Hessian同属于codehaus的RPC调用框架，但是Burlap已经几年不更新，所以Spring在4.0里已经将Burlap的支持置为Deprecated,所以在选择RPC框架时，不应该考虑Burlap了。 这篇文章还是记录下Burlap的用法吧，主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成  
  • 【Mahout一】基于Mahout 命令参数含义 bit1129 Mahout
    1. mahout seqdirectory   $ mahout seqdirectory --input (-i) input Path to job input directory(原始文本文件). --output (-o) output The directory pathna
  • linux使用flock文件锁解决脚本重复执行问题 ronin47 linux lock　重复执行
    linux的crontab命令，可以定时执行操作，最小周期是每分钟执行一次。关于crontab实现每秒执行可参考我之前的文章《linux crontab 实现每秒执行》现在有个问题，如果设定了任务每分钟执行一次，但有可能一分钟内任务并没有执行完成，这时系统会再执行任务。导致两个相同的任务在执行。 例如： <? //  test .php
  • java-74-数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字 bylijinnan java
    public class OcuppyMoreThanHalf { /** * Q74 数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字 * two solutions: * 1.O(n) * see <beauty of coding>--每次删除两个不同的数字，不改变数组的特性 * 2.O(nlogn) * 排序。中间
  • linux 系统相关命令 candiio linux
    系统参数 cat /proc/cpuinfo  cpu相关参数 cat /proc/meminfo 内存相关参数 cat /proc/loadavg 负载情况 性能参数 1）top M：按内存使用排序 P：按CPU占用排序 1：显示各CPU的使用情况 k：kill进程 o：更多排序规则 回车：刷新数据 2）ulimit ulimit -a：显示本用户的系统限制参
  • [经营与资产]保持独立性和稳定性对于软件开发的重要意义 comsci 软件开发
         一个软件的架构从诞生到成熟，中间要经过很多次的修正和改造       如果在这个过程中，外界的其它行业的资本不断的介入这种软件架构的升级过程中           那么软件开发者原有的设计思想和开发路线
  • 在CentOS5.5上编译OpenJDK6 Cwind linuxOpenJDK
    几番周折终于在自己的CentOS5.5上编译成功了OpenJDK6，将编译过程和遇到的问题作一简要记录，备查。 0. OpenJDK介绍 OpenJDK是Sun（现Oracle）公司发布的基于GPL许可的Java平台的实现。其优点： 1、它的核心代码与同时期Sun（-> Oracle）的产品版基本上是一样的，血统纯正，不用担心性能问题，也基本上没什么兼容性问题；（代码上最主要的差异是
  • java乱码问题 dashuaifu java乱码问题js中文乱码
    swfupload上传文件参数值为中文传递到后台接收中文乱码     在js中用setPostParams（{"tag" : encodeURI( document.getElementByIdx_x("filetag").value，"utf-8")}）; 然后在servlet中String t
  • cygwin很多命令显示command not found的解决办法 dcj3sjt126com cygwin
    cygwin很多命令显示command not found的解决办法   修改cygwin.BAT文件如下 @echo off D: set CYGWIN=tty notitle glob set PATH=%PATH%;d:\cygwin\bin;d:\cygwin\sbin;d:\cygwin\usr\bin;d:\cygwin\usr\sbin;d:\cygwin\us
  • [介绍]从 Yii 1.1 升级 dcj3sjt126com PHPyii2
    2.0 版框架是完全重写的，在 1.1 和 2.0 两个版本之间存在相当多差异。因此从 1.1 版升级并不像小版本间的跨越那么简单，通过本指南你将会了解两个版本间主要的不同之处。 如果你之前没有用过 Yii 1.1，可以跳过本章，直接从"入门篇"开始读起。 请注意，Yii 2.0 引入了很多本章并没有涉及到的新功能。强烈建议你通读整部权威指南来了解所有新特性。这样有可能会发
  • Linux SSH免登录配置总结 eksliang ssh-keygenLinux SSH免登录认证Linux SSH互信
    转载请出自出处：http://eksliang.iteye.com/blog/2187265 一、原理      我们使用ssh-keygen在ServerA上生成私钥跟公钥，将生成的公钥拷贝到远程机器ServerB上后,就可以使用ssh命令无需密码登录到另外一台机器ServerB上。      生成公钥与私钥有两种加密方式，第一种是
  • 手势滑动销毁Activity gundumw100 android
    老是效仿ios，做android的真悲催！ 有需求：需要手势滑动销毁一个Activity 怎么办尼？自己写？ 不用~，网上先问一下百度。 结果： http://blog.csdn.net/xiaanming/article/details/20934541 首先将你需要的Activity继承SwipeBackActivity，它会在你的布局根目录新增一层SwipeBackLay
  • JavaScript变换表格边框颜色 ini JavaScripthtmlWebhtml5css
    效果查看：http://hovertree.com/texiao/js/2.htm代码如下，保存到HTML文件也可以查看效果： <html> <head> <meta charset="utf-8"> <title>表格边框变换颜色代码-何问起</title> </head> <body&
  • Kafka Rest : Confluent kane_xie kafkaRESTconfluent
    最近拿到一个kafka rest的需求，但kafka暂时还没有提供rest api（应该是有在开发中，毕竟rest这么火），上网搜了一下，找到一个Confluent Platform，本文简单介绍一下安装。 这里插一句，给大家推荐一个九尾搜索，原名叫谷粉SOSO，不想fanqiang谷歌的可以用这个。以前在外企用谷歌用习惯了，出来之后用度娘搜技术问题，那匹配度简直感人。 环境声明：Ubu
  • Calender不是单例 men4661273 单例Calender
             在我们使用Calender的时候，使用过Calendar.getInstance()来获取一个日期类的对象，这种方式跟单例的获取方式一样，那么它到底是不是单例呢，如果是单例的话，一个对象修改内容之后，另外一个线程中的数据不久乱套了吗？从试验以及源码中可以得出，Calendar不是单例。 测试： Calendar c1 =
  • 线程内存和主内存之间联系 qifeifei java thread
    1， java多线程共享主内存中变量的时候，一共会经过几个阶段，    lock:将主内存中的变量锁定，为一个线程所独占。   unclock:将lock加的锁定解除，此时其它的线程可以有机会访问此变量。   read:将主内存中的变量值读到工作内存当中。   load:将read读取的值保存到工作内存中的变量副本中。  
  • schedule和scheduleAtFixedRate tangqi609567707 javatimerschedule
    原文地址：http://blog.csdn.net/weidan1121/article/details/527307 import java.util.Timer;import java.util.TimerTask;import java.util.Date; /** * @author vincent */public class TimerTest {  
  • erlang 部署 wudixiaotie erlang
    1.如果在启动节点的时候报这个错 ： {"init terminating in do_boot",{'cannot load',elf_format,get_files}} 则需要在reltool.config中加入 {app, hipe, [{incl_cond, exclude}]},     2.当generate时，遇到： ERROR
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他