sping AOP核心思想及实现原理

核心思想

aop的核心思想是目标对象初始化后创建其代理对象（cglib、jdk）。代理对象执行方法时走MethodInterceptor的invoke拦截方法，实现横切。

实现原理

首先我们先来看AspectJAwareAdvisorAutoProxyCreator（还有AnnotationAwareAspectJAutoProxyCreator），这是目标对象的代理对象创建者

我们重点关注InstantiationAwareBeanPostProcessor，BeanPostProcessor接口。

BeanPostProcessor

public interface BeanPostProcessor {

    /**
     * bean初始化前的后置处理*/
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

    /**
     * bean初始化后的后置处理*/
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

}

InstantiationAwareBeanPostProcessor继承了BeanPostProcessor

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {

    /**
     * bean实例化之前的后只处理
     */
    Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;

    /**
     * bean实例化后的后置处理
     */
    boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException;

    PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
            throws BeansException;

}

也就是说AspectJAwareAdvisorAutoProxyCreator在bean实例化和初始化前后都会进行后置处理

spring注册并实例化AspectJAwareAdvisorAutoProxyCreator后，bean如GoodService实例化后初始化时就有了后置处理器的前置处理和后置处理，而后置处理就是为目标对象创建代理的过程。

 AbstractBeanFactory执行creatBean()时，实例化前给后置处理器一个机会去创建自定义的代理对象，这个必须实现TargetSource接口

实例化bean后初始化时使用后置处理器去创建代理对象

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException {

        Object result = existingBean;
　　　　　// 获得所有的bean后置处理器其中就包含AspectJAwareAdvisorAutoProxyCreator
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            result = beanProcessor.postProcessAfterInitialization(result, beanName);
            if (result == null) {
                return result;
            }
        }
        return result;
    }

AbstractAutoProxyCreator中执行

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
　　　　　// 判断是Advice、Pointcut、Advisor等的实现类是的话不创建代理对象
　　　　　// 判断是否需要跳过即判断该bean是否是切面类bean如com.wjz.service.Transaction，后文详解#1
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
        // 获得Advisor广播和Advice通知，后文详解#2
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
　　　　　　　// 创建目标对象的代理对象，后文详解#3
            Object proxy = createProxy(
                    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

 书接前文#1

protected boolean shouldSkip(Class<?> beanClass, String beanName) {
        // 获得所有的广播
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
        for (Advisor advisor : candidateAdvisors) {
            if (advisor instanceof AspectJPointcutAdvisor) {
                if (((AbstractAspectJAdvice) advisor.getAdvice()).getAspectName().equals(beanName)) {
                    return true;
                }
            }
        }
        return super.shouldSkip(beanClass, beanName);
    }

public List<Advisor> findAdvisorBeans() {
        // Determine list of advisor bean names, if not cached already.
        String[] advisorNames = null;
        synchronized (this) {
            advisorNames = this.cachedAdvisorBeanNames;
            if (advisorNames == null) {
                // 获得所有的注册了的实现了Advisor接口的bean如<aop:before>标签对应的bean
                advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                        this.beanFactory, Advisor.class, true, false);
                this.cachedAdvisorBeanNames = advisorNames;
            }
        }
        if (advisorNames.length == 0) {
            return new LinkedList<Advisor>();
        }

        List<Advisor> advisors = new LinkedList<Advisor>();
        for (String name : advisorNames) {
            if (isEligibleBean(name)) {
                if (this.beanFactory.isCurrentlyInCreation(name)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Skipping currently created advisor '" + name + "'");
                    }
                }
                else {
                    try {
　　　　　　　　　　　　　　// 实例化那些广播bean（全局变量中有通知bean）
                        advisors.add(this.beanFactory.getBean(name, Advisor.class));
                    }
                    catch (BeanCreationException ex) {
                        Throwable rootCause = ex.getMostSpecificCause();
                        if (rootCause instanceof BeanCurrentlyInCreationException) {
                            BeanCreationException bce = (BeanCreationException) rootCause;
                            if (this.beanFactory.isCurrentlyInCreation(bce.getBeanName())) {
                                if (logger.isDebugEnabled()) {
                                    logger.debug("Skipping advisor '" + name +
                                            "' with dependency on currently created bean: " + ex.getMessage());
                                }
                                // Ignore: indicates a reference back to the bean we're trying to advise.
                                // We want to find advisors other than the currently created bean itself.
                                continue;
                            }
                        }
                        throw ex;
                    }
                }
            }
        }
        return advisors;
    }

这里我们需要说一下AspectJPointcutAdvisor的实例化过程是通过构造器反射完成的，他的构造函数如下

在实例化AspectJPointcutAdvisor之前我们知道得先实例化AbstractAspectJAdvice如AspectJMethodBeforeAdvice，后者的构造函数如下

我们可以看到他有三个参数，这三个参数都必须先初始化，他们的初始化过程就是普通的无参构造器反射

书接前文#2

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
　　　　　// 获得广播和#1相同
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
　　　　　// 使用AspectJPointcutAdvisor中的ClassFilter和MethodMatcher匹配出符合的广播
        List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        extendAdvisors(eligibleAdvisors);
        if (!eligibleAdvisors.isEmpty()) {
            eligibleAdvisors = sortAdvisors(eligibleAdvisors);
        }
        return eligibleAdvisors;
    }

else if (advisor instanceof PointcutAdvisor) {
　　PointcutAdvisor pca = (PointcutAdvisor) advisor;
　　// pca.getPointcut()返回ComposablePointcut后者有ClassFilter和MethodMatcher
   return canApply(pca.getPointcut(), targetClass, hasIntroductions);
}

public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
        // 获得AspectJExpressionPointcut并匹配bean的Class如com.wjz.service.GoodService，后文详解#2-1
　　　　  if (!pc.getClassFilter().matches(targetClass)) {
            return false;
        }

        MethodMatcher methodMatcher = pc.getMethodMatcher();
        if (methodMatcher == MethodMatcher.TRUE) {
            // No need to iterate the methods if we're matching any method anyway...
            return true;
        }

        IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
        if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
            introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
        }

        Set<Class<?>> classes = new LinkedHashSet<Class<?>>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
        classes.add(targetClass);
        for (Class<?> clazz : classes) {
            Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
            for (Method method : methods) {
　　　　　　　　　　// 获得bean的所有方法使用MethodMatcher匹配方法，后文详解#2-2
                if ((introductionAwareMethodMatcher != null &&
                        introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions)) ||
                        methodMatcher.matches(method, targetClass)) {
                    return true;
                }
            }
        }

        return false;
    }

书接前文#2-1

public boolean matches(Class<?> targetClass) {
　　　　// 检查org.aspectj的PointcutExpression是否创建了
       checkReadyToMatch();
　　　　// 这里使用了org.aspectj的API完成的
       return this.pointcutExpression.couldMatchJoinPointsInType(targetClass);
}

自定义实现横切过滤类功能

import java.util.HashSet;
import java.util.Set;

import org.aspectj.weaver.tools.PointcutExpression;
import org.aspectj.weaver.tools.PointcutParameter;
import org.aspectj.weaver.tools.PointcutParser;
import org.aspectj.weaver.tools.PointcutPrimitive;

private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = new HashSet<PointcutPrimitive>();
    private static final String expression = "execution(* com.wjz.service.*.*(..))";
    private static final Class<?> clazz = GoodService.class;
    static {
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
    }
    public static void main(String[] args) {
        PointcutExpression pointcutExpression = null;
        PointcutParser parser = PointcutParser
                .getPointcutParserSupportingSpecifiedPrimitivesAndUsingSpecifiedClassLoaderForResolution(
                        SUPPORTED_PRIMITIVES, Thread.currentThread().getContextClassLoader());
        PointcutParameter[] pointcutParameters = new PointcutParameter[0];
        pointcutExpression = parser.parsePointcutExpression(expression, null, pointcutParameters);
        System.out.println(pointcutExpression.couldMatchJoinPointsInType(clazz));
    }

 书接前文#2-2

public boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions) {
       return
　　　　　　　　// 判断目标方法是否是切入点方法如beginTransaction方法
　　　　　　　　MethodMatchers.matches(this.mm1, method, targetClass, hasIntroductions) &&
　　　　　　　　// 判断目标方法是否符合表达式，使用了org.aspectj的API完成的
　　　　　　　　MethodMatchers.matches(this.mm2, method, targetClass, hasIntroductions);
}

public static boolean matches(MethodMatcher mm, Method method, Class<?> targetClass, boolean hasIntroductions) {
　　return
　　　　// org.aspectj的API判断目标方法是否匹配表达式 
　　　　((mm instanceof IntroductionAwareMethodMatcher && 
　　　　　　((IntroductionAwareMethodMatcher) mm).matches(method, targetClass, hasIntroductions)) 
　　　　||
　　　　// 使用AdviceExcludingMethodMatcher判断目标方法是否是切入点方法
　　　　mm.matches(method, targetClass));
}

org.aspectj的API判断目标方法是否匹配表达式

public boolean matches(Method method, Class<?> targetClass, boolean beanHasIntroductions) {
        // 检查是否创建了org.aspectj的PointcutExpression对象没有的话立即创建
　　　　 checkReadyToMatch();
        Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
　　　　　// 获得org.aspectj的ShadowMatch对象
        ShadowMatch shadowMatch = getShadowMatch(targetMethod, method);// 使用API判断是否匹配
        if (shadowMatch.alwaysMatches()) {
            return true;
        }
　　　　　return false;
}

自定义实现横切过滤方法功能

private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = new HashSet<PointcutPrimitive>();
    private static final String expression = "execution(* com.wjz.service.*.*(..))";
    private static final Class<?> clazz = GoodService.class;
    static {
        SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
    }
    public static void main(String[] args) throws Exception {
        PointcutExpression pointcutExpression = null;
        PointcutParser parser = PointcutParser
                .getPointcutParserSupportingSpecifiedPrimitivesAndUsingSpecifiedClassLoaderForResolution(
                        SUPPORTED_PRIMITIVES, Thread.currentThread().getContextClassLoader());
        PointcutParameter[] pointcutParameters = new PointcutParameter[0];
        pointcutExpression = parser.parsePointcutExpression(expression, null, pointcutParameters);
        Method method = clazz.getDeclaredMethod("list");
        ShadowMatch shadowMatch = pointcutExpression.matchesMethodExecution(method);
        System.out.println(shadowMatch.alwaysMatches());
    }

使用AdviceExcludingMethodMatcher判断目标方法是否是切入点方法

public boolean matches(Method method, Class<?> targetClass) {
　　// 方法比较
　　return !this.adviceMethod.equals(method);
}

 书接前文#3

这是核心部分，创建目标对象的代理对象

protected Object createProxy(
            Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {

        if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
            AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
        }
　　　　　// 创建ProxyFactory对象并设置一些属性值
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.copyFrom(this);
　　　　　// 判断bean是否已经是代理对象了
        if (!proxyFactory.isProxyTargetClass()) {
            if (shouldProxyTargetClass(beanClass, beanName)) {
                proxyFactory.setProxyTargetClass(true);
            }
            else {
　　　　　　　　　　// 判断bean是否能创建代理对象
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }
　　　　　// 创建所有的广播，就是将specificInterceptors中的Advisor拿到
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        for (Advisor advisor : advisors) {
　　　　　　　// 将Advisor注入到ProxyFactory中
            proxyFactory.addAdvisor(advisor);
        }
　　　　　// 将SingletonTargetSource注入到ProxyFactory中，前者包含bean的实例化对象
        proxyFactory.setTargetSource(targetSource);
　　　　　// 自定义扩展ProxyFactory
        customizeProxyFactory(proxyFactory);

        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }
　　　　　// 核心部分，获得bean对象的代理对象
        return proxyFactory.getProxy(getProxyClassLoader());
    }

 使用AopProxyFactory（DefaultAopProxyFactory）创建JdkDynamicAopProxy（JDK）或者是ObjenesisCglibAopProxy（cglib）对象，再创建代理对象

public Object getProxy(ClassLoader classLoader) {
　　return createAopProxy().getProxy(classLoader);
}

判断创建jdk方式的代理还是cglib方式的代理

// 如果bean是接口或者已经是代理对象了则创建jdk方式的代理，否则创建cglib方式的
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
　　return new JdkDynamicAopProxy(config);
}
　　return new ObjenesisCglibAopProxy(config);

cglib方式创建代理对象

public Object getProxy(ClassLoader classLoader) {try {
            Class<?> rootClass = this.advised.getTargetClass();
            Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");

            Class<?> proxySuperClass = rootClass;
　　　　　　　// 判断是否是cglib代理对象
            if (ClassUtils.isCglibProxyClass(rootClass)) {
                proxySuperClass = rootClass.getSuperclass();
                Class<?>[] additionalInterfaces = rootClass.getInterfaces();
                for (Class<?> additionalInterface : additionalInterfaces) {
                    this.advised.addInterface(additionalInterface);
                }
            }

            // 验证类，根据需要编写日志消息
            validateClassIfNecessary(proxySuperClass, classLoader);

            // 创建cglib核心类Enhancer
            Enhancer enhancer = createEnhancer();
            if (classLoader != null) {
                enhancer.setClassLoader(classLoader);
                if (classLoader instanceof SmartClassLoader &&
                        ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
                    enhancer.setUseCache(false);
                }
            }
            enhancer.setSuperclass(proxySuperClass);
            enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
            enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));
　　　　　　　// 获得回调即执行目标方法时的拦截方法，稍后详解
            Callback[] callbacks = getCallbacks(rootClass);
            Class<?>[] types = new Class<?>[callbacks.length];
            for (int x = 0; x < types.length; x++) {
                types[x] = callbacks[x].getClass();
            }
            // fixedInterceptorMap only populated at this point, after getCallbacks call above
            enhancer.setCallbackFilter(new ProxyCallbackFilter(
                    this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
            enhancer.setCallbackTypes(types);

            // 生成代理类并创建一个代理实例
            return createProxyClassAndInstance(enhancer, callbacks);
        }
}

protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
        enhancer.setInterceptDuringConstruction(false);
        enhancer.setCallbacks(callbacks);
        return (this.constructorArgs != null ?
                enhancer.create(this.constructorArgTypes, this.constructorArgs) :
                enhancer.create());
}

private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
        // 用于优化选择的参数
        boolean exposeProxy = this.advised.isExposeProxy();
        boolean isFrozen = this.advised.isFrozen();
        boolean isStatic = this.advised.getTargetSource().isStatic();

        // 创建一个重要的动态aop拦截类，后文详解
        Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);
        Callback targetInterceptor;
        if (exposeProxy) {
            targetInterceptor = isStatic ?
                    new StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) :
                    new DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource());
        }
        else {
            targetInterceptor = isStatic ?
                    new StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) :
                    new DynamicUnadvisedInterceptor(this.advised.getTargetSource());
        }
        Callback targetDispatcher = isStatic ?
                new StaticDispatcher(this.advised.getTargetSource().getTarget()) : new SerializableNoOp();
        Callback[] mainCallbacks = new Callback[] {
                aopInterceptor,  // for normal advice
                targetInterceptor,  // invoke target without considering advice, if optimized
                new SerializableNoOp(),  // no override for methods mapped to this
                targetDispatcher, this.advisedDispatcher,
                new EqualsInterceptor(this.advised),
                new HashCodeInterceptor(this.advised)
        };
        Callback[] callbacks;
        if (isStatic && isFrozen) {
            Method[] methods = rootClass.getMethods();
            Callback[] fixedCallbacks = new Callback[methods.length];
            this.fixedInterceptorMap = new HashMap<String, Integer>(methods.length);

            // TODO: small memory optimisation here (can skip creation for methods with no advice)
            for (int x = 0; x < methods.length; x++) {
                List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(methods[x], rootClass);
                fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
                        chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
                this.fixedInterceptorMap.put(methods[x].toString(), x);
            }

            callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
            System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
            System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
            this.fixedInterceptorOffset = mainCallbacks.length;
        }
        else {
            callbacks = mainCallbacks;
        }
        return callbacks;
    }

我们可以看到cglib设置了好几个CallBack用于拦截目标方法，我们详细看一下DynamicAdvisedInterceptor对象它拦截目标方法时做了什么？

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            Object oldProxy = null;
            boolean setProxyContext = false;
            Class<?> targetClass = null;
            Object target = null;
            try {
                if (this.advised.exposeProxy) {
                    oldProxy = AopContext.setCurrentProxy(proxy);
                    setProxyContext = true;
                }
             
                target = getTarget();
                if (target != null) {
                    targetClass = target.getClass();
                }
　　　　　　　　　 // 关键部分，获得所有的通知拦截如MethodBeforeAdviceInterceptor、AfterReturningAdviceInterceptor，稍后详解
                List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
                Object retVal;
                
                if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
                    Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
　　　　　　　　　　　　retVal = methodProxy.invoke(target, argsToUse);
                }
                else {
                    // 创建方法调用，执行方法链
                    retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
                }
　　　　　　　　　 // 处理返回结果
                retVal = processReturnType(proxy, target, method, retVal);
                return retVal;
            }
            finally {
                if (target != null) {
                    releaseTarget(target);
                }
                if (setProxyContext) {
                    // Restore old proxy.
                    AopContext.setCurrentProxy(oldProxy);
                }
            }
        }

public Object proceed() throws Throwable {
        // We start with an index of -1 and increment early.
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
　　　　　　　// 调用methodProxy.invoke(target, arguments);执行目标方法
            return invokeJoinpoint();
        }

        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
                return dm.interceptor.invoke(this);
            }
            else {
                return proceed();
            }
        }
        else {// MethodBeforeAdviceInterceptor、AfterReturningAdviceInterceptor等通知拦截器开始拦截
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }

前置通知拦截

public Object invoke(MethodInvocation mi) throws Throwable {
　　　　　// 前置通知拦截处理
        this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );
　　　　　// 调用拦截方法链
        return mi.proceed();
}

后置通知拦截

public Object invoke(MethodInvocation mi) throws Throwable {
　　　　　// 调用拦截方法链
        Object retVal = mi.proceed();
　　　　　// 后置通知拦截处理
        this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
        return retVal;
}

jdk方式创建代理对象

public Object getProxy(ClassLoader classLoader) {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
        }
        Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}