简介

表示被通知的标记接口；
实现子类主要是代理生成的对象和AdvisedSupport；

源码

public interface Advised extends TargetClassAware {

    // Advice配置信是否支持修改
    boolean isFrozen();

    // 是否代理指定的类而不是接口
    boolean isProxyTargetClass();

    // 获取代理的接口
    Class<?>[] getProxiedInterfaces();

    // 判断指定接口是否被代理
    boolean isInterfaceProxied(Class<?> intf);

    // 设置代理的目标对象
    void setTargetSource(TargetSource targetSource);

    / 获取代理的目标对象
    TargetSource getTargetSource();

    // 设置是否暴露代理对象到ThreadLocal，方便通过AopContext获取代理对象
    void setExposeProxy(boolean exposeProxy);

    // 判断是否暴露代理对象
    boolean isExposeProxy();

    // 设置是否已预过滤，如果已预过滤，则持有的Advisors都适用
    void setPreFiltered(boolean preFiltered);

    // 判断是否已预过滤
    boolean isPreFiltered();

    // 获取Advisors
    Advisor[] getAdvisors();

    // 获取Advisors数量
    default int getAdvisorCount() {
        return getAdvisors().length;
    }

    // 添加Advisor到链尾
    void addAdvisor(Advisor advisor) throws AopConfigException;

    // 添加Advisor到指定位置，pos必须有效
    void addAdvisor(int pos, Advisor advisor) throws AopConfigException;

    // 移除指定Advisor
    boolean removeAdvisor(Advisor advisor);

    // 移除指定位置的Advisor
    void removeAdvisor(int index) throws AopConfigException;

    // 获取指定Advisor的位置
    int indexOf(Advisor advisor);

    // 替换指定Advisor，如果旧Advisor是引介Advisor，则需要重新获取代理，否则新旧接口都不支持
    boolean replaceAdvisor(Advisor a, Advisor b) throws AopConfigException;

    // 添加Advice到链尾
    void addAdvice(Advice advice) throws AopConfigException;

    // 添加Advice到指定位置，pos必须有效
    void addAdvice(int pos, Advice advice) throws AopConfigException;

    // 移除指定Advice
    boolean removeAdvice(Advice advice);

    // 获取指定Advice的位置
    int indexOf(Advice advice);

    // 获取String形式的ProxyConfig
    String toProxyConfigString();
}

实现子类

public interface Advised extends TargetClassAware
    public class AdvisedSupport extends ProxyConfig implements Advised
        public class ProxyCreatorSupport extends AdvisedSupport
            public class ProxyFactoryBean extends ProxyCreatorSupport implements FactoryBean<Object>, BeanClassLoaderAware, BeanFactoryAware
            public class ProxyFactory extends ProxyCreatorSupport
            public class AspectJProxyFactory extends ProxyCreatorSupport

AdvisedSupport

简介

AOP代理配置管理类的基础类，这些管理类本身不是AOP代理类，但是它们的子类通常是直接获取AOP代理的工厂类；
AdvisedSupport实现了Advice和Advisor的管理，子类需要负责创建代理；

核心代码

public class AdvisedSupport extends ProxyConfig implements Advised {

    /**
     * Canonical TargetSource when there's no target, and behavior is
     * supplied by the advisors.
     */
    // 目标对象的典例
    public static final TargetSource EMPTY_TARGET_SOURCE = EmptyTargetSource.INSTANCE;

    // 目标对象
    TargetSource targetSource = EMPTY_TARGET_SOURCE;

    // 预过滤标识
    private boolean preFiltered = false;

    // Advisor链工厂
    AdvisorChainFactory advisorChainFactory = new DefaultAdvisorChainFactory();

    // 方法缓存，以Method为Key，Advisor chain list为Value
    private transient Map<MethodCacheKey, List<Object>> methodCache;

    // 代理实现的接口集合
    private List<Class<?>> interfaces = new ArrayList<>();

    // Advisor集合
    private List<Advisor> advisors = new ArrayList<>();


    public AdvisedSupport() {
        this.methodCache = new ConcurrentHashMap<>(32);
    }

    public AdvisedSupport(Class<?>... interfaces) {
        this();
        setInterfaces(interfaces);
    }

    public void setTarget(Object target) {
        setTargetSource(new SingletonTargetSource(target));
    }

    @Override
    public void setTargetSource(@Nullable TargetSource targetSource) {
        this.targetSource = (targetSource != null ? targetSource : EMPTY_TARGET_SOURCE);
    }

    @Override
    public TargetSource getTargetSource() {
        return this.targetSource;
    }

    public void setTargetClass(@Nullable Class<?> targetClass) {
        this.targetSource = EmptyTargetSource.forClass(targetClass);
    }

    @Override
    @Nullable
    public Class<?> getTargetClass() {
        return this.targetSource.getTargetClass();
    }

    @Override
    public void setPreFiltered(boolean preFiltered) {
        this.preFiltered = preFiltered;
    }

    @Override
    public boolean isPreFiltered() {
        return this.preFiltered;
    }

    public void setAdvisorChainFactory(AdvisorChainFactory advisorChainFactory) {
        // 校验AdvisorChainFactory
        Assert.notNull(advisorChainFactory, "AdvisorChainFactory must not be null");
        this.advisorChainFactory = advisorChainFactory;
    }

    public AdvisorChainFactory getAdvisorChainFactory() {
        return this.advisorChainFactory;
    }

    public void setInterfaces(Class<?>... interfaces) {
        // 校验代理的接口集合
        Assert.notNull(interfaces, "Interfaces must not be null");
        this.interfaces.clear();
        for (Class<?> ifc : interfaces) {
            addInterface(ifc);
        }
    }

    public void addInterface(Class<?> intf) {
        Assert.notNull(intf, "Interface must not be null");
        if (!intf.isInterface()) {
            // 只支持接口类型
            throw new IllegalArgumentException("[" + intf.getName() + "] is not an interface");
        }
        if (!this.interfaces.contains(intf)) {
            this.interfaces.add(intf);
            adviceChanged();
        }
    }

    public boolean removeInterface(Class<?> intf) {
        return this.interfaces.remove(intf);
    }

    @Override
    public Class<?>[] getProxiedInterfaces() {
        return ClassUtils.toClassArray(this.interfaces);
    }

    @Override
    public boolean isInterfaceProxied(Class<?> intf) {
        // 遍历代理的接口集合
        for (Class<?> proxyIntf : this.interfaces) {
            // 判断指定的接口类型是否属于遍历接口
            if (intf.isAssignableFrom(proxyIntf)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public final Advisor[] getAdvisors() {
        return this.advisors.toArray(new Advisor[0]);
    }

    @Override
    public int getAdvisorCount() {
        return this.advisors.size();
    }

    @Override
    public void addAdvisor(Advisor advisor) {
        int pos = this.advisors.size();
        addAdvisor(pos, advisor);
    }

    @Override
    public void addAdvisor(int pos, Advisor advisor) throws AopConfigException {
        if (advisor instanceof IntroductionAdvisor) {
            // 校验IntroductionAdvisor
            validateIntroductionAdvisor((IntroductionAdvisor) advisor);
        }
        addAdvisorInternal(pos, advisor);
    }

    @Override
    public boolean removeAdvisor(Advisor advisor) {
        int index = indexOf(advisor);
        if (index == -1) {
            return false;
        }
        else {
            removeAdvisor(index);
            return true;
        }
    }

    @Override
    public void removeAdvisor(int index) throws AopConfigException {
        if (isFrozen()) {
            // 不支持变动
            throw new AopConfigException("Cannot remove Advisor: Configuration is frozen.");
        }
        if (index < 0 || index > this.advisors.size() - 1) {
            throw new AopConfigException("Advisor index " + index + " is out of bounds: " +
                    "This configuration only has " + this.advisors.size() + " advisors.");
        }

        Advisor advisor = this.advisors.remove(index);
        if (advisor instanceof IntroductionAdvisor) {
            IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
            // 移除IntroductionAdvisor相关的接口
            for (Class<?> ifc : ia.getInterfaces()) {
                removeInterface(ifc);
            }
        }

        adviceChanged();
    }

    @Override
    public int indexOf(Advisor advisor) {
        Assert.notNull(advisor, "Advisor must not be null");
        return this.advisors.indexOf(advisor);
    }

    @Override
    public boolean replaceAdvisor(Advisor a, Advisor b) throws AopConfigException {
        Assert.notNull(a, "Advisor a must not be null");
        Assert.notNull(b, "Advisor b must not be null");
        int index = indexOf(a);
        if (index == -1) {
            return false;
        }
        removeAdvisor(index);
        addAdvisor(index, b);
        return true;
    }

    public void addAdvisors(Advisor... advisors) {
        addAdvisors(Arrays.asList(advisors));
    }

    public void addAdvisors(Collection<Advisor> advisors) {
        if (isFrozen()) {
            // 不支持变动
            throw new AopConfigException("Cannot add advisor: Configuration is frozen.");
        }
        if (!CollectionUtils.isEmpty(advisors)) {
            for (Advisor advisor : advisors) {
                if (advisor instanceof IntroductionAdvisor) {
                    validateIntroductionAdvisor((IntroductionAdvisor) advisor);
                }
                Assert.notNull(advisor, "Advisor must not be null");
                this.advisors.add(advisor);
            }
            adviceChanged();
        }
    }

    private void validateIntroductionAdvisor(IntroductionAdvisor advisor) {
        advisor.validateInterfaces();
        // If the advisor passed validation, we can make the change.
        Class<?>[] ifcs = advisor.getInterfaces();
        for (Class<?> ifc : ifcs) {
            addInterface(ifc);
        }
    }

    private void addAdvisorInternal(int pos, Advisor advisor) throws AopConfigException {
        Assert.notNull(advisor, "Advisor must not be null");
        if (isFrozen()) {
            // 不支持变动
            throw new AopConfigException("Cannot add advisor: Configuration is frozen.");
        }
        if (pos > this.advisors.size()) {
            throw new IllegalArgumentException(
                    "Illegal position " + pos + " in advisor list with size " + this.advisors.size());
        }
        this.advisors.add(pos, advisor);
        adviceChanged();
    }

    protected final List<Advisor> getAdvisorsInternal() {
        return this.advisors;
    }

    @Override
    public void addAdvice(Advice advice) throws AopConfigException {
        int pos = this.advisors.size();
        addAdvice(pos, advice);
    }

    @Override
    public void addAdvice(int pos, Advice advice) throws AopConfigException {
        Assert.notNull(advice, "Advice must not be null");
        // 将Advice包装为Advisor
        if (advice instanceof IntroductionInfo) {
            // We don't need an IntroductionAdvisor for this kind of introduction:
            // It's fully self-describing.
            addAdvisor(pos, new DefaultIntroductionAdvisor(advice, (IntroductionInfo) advice));
        }
        else if (advice instanceof DynamicIntroductionAdvice) {
            // We need an IntroductionAdvisor for this kind of introduction.
            throw new AopConfigException("DynamicIntroductionAdvice may only be added as part of IntroductionAdvisor");
        }
        else {
            addAdvisor(pos, new DefaultPointcutAdvisor(advice));
        }
    }

    @Override
    public boolean removeAdvice(Advice advice) throws AopConfigException {
        int index = indexOf(advice);
        if (index == -1) {
            return false;
        }
        else {
            removeAdvisor(index);
            return true;
        }
    }

    @Override
    public int indexOf(Advice advice) {
        Assert.notNull(advice, "Advice must not be null");
        for (int i = 0; i < this.advisors.size(); i++) {
            Advisor advisor = this.advisors.get(i);
            if (advisor.getAdvice() == advice) {
                return i;
            }
        }
        return -1;
    }

    protected void adviceChanged() {
        // 清除方法缓存
        this.methodCache.clear();
    }


    // Method的简单包装类，作为methodCache的Key
    private static final class MethodCacheKey implements Comparable<MethodCacheKey> {

        private final Method method;

        private final int hashCode;

        public MethodCacheKey(Method method) {
            this.method = method;
            this.hashCode = method.hashCode();
        }

        @Override
        public int compareTo(MethodCacheKey other) {
            // 先比较方法名称
            int result = this.method.getName().compareTo(other.method.getName());
            if (result == 0) {
                // 再比较方法签名
                result = this.method.toString().compareTo(other.method.toString());
            }
            return result;
        }
    }
}

ProxyCreatorSupport

简介

代理工厂的基础类，提供对可配置的AopProxyFactory的便捷访问；

核心代码

public class ProxyCreatorSupport extends AdvisedSupport {

    private AopProxyFactory aopProxyFactory;

    private final List<AdvisedSupportListener> listeners = new ArrayList<>();

    // 初始状态未激活，当创建第一个代理对象时设置为true
    private boolean active = false;


    public ProxyCreatorSupport() {
        this.aopProxyFactory = new DefaultAopProxyFactory();
    }

    public ProxyCreatorSupport(AopProxyFactory aopProxyFactory) {
        Assert.notNull(aopProxyFactory, "AopProxyFactory must not be null");
        this.aopProxyFactory = aopProxyFactory;
    }

    protected final synchronized AopProxy createAopProxy() {
        if (!this.active) {
            activate();
        }
        // 通过AopProxyFactory创建代理对象
        return getAopProxyFactory().createAopProxy(this);
    }

    private void activate() {
        this.active = true;
        // 通知激活
        for (AdvisedSupportListener listener : this.listeners) {
            listener.activated(this);
        }
    }

    @Override
    protected void adviceChanged() {
        super.adviceChanged();
        synchronized (this) {
            if (this.active) {
                // 通知变动
                for (AdvisedSupportListener listener : this.listeners) {
                    listener.adviceChanged(this);
                }
            }
        }
    }

    protected final synchronized boolean isActive() {
        return this.active;
    }
}

ProxyFactory

简介

支持自定义获取和配置AOP代理实例的代理实例工厂；

核心代码

public class ProxyFactory extends ProxyCreatorSupport {

    public Object getProxy() {
        // 使用默认地ClassLoader创建代理对象
        return createAopProxy().getProxy();
    }

    public Object getProxy(@Nullable ClassLoader classLoader) {
        // 使用指定的ClassLoader创建代理对象
        return createAopProxy().getProxy(classLoader);
    }

    // 根据指定的接口和拦截器创建代理对象
    @SuppressWarnings("unchecked")
    public static <T> T getProxy(Class<T> proxyInterface, Interceptor interceptor) {
        return (T) new ProxyFactory(proxyInterface, interceptor).getProxy();
    }

    // 根据指定的接口和目标对象创建代理对象
    @SuppressWarnings("unchecked")
    public static <T> T getProxy(Class<T> proxyInterface, TargetSource targetSource) {
        return (T) new ProxyFactory(proxyInterface, targetSource).getProxy();
    }

    // 创建继承自目标对象类型的代理对象
    public static Object getProxy(TargetSource targetSource) {
        if (targetSource.getTargetClass() == null) {
            throw new IllegalArgumentException("Cannot create class proxy for TargetSource with null target class");
        }
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTargetSource(targetSource);
        proxyFactory.setProxyTargetClass(true);
        return proxyFactory.getProxy();
    }
}

ProxyFactoryBean

简介

基于Spring BeanFactory中的Bean来创建AOP代理实例的FactoryBean的实现；
Advisor和Advice都是通过bean name指定，最后一个bean name可能是目标对象，但通常目标对象都是通过targetName/target/targetSource属性指定（一旦指定，那么所有bean name只能是Advisor或者Advice）；

核心代码

public class ProxyFactoryBean extends ProxyCreatorSupport
        implements FactoryBean<Object>, BeanClassLoaderAware, BeanFactoryAware {

    @Override
    @Nullable
    public Object getObject() throws BeansException {
        initializeAdvisorChain();
        if (isSingleton()) {
            // 单例则会缓存
            return getSingletonInstance();
        }
        else {
            if (this.targetName == null) {
                logger.info("Using non-singleton proxies with singleton targets is often undesirable. " +
                        "Enable prototype proxies by setting the 'targetName' property.");
            }
            // 多例则每次创建新实例
            return newPrototypeInstance();
        }
    }

    private synchronized Object getSingletonInstance() {
        if (this.singletonInstance == null) {
            this.targetSource = freshTargetSource();
            // 自动检测代理的接口
            if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
                // Rely on AOP infrastructure to tell us what interfaces to proxy.
                Class<?> targetClass = getTargetClass();
                if (targetClass == null) {
                    throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
                }
                // 设置代理的接口
                setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
            }
            // Initialize the shared singleton instance.
            super.setFrozen(this.freezeProxy);
            // 创建代理对象
            this.singletonInstance = getProxy(createAopProxy());
        }
        return this.singletonInstance;
    }

    private synchronized Object newPrototypeInstance() {
        // 通过当前配置的拷贝创建代理对象
        ProxyCreatorSupport copy = new ProxyCreatorSupport(getAopProxyFactory());

        TargetSource targetSource = freshTargetSource();
        copy.copyConfigurationFrom(this, targetSource, freshAdvisorChain());
        if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
            // Rely on AOP infrastructure to tell us what interfaces to proxy.
            Class<?> targetClass = targetSource.getTargetClass();
            if (targetClass != null) {
                copy.setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
            }
        }
        copy.setFrozen(this.freezeProxy);

        // 创建代理对象
        return getProxy(copy.createAopProxy());
    }

    protected Object getProxy(AopProxy aopProxy) {
        return aopProxy.getProxy(this.proxyClassLoader);
    }

    @Override
    protected void adviceChanged() {
        super.adviceChanged();
        if (this.singleton) {
            logger.debug("Advice has changed; re-caching singleton instance");
            synchronized (this) {
                // 清除缓存的单例
                this.singletonInstance = null;
            }
        }
    }
}

AspectJProxyFactory

简介

基于AspectJ的代理工厂，支持创建持有AspectJ切面的代理对象；

核心代码

public class AspectJProxyFactory extends ProxyCreatorSupport {

    public void addAspect(Object aspectInstance) {
        Class<?> aspectClass = aspectInstance.getClass();
        String aspectName = aspectClass.getName();
        AspectMetadata am = createAspectMetadata(aspectClass, aspectName);
        if (am.getAjType().getPerClause().getKind() != PerClauseKind.SINGLETON) {
            throw new IllegalArgumentException(
                    "Aspect class [" + aspectClass.getName() + "] does not define a singleton aspect");
        }
        addAdvisorsFromAspectInstanceFactory(
                new SingletonMetadataAwareAspectInstanceFactory(aspectInstance, aspectName));
    }

    public void addAspect(Class<?> aspectClass) {
        String aspectName = aspectClass.getName();
        AspectMetadata am = createAspectMetadata(aspectClass, aspectName);
        MetadataAwareAspectInstanceFactory instanceFactory = createAspectInstanceFactory(am, aspectClass, aspectName);
        addAdvisorsFromAspectInstanceFactory(instanceFactory);
    }

    private void addAdvisorsFromAspectInstanceFactory(MetadataAwareAspectInstanceFactory instanceFactory) {
        List<Advisor> advisors = this.aspectFactory.getAdvisors(instanceFactory);
        Class<?> targetClass = getTargetClass();
        Assert.state(targetClass != null, "Unresolvable target class");
        advisors = AopUtils.findAdvisorsThatCanApply(advisors, targetClass);
        AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(advisors);
        AnnotationAwareOrderComparator.sort(advisors);
        addAdvisors(advisors);
    }

    private AspectMetadata createAspectMetadata(Class<?> aspectClass, String aspectName) {
        AspectMetadata am = new AspectMetadata(aspectClass, aspectName);
        if (!am.getAjType().isAspect()) {
            throw new IllegalArgumentException("Class [" + aspectClass.getName() + "] is not a valid aspect type");
        }
        return am;
    }

    private MetadataAwareAspectInstanceFactory createAspectInstanceFactory(
            AspectMetadata am, Class<?> aspectClass, String aspectName) {

        MetadataAwareAspectInstanceFactory instanceFactory;
        if (am.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
            // Create a shared aspect instance.
            Object instance = getSingletonAspectInstance(aspectClass);
            instanceFactory = new SingletonMetadataAwareAspectInstanceFactory(instance, aspectName);
        }
        else {
            // Create a factory for independent aspect instances.
            instanceFactory = new SimpleMetadataAwareAspectInstanceFactory(aspectClass, aspectName);
        }
        return instanceFactory;
    }

    private Object getSingletonAspectInstance(Class<?> aspectClass) {
        return aspectCache.computeIfAbsent(aspectClass,
                clazz -> new SimpleAspectInstanceFactory(clazz).getAspectInstance());
    }

    @SuppressWarnings("unchecked")
    public <T> T getProxy() {
        return (T) createAopProxy().getProxy();
    }

    @SuppressWarnings("unchecked")
    public <T> T getProxy(ClassLoader classLoader) {
        return (T) createAopProxy().getProxy(classLoader);
    }
}