ls_cherish
ls_cherish

静态、动态代理和AOP详解（此坑未填）

静态代理（简单描述）

先定义一个接口，里面定义目标方法

//目标类要实现的接口
public interface ITarget {
    
    //目标方法
    void doFunc(String words);
}

定义一个代理类

public class StaticProxy implements ITarget{
    
    private ITarget target = null;
    
    //关联要增强的目标类
    public StaticProxy(ITarget target){
        this.target = target;
    }
 
    //在这里增强目标类的目标方法
    @Override
    public void doFunc() {
        ...
        ...
        ...
        //增强目标方法
        target.doFunc();
        ...
        ...
        ...
    }
}

以后，任意的一个ITarget接口的子类，都可以注入给StaticProxy类，然后实现一套增强，不再赘述。

动态代理

代理类在程序运行时创建的代理方式被成为 动态代理。也就是说，这种情况下，代理类并不是像静态代理一样，是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。

动态代理是spring AOP的实现原理，spring有两种动态代理模式，cglib和jdk，我们先来将java jdk的动态代理。

jdk的动态代理

首先，我们需要知道，jdk的动态代理只能代理实现了接口的类 没有实现接口的类不能实现JDK动态代理。其次，我们还要了解一个重要的中介接口InvocationHandler，这是jdk的动态代理的基石，它的定义如下：

public interface InvocationHandler {

    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

我们先来写一个jdk的动态代理实例，再来讨论其中的原理吧

jdk动态代理实例

我们先来定义一个目标类，或者说委托类，或者又叫被代理类，它实现了我们上面定义的那个接口ITarget：

public class Entrust implements ITarget {
    public void doFunc(String words){
        System.out.println(words);
    }
}

再定义一个中介类，实现InvocationHandler接口，这个中介类，持有被代理的对象，在invoke中利用反射，调用目标类的方法：

public class JdkDynamicProxyHandler  implements InvocationHandler {
    //invocationHandler持有的被代理对象
    T target;

    public JdkDynamicProxyHandler(T target) {
        this.target = target;
    }
    /**
     * proxy:代表动态代理对象
     * method：代表正在执行的方法
     * args：代表调用目标方法时传入的实参
     * 
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("do before");
        Object result = method.invoke(target, args);
        System.out.println("do after");
        return result;
    }
}

好了，我们现在来写一个代理demo：

public static void main(String[] a){
        //创建一个实例对象，这个对象是被代理的对象
        ITarget attorney = new Attorney();

        //创建一个与代理对象相关联的InvocationHandler
        InvocationHandler jdkDynamicProxyHandler = new JdkDynamicProxyHandler(attorney);

        //创建一个代理对象proxy来代理attorney，代理对象的每个执行方法都会替换执行Invocation中的invoke方法
        ITarget proxy = (ITarget) Proxy.newProxyInstance(ITarget.class.getClassLoader(), new Class[]{ITarget.class}, jdkDynamicProxyHandler);

        //代理执行上交班费的方法
        proxy.doFunc("hello word");

        //将生成的代理类写到桌面
        writeProxyClassToHardDisk("/home/ls/Desktop/$Proxy22.class");
    }

    public static void writeProxyClassToHardDisk(String path) {
        byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy22", Attorney.class.getInterfaces());
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(path);
            out.write(classFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

最后输出：

clipboard.png

原理剖析

我们来看看Proxy.newProxyInstance方法

public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            //验证一些参数
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         * 从缓存里面获取某个类的代理类，如果该类的代理类不存在，就根据该类的类型创建一个
         * 如果要深挖逻辑，可以看看ProxyClassFactory的apply方法。
         * 其实生成代理类字节码文件的工作是通过 ProxyGenerate类中的generateProxyClass方法来完成的。
         */
        Class cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         *
         * /** parameter types of a proxy class constructor */
         * private static final Class[] constructorParams = { InvocationHandler.class };
         * 
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //看上面的注释，constructorParams={ InvocationHandler.class }，
            //这是在生成代理类的构造函数,获得一个参数为InvocationHandler的构造方法
            final Constructor cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            //这行代码的意思是将h,也就是实现InvocationHandler的实现类，
            //我们传入的是jdkDynamicProxyHandler，注入到cons中。
            //然后newInstance生成一个已经组装过参数的代理类。
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

我们最应该关注的是 Class cl = getProxyClass0(loader, intfs);这句，这里产生了代理类，后面代码中的构造器也是通过这里产生的类来获得，可以看出，这个类的产生就是整个动态代理的关键，由于是动态生成的类文件，我这里不具体进入分析如何产生的这个类文件，只需要知道这个类文件时缓存在java虚拟机中的。

我们对这个代理类进行反编译：（本次使用http://www.javadecompilers.co...）

import java.lang.reflect.UndeclaredThrowableException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import aopLearn.ITarget;
import java.lang.reflect.Proxy;

// 
// Decompiled by Procyon v0.5.30
// 

public final class $Proxy22 extends Proxy implements ITarget
{
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;
    /**
      *注意这里是生成代理类的构造方法，方法参数为InvocationHandler类型，看到这，是不是就有点明白了
      *为何代理对象调用方法都是执行InvocationHandler中的invoke方法，而InvocationHandler又持有一个
      *被代理对象的实例
      *
      *super(paramInvocationHandler)，是调用父类Proxy的构造方法。
      *父类持有：protected InvocationHandler h;
      *Proxy构造方法：
      *    protected Proxy(InvocationHandler h) {
      *         Objects.requireNonNull(h);
      *         this.h = h;
      *     }
      *
      */
    public $Proxy22(final InvocationHandler invocationHandler) {
        super(invocationHandler);
    }
    
    //这个静态块本来是在最后的，我把它拿到前面来，方便描述
    static {
        try {
            //doFunc通过反射得到的名字m3
            $Proxy22.m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            $Proxy22.m3 = Class.forName("aopLearn.ITarget").getMethod("doFunc", Class.forName("java.lang.String"));
            $Proxy22.m2 = Class.forName("java.lang.Object").getMethod("toString", (Class[])new Class[0]);
            $Proxy22.m0 = Class.forName("java.lang.Object").getMethod("hashCode", (Class[])new Class[0]);
        }
        catch (NoSuchMethodException ex) {
            throw new NoSuchMethodError(ex.getMessage());
        }
        catch (ClassNotFoundException ex2) {
            throw new NoClassDefFoundError(ex2.getMessage());
        }
    }
    
    public final boolean equals(final Object o) {
        try {
            return (boolean)super.h.invoke(this, $Proxy22.m1, new Object[] { o });
        }
        catch (Error | RuntimeException error) {
            throw;
        }
        catch (Throwable t) {
            throw new UndeclaredThrowableException(t);
        }
    }
    /**
      * 
      *这里调用代理对象的doFunc方法，直接就调用了InvocationHandler中的invoke方法，并把m3传了进去。
      *this.h.invoke(this, m3, null);这里简单，明了。
      *代理对象持有一个InvocationHandler对象，InvocationHandler对象持有一个被代理的对象，
      *再联系到InvacationHandler中的invoke方法。其实就是代理对象调用InvocationHandler，
      * InvocationHandler对象反射调用委托类对象。
      */
    public final void doFunc(final String s) {
        try {
            super.h.invoke(this, $Proxy22.m3, new Object[] { s });
        }
        catch (Error | RuntimeException error) {
            throw;
        }
        catch (Throwable t) {
            throw new UndeclaredThrowableException(t);
        }
    }
    
    public final String toString() {
        try {
            return (String)super.h.invoke(this, $Proxy22.m2, null);
        }
        catch (Error | RuntimeException error) {
            throw;
        }
        catch (Throwable t) {
            throw new UndeclaredThrowableException(t);
        }
    }
    
    public final int hashCode() {
        try {
            return (int)super.h.invoke(this, $Proxy22.m0, null);
        }
        catch (Error | RuntimeException error) {
            throw;
        }
        catch (Throwable t) {
            throw new UndeclaredThrowableException(t);
        }
    }
    
}

看完了这些，我们来想一下，为什么jdk的动态代理，一定要委托类实现一个接口？这是因为我们可以看到，我们生成的代理类Proxy22 extends Proxy implements ITarget，已经继承了Proxy类，而java中不能多继承，为了让$Proxy22和委托类建立联系，只能实现一个接口。这里的建立联系，是指通过接口，得到委托类方法的反射等，并且，委托类实现自接口的方法，才能被增强。

故而，本质上来说，jdk的动态代理，是为接口产生代理。

在spring AOP中，我们使用jdk动态代理时当然也要定义InvocationHandler的实现类对象，spring中的是org.springframework.aop.framework.JdkDynamicAopProxy类。

cglib的动态代理

cglib的动态代理针对类来实现代理,对指定目标产生一个子类 通过方法拦截技术拦截所有父类方法的调用。我们要使用cglib代理必须引入cglib的jar包。

cglib动态代理实例

同样，定义一个跟上面例子一样的委托类。

public class Entrust {
    public void doFunc(String words){
        System.out.println(words);
    }
}

实现MethodInterceptor接口生成方法拦截器

public class EntrustInterceptor implements MethodInterceptor{

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("before");
        Object o = proxy.invokeSuper(obj,args);
        System.out.println("after");
        return o;
    }
}

实例如下：

public static void main(String[] a){
    //cglib自带的debug工具，可以将代理类输出到指定路径
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/home/ls/Desktop/cglib");
    Enhancer enhancer = new Enhancer();
    //继承被代理类
    enhancer.setSuperclass(Entrust.class);
    enhancer.setCallback(new EntrustInterceptor());
    //生成的代理类对象
    Entrust entrust = (Entrust) enhancer.create();
    //在调用我们代理类中的方法时会被我们实现的方法拦截器拦截
    entrust.doFunc("hello word");
}

输出结果如下：
clipboard.png

原理剖析

CGLIB会让生成的代理类继承被代理类，并在代理类中对代理方法进行强化处理(前置处理、后置处理等)。在CGLIB底层，其实是借助了ASM这个非常强大的Java字节码生成框架。

我们看到，代理类对象是由Enhancer类创建的。Enhancer是CGLIB的字节码增强器，可以很方便的对类进行拓展，创建代理对象的几个步骤:

  1. 生成代理类的二进制字节码文件；
  2. 加载二进制字节码，生成Class对象( 例如使用Class.forName()方法 )；
  3. 通过反射机制获得实例构造，并创建代理类对象

我们来看看将代理类Class文件反编译之后的Java代码，一个动态代理，产生了三个类：

clipboard.png

主要的代理类是

Entrust$$EnhancerByCGLIB$$832e20ab

// 
// Decompiled by Procyon v0.5.30
// 

package com.lufax.util.aopCache.cglibProxy;

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


/**
 * 生成的代理类Entrust$$EnhancerByCGLIB$$832e20ab继承被代理类Entrust。
 * 在这里我们需要注意一点：如果委托类被final修饰，那么它不可被继承，即不可被代理；
 * 同样，如果委托类中存在final修饰的方法，那么该方法也不可被代理；
 * 
 */
public class Entrust$$EnhancerByCGLIB$$832e20ab extends Entrust implements Factory
{
    private boolean CGLIB$BOUND;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static final Method CGLIB$doFunc$0$Method;
    private static final MethodProxy CGLIB$doFunc$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$finalize$1$Method;
    private static final MethodProxy CGLIB$finalize$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;
    
    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        final Class forName = Class.forName("com.lufax.util.aopCache.cglibProxy.Entrust$$EnhancerByCGLIB$$832e20ab");
        final Class forName2;
        final Method[] methods = ReflectUtils.findMethods(new String[] { "finalize", "()V", "equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;" }, (forName2 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$finalize$1$Method = methods[0];
        CGLIB$finalize$1$Proxy = MethodProxy.create((Class)forName2, (Class)forName, "()V", "finalize", "CGLIB$finalize$1");
        CGLIB$equals$2$Method = methods[1];
        CGLIB$equals$2$Proxy = MethodProxy.create((Class)forName2, (Class)forName, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");
        CGLIB$toString$3$Method = methods[2];
        CGLIB$toString$3$Proxy = MethodProxy.create((Class)forName2, (Class)forName, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");
        CGLIB$hashCode$4$Method = methods[3];
        CGLIB$hashCode$4$Proxy = MethodProxy.create((Class)forName2, (Class)forName, "()I", "hashCode", "CGLIB$hashCode$4");
        CGLIB$clone$5$Method = methods[4];
        CGLIB$clone$5$Proxy = MethodProxy.create((Class)forName2, (Class)forName, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
        final Class forName3;
        CGLIB$doFunc$0$Method = ReflectUtils.findMethods(new String[] { "doFunc", "(Ljava/lang/String;)V" }, (forName3 = Class.forName("com.lufax.util.aopCache.cglibProxy.Entrust")).getDeclaredMethods())[0];
        CGLIB$doFunc$0$Proxy = MethodProxy.create((Class)forName3, (Class)forName, "(Ljava/lang/String;)V", "doFunc", "CGLIB$doFunc$0");
    }
    //代理类会为委托方法生成两个方法，一个是重写的doFunc方法，
    //另一个是CGLIB$doFunc$0方法，我们可以看到它是直接调用父类的doFunc方法；
    
    final void CGLIB$doFunc$0(final String s) {
        super.doFunc(s);
    }
    //当执行代理对象的doFunc方法时，会首先判断一下是否存在实现了MethodInterceptor接口的CGLIB$CALLBACK_0;
    //如果存在，则将调用MethodInterceptor中的intercept方法，如图2.1。
    public final void doFunc(final String s) {
        MethodInterceptor cglib$CALLBACK_2;
        MethodInterceptor cglib$CALLBACK_0;
        if ((cglib$CALLBACK_0 = (cglib$CALLBACK_2 = this.CGLIB$CALLBACK_0)) == null) {
            CGLIB$BIND_CALLBACKS(this);
            cglib$CALLBACK_2 = (cglib$CALLBACK_0 = this.CGLIB$CALLBACK_0);
        }
        if (cglib$CALLBACK_0 != null) {
            //这里开始调用我们定义的EntrustInterceptor中的intercept方法。
            //参数1、代理对象；2、委托类方法；3、方法参数；4、代理方法的MethodProxy对象（注意这个对象）。
            cglib$CALLBACK_2.intercept((Object)this, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$doFunc$0$Method, new Object[] { s }, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$doFunc$0$Proxy);
            return;
        }
        super.doFunc(s);
    }
    
    final void CGLIB$finalize$1() throws Throwable {
        super.finalize();
    }
    
    protected final void finalize() throws Throwable {
        MethodInterceptor cglib$CALLBACK_2;
        MethodInterceptor cglib$CALLBACK_0;
        if ((cglib$CALLBACK_0 = (cglib$CALLBACK_2 = this.CGLIB$CALLBACK_0)) == null) {
            CGLIB$BIND_CALLBACKS(this);
            cglib$CALLBACK_2 = (cglib$CALLBACK_0 = this.CGLIB$CALLBACK_0);
        }
        if (cglib$CALLBACK_0 != null) {
            cglib$CALLBACK_2.intercept((Object)this, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$finalize$1$Method, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$emptyArgs, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$finalize$1$Proxy);
            return;
        }
        super.finalize();
    }
    
    final boolean CGLIB$equals$2(final Object o) {
        return super.equals(o);
    }
    
    public final boolean equals(final Object o) {
        MethodInterceptor cglib$CALLBACK_2;
        MethodInterceptor cglib$CALLBACK_0;
        if ((cglib$CALLBACK_0 = (cglib$CALLBACK_2 = this.CGLIB$CALLBACK_0)) == null) {
            CGLIB$BIND_CALLBACKS(this);
            cglib$CALLBACK_2 = (cglib$CALLBACK_0 = this.CGLIB$CALLBACK_0);
        }
        if (cglib$CALLBACK_0 != null) {
            final Object intercept = cglib$CALLBACK_2.intercept((Object)this, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$equals$2$Method, new Object[] { o }, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$equals$2$Proxy);
            return intercept != null && (boolean)intercept;
        }
        return super.equals(o);
    }
    
    final String CGLIB$toString$3() {
        return super.toString();
    }
    
    public final String toString() {
        MethodInterceptor cglib$CALLBACK_2;
        MethodInterceptor cglib$CALLBACK_0;
        if ((cglib$CALLBACK_0 = (cglib$CALLBACK_2 = this.CGLIB$CALLBACK_0)) == null) {
            CGLIB$BIND_CALLBACKS(this);
            cglib$CALLBACK_2 = (cglib$CALLBACK_0 = this.CGLIB$CALLBACK_0);
        }
        if (cglib$CALLBACK_0 != null) {
            return (String)cglib$CALLBACK_2.intercept((Object)this, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$toString$3$Method, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$emptyArgs, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$toString$3$Proxy);
        }
        return super.toString();
    }
    
    final int CGLIB$hashCode$4() {
        return super.hashCode();
    }
    
    public final int hashCode() {
        MethodInterceptor cglib$CALLBACK_2;
        MethodInterceptor cglib$CALLBACK_0;
        if ((cglib$CALLBACK_0 = (cglib$CALLBACK_2 = this.CGLIB$CALLBACK_0)) == null) {
            CGLIB$BIND_CALLBACKS(this);
            cglib$CALLBACK_2 = (cglib$CALLBACK_0 = this.CGLIB$CALLBACK_0);
        }
        if (cglib$CALLBACK_0 != null) {
            final Object intercept = cglib$CALLBACK_2.intercept((Object)this, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$hashCode$4$Method, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$emptyArgs, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$hashCode$4$Proxy);
            return (intercept == null) ? 0 : ((Number)intercept).intValue();
        }
        return super.hashCode();
    }
    
    final Object CGLIB$clone$5() throws CloneNotSupportedException {
        return super.clone();
    }
    
    protected final Object clone() throws CloneNotSupportedException {
        MethodInterceptor cglib$CALLBACK_2;
        MethodInterceptor cglib$CALLBACK_0;
        if ((cglib$CALLBACK_0 = (cglib$CALLBACK_2 = this.CGLIB$CALLBACK_0)) == null) {
            CGLIB$BIND_CALLBACKS(this);
            cglib$CALLBACK_2 = (cglib$CALLBACK_0 = this.CGLIB$CALLBACK_0);
        }
        if (cglib$CALLBACK_0 != null) {
            return cglib$CALLBACK_2.intercept((Object)this, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$clone$5$Method, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$emptyArgs, Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$clone$5$Proxy);
        }
        return super.clone();
    }
    
    public static MethodProxy CGLIB$findMethodProxy(final Signature signature) {
        final String string = signature.toString();
        switch (string.hashCode()) {
            case -1574182249: {
                if (string.equals("finalize()V")) {
                    return Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$finalize$1$Proxy;
                }
                break;
            }
            case -508378822: {
                if (string.equals("clone()Ljava/lang/Object;")) {
                    return Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$clone$5$Proxy;
                }
                break;
            }
            case 346793840: {
                if (string.equals("doFunc(Ljava/lang/String;)V")) {
                    return Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$doFunc$0$Proxy;
                }
                break;
            }
            case 1826985398: {
                if (string.equals("equals(Ljava/lang/Object;)Z")) {
                    return Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$equals$2$Proxy;
                }
                break;
            }
            case 1913648695: {
                if (string.equals("toString()Ljava/lang/String;")) {
                    return Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$toString$3$Proxy;
                }
                break;
            }
            case 1984935277: {
                if (string.equals("hashCode()I")) {
                    return Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$hashCode$4$Proxy;
                }
                break;
            }
        }
        return null;
    }
    
    public Entrust$$EnhancerByCGLIB$$832e20ab() {
        CGLIB$BIND_CALLBACKS(this);
    }
    
    public static void CGLIB$SET_THREAD_CALLBACKS(final Callback[] array) {
        Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$THREAD_CALLBACKS.set(array);
    }
    
    public static void CGLIB$SET_STATIC_CALLBACKS(final Callback[] cglib$STATIC_CALLBACKS) {
        CGLIB$STATIC_CALLBACKS = cglib$STATIC_CALLBACKS;
    }
    
    private static final void CGLIB$BIND_CALLBACKS(final Object o) {
        final Entrust$$EnhancerByCGLIB$$832e20ab entrust$$EnhancerByCGLIB$$832e20ab = (Entrust$$EnhancerByCGLIB$$832e20ab)o;
        if (!entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$BOUND) {
            entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$BOUND = true;
            Object o2;
            if ((o2 = Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$THREAD_CALLBACKS.get()) != null || (o2 = Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$STATIC_CALLBACKS) != null) {
                entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])o2)[0];
            }
        }
    }
    
    public Object newInstance(final Callback[] array) {
        CGLIB$SET_THREAD_CALLBACKS(array);
        final Entrust$$EnhancerByCGLIB$$832e20ab entrust$$EnhancerByCGLIB$$832e20ab = new Entrust$$EnhancerByCGLIB$$832e20ab();
        CGLIB$SET_THREAD_CALLBACKS(null);
        return entrust$$EnhancerByCGLIB$$832e20ab;
    }
    
    public Object newInstance(final Callback callback) {
        CGLIB$SET_THREAD_CALLBACKS(new Callback[] { callback });
        final Entrust$$EnhancerByCGLIB$$832e20ab entrust$$EnhancerByCGLIB$$832e20ab = new Entrust$$EnhancerByCGLIB$$832e20ab();
        CGLIB$SET_THREAD_CALLBACKS(null);
        return entrust$$EnhancerByCGLIB$$832e20ab;
    }
    
    public Object newInstance(final Class[] array, final Object[] array2, final Callback[] array3) {
        CGLIB$SET_THREAD_CALLBACKS(array3);
        switch (array.length) {
            case 0: {
                final Entrust$$EnhancerByCGLIB$$832e20ab entrust$$EnhancerByCGLIB$$832e20ab = new Entrust$$EnhancerByCGLIB$$832e20ab();
                CGLIB$SET_THREAD_CALLBACKS(null);
                return entrust$$EnhancerByCGLIB$$832e20ab;
            }
            default: {
                throw new IllegalArgumentException("Constructor not found");
            }
        }
    }
    
    public Callback getCallback(final int n) {
        CGLIB$BIND_CALLBACKS(this);
        Object cglib$CALLBACK_0 = null;
        switch (n) {
            case 0: {
                cglib$CALLBACK_0 = this.CGLIB$CALLBACK_0;
                break;
            }
            default: {
                cglib$CALLBACK_0 = null;
                break;
            }
        }
        return (Callback)cglib$CALLBACK_0;
    }
    
    public void setCallback(final int n, final Callback callback) {
        switch (n) {
            case 0: {
                this.CGLIB$CALLBACK_0 = (MethodInterceptor)callback;
                break;
            }
        }
    }
    
    public Callback[] getCallbacks() {
        CGLIB$BIND_CALLBACKS(this);
        return new Callback[] { this.CGLIB$CALLBACK_0 };
    }
    
    public void setCallbacks(final Callback[] array) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)array[0];
    }
    
    static {
        CGLIB$STATICHOOK1();
    }
}

逻辑进入到我们在EntrustInterceptor 中定义的intercept方法


    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("before");
        Object o = proxy.invokeSuper(obj,args);
        System.out.println("after");
        return o;
    }

我们看看MethodProxy的invokeSuper方法：

/**
     * Invoke the original (super) method on the specified object.
     * @param obj the enhanced object, must be the object passed as the first
     * argument to the MethodInterceptor
     * @param args the arguments passed to the intercepted method; you may substitute a different
     * argument array as long as the types are compatible
     * @see MethodInterceptor#intercept
     * @throws Throwable the bare exceptions thrown by the called method are passed through
     * without wrapping in an InvocationTargetException
     */
    public Object invokeSuper(Object obj, Object[] args) throws Throwable {
        try {
            init();
            FastClassInfo fci = fastClassInfo;
            //f2是由CGlib生成的,在输出的class中有这个类。
            //它就是Entrust$$EnhancerByCGLIB$$832e20ab$$FastClassByCGLIB$$817a77c.class
            return fci.f2.invoke(fci.i2, obj, args);
        } catch (InvocationTargetException e) {
            throw e.getTargetException();
        }
    }

我们把

Entrust$$EnhancerByCGLIB$$832e20ab$$FastClassByCGLIB$$817a77c.class

也反编译出来，然后贴出invoke方法,注意case14调用了

entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$doFunc$0((String)array[0]);：

public Object invoke(final int n, final Object o, final Object[] array) throws InvocationTargetException {
        final Entrust$$EnhancerByCGLIB$$832e20ab entrust$$EnhancerByCGLIB$$832e20ab = (Entrust$$EnhancerByCGLIB$$832e20ab)o;
        try {
            switch (n) {
                case 0: {
                    entrust$$EnhancerByCGLIB$$832e20ab.setCallbacks((Callback[])array[0]);
                    return null;
                }
                case 1: {
                    Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$SET_STATIC_CALLBACKS((Callback[])array[0]);
                    return null;
                }
                case 2: {
                    Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$SET_THREAD_CALLBACKS((Callback[])array[0]);
                    return null;
                }
                case 3: {
                    return entrust$$EnhancerByCGLIB$$832e20ab.getCallback(((Number)array[0]).intValue());
                }
                case 4: {
                    return entrust$$EnhancerByCGLIB$$832e20ab.getCallbacks();
                }
                case 5: {
                    entrust$$EnhancerByCGLIB$$832e20ab.doFunc((String)array[0]);
                    return null;
                }
                case 6: {
                    entrust$$EnhancerByCGLIB$$832e20ab.setCallback(((Number)array[0]).intValue(), (Callback)array[1]);
                    return null;
                }
                case 7: {
                    return Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$findMethodProxy((Signature)array[0]);
                }
                case 8: {
                    Entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$STATICHOOK1();
                    return null;
                }
                case 9: {
                    entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$finalize$1();
                    return null;
                }
                case 10: {
                    return entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$toString$3();
                }
                case 11: {
                    return new Integer(entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$hashCode$4());
                }
                case 12: {
                    return entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$clone$5();
                }
                case 13: {
                    return new Boolean(entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$equals$2(array[0]));
                }
                case 14: {
                    entrust$$EnhancerByCGLIB$$832e20ab.CGLIB$doFunc$0((String)array[0]);
                    return null;
                }
                case 15: {
                    return new Boolean(entrust$$EnhancerByCGLIB$$832e20ab.equals(array[0]));
                }
                case 16: {
                    return entrust$$EnhancerByCGLIB$$832e20ab.toString();
                }
                case 17: {
                    return new Integer(entrust$$EnhancerByCGLIB$$832e20ab.hashCode());
                }
                case 18: {
                    return entrust$$EnhancerByCGLIB$$832e20ab.newInstance((Callback)array[0]);
                }
                case 19: {
                    return entrust$$EnhancerByCGLIB$$832e20ab.newInstance((Class[])array[0], (Object[])array[1], (Callback[])array[2]);
                }
                case 20: {
                    return entrust$$EnhancerByCGLIB$$832e20ab.newInstance((Callback[])array[0]);
                }
                case 21: {
                    Entrust.main((String[])array[0]);
                    return null;
                }
                case 22: {
                    entrust$$EnhancerByCGLIB$$832e20ab.wait(((Number)array[0]).longValue(), ((Number)array[1]).intValue());
                    return null;
                }
                case 23: {
                    entrust$$EnhancerByCGLIB$$832e20ab.wait(((Number)array[0]).longValue());
                    return null;
                }
                case 24: {
                    entrust$$EnhancerByCGLIB$$832e20ab.wait();
                    return null;
                }
                case 25: {
                    return entrust$$EnhancerByCGLIB$$832e20ab.getClass();
                }
                case 26: {
                    entrust$$EnhancerByCGLIB$$832e20ab.notify();
                    return null;
                }
                case 27: {
                    entrust$$EnhancerByCGLIB$$832e20ab.notifyAll();
                    return null;
                }
            }
        }
        catch (Throwable t) {
            throw new InvocationTargetException(t);
        }
        throw new IllegalArgumentException("Cannot find matching method/constructor");
    }

事实证明，最后确实是进入了case14，调用了代理类的代理doFunc方法，最后再回到EntrustInterceptor.invoke中。完成逻辑

Spring AOP

未完待续

你可能感兴趣的:(代理模式,动态代理,aop)

  • Nginx之代理模块 ngx_http_proxy_module 途径日暮不赏丶 nginxnginx
    正向代理正向代理是指位于客户机（A）和站点服务器（B）之间的代理服务器（C），为了从站点服务器（B）获取资源，客户机（A）向代理服务器（C）发送请求并指定站点服务器（B），然后代理服务器（C）向站点服务器（B）转交请求并将获取的资源返回给客户机（A）。上述这样的代理模式称为正向代理，正向代理最大的特点：客户端非常明确要访问的服务器地址；服务器只清楚请求来自哪个代理服务器，而不清楚来自哪个具体的客户
  • 设计模式 23 访问者模式 WineMonk #设计模式设计模式访问者模式
    设计模式23创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式文章目录设计模式23访问者模式（VisitorPattern）1定义2结构3
  • Java面试笔记记录6 今天背八股了吗 java面试笔记
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
  • 深入理解AOP（面向切面编程）及其应用 自身就是太阳 java开发语言spring
    目录AOP的核心概念AOP的实现方式1.定义DAO接口和实现类2.定义通知类3.开启AOP注解驱动切入点表达式通配符的使用：AOP通知类型案例分析：测量业务层接口的执行效率结论概述：AOP（Aspect-OrientedProgramming，面向切面编程）是一种编程范式，主要用于将共性功能从具体的业务逻辑中分离出来，实现松耦合的代码设计。其作用是在不修改原始代码的情况下，对现有方法进行增强，广泛
  • SpringSecurity初学总结 weixin_66442229 spring
    springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
  • SpringBoot—集成AOP详解（面向切面编程Aspect） Hughman
    AOP介绍AOP概述  AOP是Aspect-OrientedProgramming，即为面向（切面）方面编程。在维基百科中的解释：Aspect是一种新的模块化机制，用来描述分散在对象、类或函数中的横切关注点。从关注点中分离出横切关注点是面向切面的程序设计核心概念。分离关注点使得解决特定领域问题的代码从业务逻辑中独立出来，业务逻辑代码不需要再包含针对特定领域问题代码的调用，比如一些公用模块的日志、
  • 案例分析：如何用设计模式优化性能7 是小旭啊 fastapi
    设计模式就是对常用开发技巧进行的总结，它使得程序员之间交流问题，有了更专业、便捷的方式。比如，我们在《02|理论分析：性能优化有章可循，谈谈常用的切入点》中提到，I/O模块使用的是装饰器模式，你就能很容易想到I/O模块的代码组织方式。事实上，大多数设计模式并不能增加程序的性能，它只是代码的一种组织方式。本课时，我们将一一举例讲解和性能相关的几个设计模式，包括代理模式、单例模式、享元模式、原型模式等
  • 2023正规的返利app有哪些?哪个返利app最好 日常购物小技巧
    市场上的返利软件太多了，各种宣传各种引导，作为消费者无非就是想找一个稳定靠谱返利高的软件。为什么一定要使用返利软件呢，因为购物时你会发现，在返利软件可以领到商品大额优惠券和拿到20%-30%不等的返利，一年下来，能省下不少钱。2023年靠谱返利软件有哪些，小编测试分享以下10个返利最高的软件app，排名分先后。一、花桃花桃是温州花桃科技有限公司于2020年推出的一款返利APP平台，无代理模式，给的
  • 重修设计模式-结构型-代理模式 丶白泽 重修设计模式设计模式代理模式系统安全
    重修设计模式-结构型-代理模式在不改变原始类代码的情况下，通过引入代理类来给原始类附加功能。代理模式通过创建一个代理对象，使得客户端对目标对象的访问都通过代理对象间接进行，从而可以在不修改目标对象的前提下，增加额外的功能操作，如权限控制、日志记录、事务处理等。代理模式又分为静态代理和动态代理。静态代理（StaticProxy）：在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前
  • Jmeter性能-压测脚本录制与编写 HHX__HHX jmeter测试工具
    #学习打卡第6天今天学习主题：jmeter性能学习目标：压测脚本录制与编写--压测脚本录制与编写1、jmeter配置添加线程组添加recordingcontroller抓取请求添加viewresultstree添加HTTP(s)TestScriptRecorder2、浏览器配置使用firefox浏览器，下载插件omega，设置本机代理，IP地址：127.0.0.1；端口号：8888打开代理模式3、
  • Spring cache的使用 cyt涛 javaspringjava后端SpringCache缓存CacheableAOP
    SpringCache是Spring提供的一个缓存框架，基于AOP原理，实现了基于注解的缓存功能，只需要简单地加一个注解就能实现缓存功能，对业务代码的侵入性很小。1.常用的SpringCache注解@EnableCaching：开启缓存功能。@Cacheable：将方法返回值缓存，适用于读取操作。@CacheEvict：清除缓存，常用于删除或更新数据时。@CachePut：每次调用方法时都将返回值
  • 深入探究Spring Framework源码与核心组件 纸寿司
    本文还有配套的精品资源，点击获取简介：SpringFramework是Java开发中广泛使用的框架，其源码的阅读和理解对于开发者来说是宝贵的学习资源。本文将介绍依赖注入、ApplicationContext、Bean生命周期、AOP、数据访问集成、MVC模式、注解驱动开发、测试支持、SpringBoot以及SpringCloud等关键概念。通过这些核心组件的学习，可以更好地掌握Spring的高级功
  • 第 2-2 课：深入探究底层原理，应用更加得心应手 Java大联盟 案例上手Spring全家桶SpringSpringBootSpringCloudSpringMVCSpringSpringBootSpring
    前言上一讲我们学习了SpringMVC框架的使用，为了更好地理解这个框架，本讲来仿写一个SpringMVC框架，用到的技术比较简单，只需要XML解析+反射就可以完成，不需要JDK动态代理。自己手写框架的前提是必须理解框架的底层原理和运行机制，因此我们还是先来回顾一下SpringMVC的实现原理。SpringMVC实现原理SpringMVC的核心组件和工作流程的内容具体可以参考第2-1讲的内容，通过
  • 短视频矩阵源码 fendou--yx898978 抖音账号矩阵系统源码开发python开发语言矩阵
    矩阵系统源码主要有三种框架：Spring、Struts和Hibernate。Spring框架是一个全栈式的Java应用程序开发框架，提供了IOC容器、AOP、事务管理等功能。Struts框架是一个MVC架构的Web应用程序框架，用于将数据模型、Web应用程序的用户界面和控制器逻辑分离。Hibernate框架是一个面向对象的数据库访问框架，提供了ORM（对象关系映射）机制，允许开发人员使用面向对象的
  • Java设计模式之单例模式/饿汉式/懒汉式/DCL双重检测锁模式/静态内部类实现单例模式/使用反射破坏单例模式/枚举类实现单例模式 ZaynFox #JavaSE
    一、概念设计模式：是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索。共有23种设计模式：创建型模式，共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共7种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共11种：策
  • java设计模式---中介者模式 奔跑的扫地僧 Java设计模式java
    首先我们了解下设计模式的总览：GoF提出的设计模式总共有23种，根据目的准则分类分为三大类：创建型模式，共五种：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式
  • 代理模式详解：静态代理与动态代理的实现 Disper_ 代理模式
    静态代理eg:我们在商店买商品，而商店的商品又来源于厂商，此时商店的作用便是代理1.定义服务接口publicinterfaceUserService{voidselect();voidupdate();}2.实现服务接口的类publicclassUserServiceImplimplementsUserService{@Overridepublicvoidselect(){System.out.p
  • 【架构设计模式-1】代理模式 W Y 代理模式系统安全安全
    什么情况下用上代理模式？远程对象访问当需要访问位于不同地址空间的远程对象时，比如在分布式系统中。代理可以隐藏网络通信的复杂性，让客户端感觉就像在本地访问对象一样。例如，一个企业级应用中，不同部门的系统可能分布在不同的服务器上。当部门A的系统需要调用部门B系统中的某个服务时，可以使用代理模式。代理对象负责与远程服务进行通信，将请求发送到远程服务器并接收响应，然后将结果返回给本地客户端。这样，部门A的
  • Java基础 -- 05反射reflect mmlz00 Java基础Java基础反射reflectProxy动态代理
    目录引序说不通1：注解说不通2：匿名内部类说不通3：动态代理反射：反射定义强调：类对象又强调：static类静态成员再三强调：synchronized修饰符类对象：知晓类结构类结构之：内部成员内部成员--构造函数内部成员--数据成员内部成员--方法成员静态代理：动态代理：反射+注解反射+泛型+注解getGenericSuperclass()用法引序引序：开始反射概念学习之前，先来段引序。请牢记：计
  • Conda创建环境失败：000和404错误 柚柚柚柚柚 conda
    一、首先下载Anaconda1.打开网址Indexof/anaconda/archive/|清华大学开源软件镜像站|TsinghuaOpenSourceMirror，滑到最底部，下载Anaconda3-5.3.1-Linux-x86_64.sh。2.使用winscp拖动本地的Anaconda3-5.3.1-Linux-x86_64.sh到服务器的个人工作目录下。二、安装Anaconda软件，创建虚
  • 【深入学习Redis丨第三篇】深入详解Redis高可用集群模式 陈橘又青 深入学习Redis学习redis数据库高可用集群
    前言本文我们将介绍Redis的四种模式及各自优缺点分析。Redis一共4种模式：1、主从复制模式2、(Sentinel)哨兵模式3、(Cluster)集群模式4、代理模式文章目录前言1.**主从模式****1.1简介****1.2工作机制**2.**哨兵模式****2.1简介****2.2工作机制****2.3注意点**3.**Cluster模式****3.1简介****3.2工作机制****3.
  • 软考-常见的23种设计模式整理 ppliu600 软件架构数据仓库数据库数据挖掘
    参考：23种设计模式总结设计模式可以将复用别人的解决方案。一、设计模式的分类创建型模式，共5种：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。结构型模式，共7种：适配器模式、组合模式、代理模式、享元模式、外观模式、桥接模式、装饰器模式、行为型模式，共11种：观察者模式、策略模式、模板方法模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
  • SpringMVC架构介绍 丹_妮 spring
    MVC框架要做的事情？1)将url映射到java类或java类的方法2)封装用户提交的数据3)处理请求-调用相关的业务处理-封装响应数据4)将响应的数据进行渲染jsphtml为什么要学习SpringMVC？性能较struts2好简单、便捷、易学天生和Spring无缝集成，使用Spring的IOC和AOP还有事务使用约定由于配置能够进行简单的junit测试支持restful风格异常处理本地化、国际化
  • Python之最常用的16种设计模式 ModelBulider Python基础（千锋篇）python设计模式javascript
    文章目录一、设计模式与面向对象介绍1.1设计模式1.2复习：面向对象1.3接口二、面向对象设计SOLID原则三、设计模式分类四、创造型模式4.1简单工厂模式4.2工厂方法模式4.3抽象工厂模式4.4建造者模式4.5单例模式4.6创建型模式小结五、结构型模式5.1适配器模式5.2桥模式5.3组合模式5.4外观模式5.5代理模式六、行为型模式6.1责任链模式6.2观察者模式6.3策略模式6.4模板方法
  • 【设计模式】第四章：原型模式详解及应用案例 Bummon. 设计模式原型模式设计模式
    系列文章【设计模式】七大设计原则【设计模式】第一章：单例模式【设计模式】第二章：工厂模式【设计模式】第三章：建造者模式【设计模式】第四章：原型模式【设计模式】第五章：适配器模式【设计模式】第六章：装饰器模式【设计模式】第七章：代理模式【设计模式】第八章：桥接模式【设计模式】第九章：外观模式/门面模式【设计模式】第十章：组合模式【设计模式】第十一章：享元模式【设计模式】第十二章：观察者模式【设计模式
  • Spring基础 zzzzzzzziu springjava后端
    前言Spring是一个开源的Java平台，用于构建企业级应用程序。它提供了一系列的模块和工具，以简化Java应用程序的开发。Spring框架的核心特点是轻量级、灵活性和可扩展性。以下是Spring基础知识的详细概述：Spring概述开源框架：Spring是一个开源的Java平台，广泛用于企业级应用开发。核心特性：Spring通过依赖注入（DI）和面向切面编程（AOP）等技术，降低了组件之间的耦合度
  • spring如何解决bean的循环依赖 fantasyYan2 springspringjava后端
    通过三级缓存解决循环依赖问题。其中一级缓存用于存储完整的bean；二级缓存用于存储已经完成aop动态代理的bean，防止重复创建动态代理；三级缓存存储未实现aop动态代理和为实现依赖注入的bean。getBean()时先从一级缓存取，没有取二级，最后取三级。举个例子：A依赖B，B依赖A。首先创建A发现缓存中没有A，如图实例化A，然后发现A依赖B，把A放入三级缓存。开始创建B，发现B不在缓存中，实例
  • 深入浅出：使用Spring Boot实现AOP切面编程 一休哥助手 javaspringboot后端java
    目录引言AOP概述AOP的定义与核心概念AOP的优势SpringBoot中的AOP实现SpringAOP与AspectJ依赖配置AOP的工作原理
  • 19.3-装饰器习题cache和命令分发器实现 BeautifulSoulpy
    当你处于低潮期的时候，好好想想，就算现在攒不到钱，攒点知识，交情，经验，最不济攒点教训也行!装饰器一定要多加练习，装饰器是越练越熟练；后面很多框架一装饰就能用了，经常见到的各种类型的装饰器都要练一遍；本章总结：无参、有参、缓存装饰器、通用装饰器、1.40；装饰器是AOP面向对象编程AspectOrientedProgramming思想的体现；想装饰器return是什么很重要，装饰器装饰器（Deco
  • android Camera操作类 天下乌鸦不尽黑 androidandroid
    publicclassCameraOperate{privatestaticCameraOperatemCameraOperate;privateCameramCamera;privateintmStatus=0;privateintmCameraId=-1;privateintmSurfaceViewOrientation=0;privateintmPictureOrientation=0;pu
  • JVM StackMapTable 属性的作用及理解 lijingyao8206 jvm字节码Class文件StackMapTable
            在Java 6版本之后JVM引入了栈图(Stack Map Table)概念。为了提高验证过程的效率，在字节码规范中添加了Stack Map Table属性，以下简称栈图，其方法的code属性中存储了局部变量和操作数的类型验证以及字节码的偏移量。也就是一个method需要且仅对应一个Stack Map Table。在Java 7版
  • 回调函数调用方法 百合不是茶 java
    最近在看大神写的代码时,.发现其中使用了很多的回调 ,以前只是在学习的时候经常用到 ,现在写个笔记 记录一下   代码很简单:           MainDemo  :调用方法  得到方法的返回结果        
  • [时间机器]制造时间机器需要一些材料 comsci 制造
          根据我的计算和推测,要完全实现制造一台时间机器,需要某些我们这个世界不存在的物质     和材料...       甚至可以这样说,这种材料和物质,我们在反应堆中也无法获得......      
  • 开口埋怨不如闭口做事 邓集海 邓集海 做人 做事 工作
    “开口埋怨，不如闭口做事。”不是名人名言，而是一个普通父亲对儿子的训导。但是，因为这句训导，这位普通父亲却造就了一个名人儿子。这位普通父亲造就的名人儿子，叫张明正。 　　 　　张明正出身贫寒，读书时成绩差，常挨老师批评。高中毕业，张明正连普通大学的分数线都没上。高考成绩出来后，平时开口怨这怨那的张明正，不从自身找原因，而是不停地埋怨自己家庭条件不好、埋怨父母没有给他创造良好的学习环境。 　　 　　
  • jQuery插件开发全解析，类级别与对象级别开发 IT独行者 jquery开发插件　函数
    jQuery插件的开发包括两种： 一种是类级别的插件开发，即给 jQuery添加新的全局函数，相当于给 jQuery类本身添加方法。 jQuery的全局函数就是属于 jQuery命名空间的函数，另一种是对象级别的插件开发，即给 jQuery对象添加方法。下面就两种函数的开发做详细的说明。   1 、类级别的插件开发 类级别的插件开发最直接的理解就是给jQuer
  • Rome解析Rss 413277409 Rome解析Rss
    import java.net.URL;  import java.util.List;    import org.junit.Test;    import com.sun.syndication.feed.synd.SyndCategory;  import com.sun.syndication.feed.synd.S
  • RSA加密解密 无量 加密解密rsa
    RSA加密解密代码 代码有待整理 package com.tongbanjie.commons.util; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerat
  • linux 软件安装遇到的问题 aichenglong linux遇到的问题ftp
    1 ftp配置中遇到的问题    500 OOPS: cannot change directory   出现该问题的原因:是SELinux安装机制的问题.只要disable SELinux就可以了   修改方法:1 修改/etc/selinux/config 中SELINUX=disabled    2 source /etc
  • 面试心得 alafqq 面试
    最近面试了好几家公司。记录下； 支付宝，面试我的人胖胖的，看着人挺好的；博彦外包的职位，面试失败； 阿里金融，面试官人也挺和善，只不过我让他吐血了。。。 由于印象比较深，记录下； 1，自我介绍 2，说下八种基本类型；（算上string。楼主才答了3种，哈哈，string其实不是基本类型，是引用类型） 3，什么是包装类，包装类的优点； 4，平时看过什么书？NND，什么书都没看过。。照样
  • java的多态性探讨 百合不是茶 java
    java的多态性是指main方法在调用属性的时候类可以对这一属性做出反应的情况 //package 1; class A{ public void test(){ System.out.println("A"); } } class D extends A{ public void test(){ S
  • 网络编程基础篇之JavaScript-学习笔记 bijian1013 JavaScript
    1.documentWrite <html> <head> <script language="JavaScript"> document.write("这是电脑网络学校"); document.close(); </script> </h
  • 探索JUnit4扩展：深入Rule bijian1013 JUnitRule单元测试
            本文将进一步探究Rule的应用，展示如何使用Rule来替代@BeforeClass，@AfterClass，@Before和@After的功能。         在上一篇中提到，可以使用Rule替代现有的大部分Runner扩展，而且也不提倡对Runner中的withBefores()，withAfte
  • [CSS]CSS浮动十五条规则 bit1129 css
    这些浮动规则，主要是参考CSS权威指南关于浮动规则的总结，然后添加一些简单的例子以验证和理解这些规则。   1. 所有的页面元素都可以浮动 2. 一个元素浮动后，会成为块级元素，比如<span>,a, strong等都会变成块级元素 3.一个元素左浮动，会向最近的块级父元素的左上角移动，直到浮动元素的左外边界碰到块级父元素的左内边界；如果这个块级父元素已经有浮动元素停靠了
  • 【Kafka六】Kafka Producer和Consumer多Broker、多Partition场景 bit1129 partition
    0.Kafka服务器配置 3个broker 1个topic，6个partition，副本因子是2 2个consumer，每个consumer三个线程并发读取   1. Producer package kafka.examples.multibrokers.producers; import java.util.Properties; import java.util.
  • zabbix_agentd.conf配置文件详解 ronin47 zabbix 配置文件
    Aliaskey的别名，例如 Alias=ttlsa.userid:vfs.file.regexp[/etc/passwd,^ttlsa:.:([0-9]+),,,,\1]， 或者ttlsa的用户ID。你可以使用key：vfs.file.regexp[/etc/passwd,^ttlsa:.: ([0-9]+),,,,\1]，也可以使用ttlsa.userid。备注: 别名不能重复，但是可以有多个
  • java--19.用矩阵求Fibonacci数列的第N项 bylijinnan fibonacci
    参考了网上的思路，写了个Java版的： public class Fibonacci { final static int[] A={1,1,1,0}; public static void main(String[] args) { int n=7; for(int i=0;i<=n;i++){ int f=fibonac
  • Netty源码学习-LengthFieldBasedFrameDecoder bylijinnan javanetty
    先看看LengthFieldBasedFrameDecoder的官方API http://docs.jboss.org/netty/3.1/api/org/jboss/netty/handler/codec/frame/LengthFieldBasedFrameDecoder.html API举例说明了LengthFieldBasedFrameDecoder的解析机制，如下： 实
  • AES加密解密 chicony 加密解密
    AES加解密算法，使用Base64做转码以及辅助加密： package com.wintv.common; import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; import sun.misc.BASE64Decod
  • 文件编码格式转换 ctrain 编码格式
    package com.test; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream;
  • mysql 在linux客户端插入数据中文乱码 daizj mysql中文乱码
    1、查看系统客户端，数据库，连接层的编码  查看方法： http://daizj.iteye.com/blog/2174993 进入mysql，通过如下命令查看数据库编码方式： mysql>  show variables like 'character_set_%'; +--------------------------+------
  • 好代码是廉价的代码 dcj3sjt126com 程序员读书
      长久以来我一直主张：好代码是廉价的代码。 当我跟做开发的同事说出这话时，他们的第一反应是一种惊愕，然后是将近一个星期的嘲笑，把它当作一个笑话来讲。 当他们走近看我的表情、知道我是认真的时，才收敛一点。 当最初的惊愕消退后，他们会用一些这样的话来反驳： “好代码不廉价，好代码是采用经过数十年计算机科学研究和积累得出的最佳实践设计模式和方法论建立起来的精心制作的程序代码。” 我只
  • Android网络请求库——android-async-http dcj3sjt126com android
    在iOS开发中有大名鼎鼎的ASIHttpRequest库，用来处理网络请求操作，今天要介绍的是一个在Android上同样强大的网络请求库android-async-http，目前非常火的应用Instagram和Pinterest的Android版就是用的这个网络请求库。这个网络请求库是基于Apache HttpClient库之上的一个异步网络请求处理库，网络处理均基于Android的非UI线程，通
  • ORACLE 复习笔记之SQL语句的优化 eksliang SQL优化Oracle sql语句优化SQL语句的优化
    转载请出自出处：http://eksliang.iteye.com/blog/2097999   SQL语句的优化总结如下   sql语句的优化可以按照如下六个步骤进行： 合理使用索引 避免或者简化排序 消除对大表的扫描 避免复杂的通配符匹配 调整子查询的性能 EXISTS和IN运算符 下面我就按照上面这六个步骤分别进行总结：
  • 浅析：Android 嵌套滑动机制（NestedScrolling） gg163 android移动开发滑动机制嵌套
    谷歌在发布安卓 Lollipop版本之后，为了更好的用户体验，Google为Android的滑动机制提供了NestedScrolling特性 NestedScrolling的特性可以体现在哪里呢？<!--[if !supportLineBreakNewLine]--><!--[endif]--> 比如你使用了Toolbar，下面一个ScrollView，向上滚
  • 使用hovertree菜单作为后台导航 hvt JavaScriptjquery.nethovertreeasp.net
      hovertree是一个jquery菜单插件，官方网址：http://keleyi.com/jq/hovertree/ ，可以登录该网址体验效果。 0.1.3版本：http://keleyi.com/jq/hovertree/demo/demo.0.1.3.htm hovertree插件包含文件： http://keleyi.com/jq/hovertree/css
  • SVG 教程 （二）矩形 天梯梦 svg
    SVG <rect> SVG Shapes SVG有一些预定义的形状元素，可被开发者使用和操作： 矩形 <rect> 圆形 <circle> 椭圆 <ellipse> 线 <line> 折线 <polyline> 多边形 <polygon> 路径 <path>
  • 一个简单的队列 luyulong java数据结构队列
    public class MyQueue { private long[] arr; private int front; private int end; // 有效数据的大小 private int elements; public MyQueue() { arr = new long[10]; elements = 0; front
  • 基础数据结构和算法九：Binary Search Tree sunwinner Algorithm
      A binary search tree (BST) is a binary tree where each node has a Comparable key (and an associated value) and satisfies the restriction that the key in any node is larger than the keys in all
  • 项目出现的一些问题和体会 Steven-Walker DAOWebservlet
         第一篇博客不知道要写点什么，就先来点近阶段的感悟吧。     这几天学了servlet和数据库等知识，就参照老方的视频写了一个简单的增删改查的，完成了最简单的一些功能，使用了三层架构。 dao层完成的是对数据库具体的功能实现，service层调用了dao层的实现方法，具体对servlet提供支持。  &
  • 高手问答：Java老A带你全面提升Java单兵作战能力！ ITeye管理员 java
    本期特邀《Java特种兵》作者：谢宇，CSDN论坛ID: xieyuooo 针对JAVA问题给予大家解答，欢迎网友积极提问，与专家一起讨论! 作者简介： 淘宝网资深Java工程师，CSDN超人气博主，人称“胖哥”。 CSDN博客地址： http://blog.csdn.net/xieyuooo 作者在进入大学前是一个不折不扣的计算机白痴，曾经被人笑话过不懂鼠标是什么，
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他