天瑕
天瑕

较真儿学源码系列-Spring AOP核心流程源码分析

        Spring Framework版本：5.2.8.RELEASE。

        因为Spring AOP依赖于IoC容器来管理，所以需要首先来掌握Spring IoC的实现（《较真儿学源码系列-Spring IoC核心流程源码分析》）。

1 简介

        AOP（Aspect Oriented Programming），即面向切面编程。指的是在原有的代码基础之上，又包装了一层。使得可以在方法前后、抛出异常、正常返回等时机点做自定义的增强处理，让代码有一种横向进行统一处理的能力。AOP可以有很多的实现场景，包括常见的日志记录、权限验证和异常处理等。我在之前的公司项目中也曾经用Spring AOP来封装了图数据库Neo4j的事务。用了环绕通知和自定义注解，不仅去掉了冗余的try-catch写法，还解决了嵌套事务导致性能低下的问题。

1.1 AOP术语

1.1.1 切面（Aspect）

        切面就是在一个怎样的环境中工作。比如数据库的事务直接贯穿了整个代码层面，这就是一个切面，它可以定义后面需要介绍的各类通知、切点等内容，然后Spring AOP会将其定义的内容织入到约定的流程中，在动态代理中可以把它理解成一个拦截器。具体表现是一个使用了@Aspect注解的类就被称为一个切面。

1.1.2 连接点（Joinpoint）

        连接点对应的是具体需要增强的东西，比如通过切点表达式去判断哪些方法是连接点，从而织入对应的通知。

1.1.3 目标对象（Target object）

        目标对象指的是要被增强的对象，也就是包含连接点的对象。

1.1.4 通知（Advice）

        通知是切面开启后、切面的方法。它根据在代理对象真实方法调用前后的顺序和逻辑区分。

  • 前置通知（before）：在调用原有对象方法前执行的通知功能。
  • 后置通知（after）：在调用原有对象方法后执行的通知功能。无论是否抛出异常，它都会被执行。
  • 返回通知（afterReturning）：在调用原有对象方法后正常返回（无异常）执行的通知功能。
  • 异常通知（afterThrowing）：在调用原有对象方法产生异常后执行的通知功能。
  • 环绕通知（around）：相当于前四种通知的整合，当然也可以取代当前被拦截对象的方法。

1.1.5 切点（Pointcut）

        这是一个告诉AOP在什么时候启动拦截并织入对应的流程，因为并不是所有的开发都需要启动AOP的，所以可以通过切点表达式或自定义注解来进行限定。

1.1.6 织入（Weaving）

        将通知切入连接点的过程叫织入。

1.1.7 顾问（Advisor）

        实际上Advisor并不是AOP的术语之一，但却是Spring AOP源码中的内部概念。Advisor是通知和切点的整合，用来管理它们。后面的源码分析中会看到这点。

1.2 Spring AOP与AspectJ

        Spring AOP是AOP在Spring中的实现，而提到AOP就不得不提AspectJ。AspectJ框架来自于Eclipse基金会，不同于Spring AOP是通过动态代理来实现的（JDK动态代理或CGLIB代理），AspectJ是通过静态织入的方式来实现（编译期织入、编译后织入和类加载期织入）。所以在代码运行前就完成了织入，性能要更高。除此之外AspectJ还能干很多Spring AOP不能干的事，是一个很强大的AOP框架。但这并不意味着Spring AOP就一无是处了，Spring AOP致力于解决企业级开发中最普遍遇到的AOP需求，而不是像AspectJ一样成为一个提供最完整AOP实现的框架。

        Spring AOP沿用了AspectJ中的一些概念（切点表达式以及通知注解），但实现是Spring AOP自己实现的。

2 @EnableAspectJAutoProxy注解

        开启AOP需要添加@EnableAspectJAutoProxy注解，那么首先就来看一下其实现：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

    boolean proxyTargetClass() default false;

    boolean exposeProxy() default false;

}

        可以看到第4行代码处@Import了一个类：AspectJAutoProxyRegistrar。继续来看一下它的实现：

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

        //注册internalAutoProxyCreator这个bean定义
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

        AnnotationAttributes enableAspectJAutoProxy =
                AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAspectJAutoProxy != null) {
            //添加proxyTargetClass属性值为true
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            //添加exposeProxy属性值为true
            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }

}

        可以看到AspectJAutoProxyRegistrar类中只有一个方法：registerBeanDefinitions。那么它是什么时候被调用的呢？结合之前对Spring IoC的分析可知，完整的调用链：(AnnotationConfigApplicationContext)->refresh(AbstractApplicationContext)->invokeBeanFactoryPostProcessors(AbstractApplicationContext)->invokeBeanFactoryPostProcessors(PostProcessorRegistrationDelegate)->invokeBeanDefinitionRegistryPostProcessors(PostProcessorRegistrationDelegate)->postProcessBeanDefinitionRegistry(ConfigurationClassPostProcessor)->processConfigBeanDefinitions(ConfigurationClassPostProcessor)->loadBeanDefinitions(ConfigurationClassBeanDefinitionReader)->loadBeanDefinitionsForConfigurationClass(ConfigurationClassBeanDefinitionReader)->loadBeanDefinitionsFromRegistrars(ConfigurationClassBeanDefinitionReader)->registerBeanDefinitions(ImportBeanDefinitionRegistrar)->registerBeanDefinitions(AspectJAutoProxyRegistrar)

        继续来看registerBeanDefinitions方法的实现，第8行代码处会调用registerAspectJAnnotationAutoProxyCreatorIfNecessary方法：

/**
 * AopConfigUtils:
 */
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
    return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
}

@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
        BeanDefinitionRegistry registry, @Nullable Object source) {

    return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}

@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(
        Class cls, BeanDefinitionRegistry registry, @Nullable Object source) {

    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");

    /*
    只是开启AOP而没开启事务的话，是不会走入到下面的if条件中来的
    这个if条件我会留在之后对事务源码进行分析的文章中进行说明
     */
    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
        BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
        if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
            int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
            int requiredPriority = findPriorityForClass(cls);
            if (currentPriority < requiredPriority) {
                apcDefinition.setBeanClassName(cls.getName());
            }
        }
        return null;
    }

    /*
    如果此时没有AUTO_PROXY_CREATOR_BEAN_NAME这个bean定义，
    就往容器中注册AnnotationAwareAspectJAutoProxyCreator这个bean定义
     */
    RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
    beanDefinition.setSource(source);
    beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
    beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
    return beanDefinition;
}

3 AnnotationAwareAspectJAutoProxyCreator继承图

        在上面第13行代码处注册了AnnotationAwareAspectJAutoProxyCreator，下面来看一下其继承图：

较真儿学源码系列-Spring AOP核心流程源码分析_第1张图片

        可以看到，AnnotationAwareAspectJAutoProxyCreator本质上就是一个BeanPostProcessor。同时因为实现了InstantiationAwareBeanPostProcessor接口，所以可以调用其postProcessBeforeInstantiation方法，缓存切面信息。

        之前我在分析Spring IoC的源码文章中说过，正常情况下创建AOP对象是在postProcessAfterInitialization方法中创建的，而在循环依赖时则改为了在getEarlyBeanReference方法中创建。postProcessAfterInitialization是BeanPostProcessor中的方法；同时AnnotationAwareAspectJAutoProxyCreator还实现了SmartInstantiationAwareBeanPostProcessor接口，所以getEarlyBeanReference方法也是可以调用到的了。

        下面就来分别看一下这几个方法的实现。

4 postProcessBeforeInstantiation方法

        完整的调用链：(AnnotationConfigApplicationContext)->refresh(AbstractApplicationContext)->finishBeanFactoryInitialization(AbstractApplicationContext)->preInstantiateSingletons(DefaultListableBeanFactory)->getBean(AbstractBeanFactory)->doGetBean(AbstractBeanFactory)->getSingleton(DefaultSingletonBeanRegistry)->getObject(AbstractBeanFactory)->createBean(AbstractAutowireCapableBeanFactory)->resolveBeforeInstantiation(AbstractAutowireCapableBeanFactory)->applyBeanPostProcessorsBeforeInstantiation(AbstractAutowireCapableBeanFactory)->postProcessBeforeInstantiation(AbstractAutoProxyCreator)

/**
 * AbstractAutoProxyCreator:
 */
@Override
public Object postProcessBeforeInstantiation(Class beanClass, String beanName) {
    //构建缓存key
    Object cacheKey = getCacheKey(beanClass, beanName);

    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
        //如果已经解析过，就直接返回
        if (this.advisedBeans.containsKey(cacheKey)) {
            return null;
        }
        //判断是不是基础的bean，或者应不应该跳过
        if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
            //如果属于上面的条件之一，就将其设置为不需要代理的
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }

    /*
    获取自定义的TargetSource，如果有的话，就会创建代理对象（除非容器中有TargetSourceCreator，
    并且实现了TargetSource接口，否则一般情况下不会获取到的）
     */
    TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
    if (targetSource != null) {
        if (StringUtils.hasLength(beanName)) {
            this.targetSourcedBeans.add(beanName);
        }
        Object[] specificInterceptors = (beanClass, beanName, targetSource);
        //创建AOP代理对象
        Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    return null;
}

/**
 * 第7行代码处：
 */
protected Object getCacheKey(Class beanClass, @Nullable String beanName) {
    if (StringUtils.hasLength(beanName)) {
        //如果是FactoryBean的话，就加上“&”前缀
        return (FactoryBean.class.isAssignableFrom(beanClass) ?
                BeanFactory.FACTORY_BEAN_PREFIX + beanName : beanName);
    } else {
        //如果beanName为空的话，就返回beanClass
        return beanClass;
    }
}

/**
 * AnnotationAwareAspectJAutoProxyCreator:
 * 第15行代码处：
 */
@Override
protected boolean isInfrastructureClass(Class beanClass) {
    //判断是不是基础的bean，或者是不是切面
    return (super.isInfrastructureClass(beanClass) ||
            (this.aspectJAdvisorFactory != null && this.aspectJAdvisorFactory.isAspect(beanClass)));
}

/**
 * AbstractAutoProxyCreator:
 * 第62行代码处：
 */
protected boolean isInfrastructureClass(Class beanClass) {
    //Advice、Pointcut、Advisor和AopInfrastructureBean被视为基础类
    boolean retVal = Advice.class.isAssignableFrom(beanClass) ||
            Pointcut.class.isAssignableFrom(beanClass) ||
            Advisor.class.isAssignableFrom(beanClass) ||
            AopInfrastructureBean.class.isAssignableFrom(beanClass);
    if (retVal && logger.isTraceEnabled()) {
        logger.trace("Did not attempt to auto-proxy infrastructure class [" + beanClass.getName() + "]");
    }
    return retVal;
}

/**
 * AbstractAspectJAdvisorFactory:
 * 第63行代码处：
 */
@Override
public boolean isAspect(Class clazz) {
    //是否有切面注解，并且不是由AspectJ编译的（AspectJ编程中有很多的“ajc$”前缀，以此来进行判断）
    return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
}

private boolean hasAspectAnnotation(Class clazz) {
    //类上面是否含有@Aspect注解
    return (AnnotationUtils.findAnnotation(clazz, Aspect.class) != null);
}

/**
 * AspectJAwareAdvisorAutoProxyCreator:
 * 第15行代码处：
 */
@Override
protected boolean shouldSkip(Class beanClass, String beanName) {
    //找到候选的Advisor
    List candidateAdvisors = findCandidateAdvisors();
    for (Advisor advisor : candidateAdvisors) {
        //如果Advisor是AspectJPointcutAdvisor类型的（XML），并且名称和给定的beanName是一致的，就是需要跳过的
        if (advisor instanceof AspectJPointcutAdvisor &&
                ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
            return true;
        }
    }
    //返回false
    return super.shouldSkip(beanClass, beanName);
}

/**
 * AnnotationAwareAspectJAutoProxyCreator:
 * 第104行代码处：
 */
@Override
protected List findCandidateAdvisors() {
    //找到事务相关的Advisor（当前没有事务操作，所以在这里会找不到）
    List advisors = super.findCandidateAdvisors();
    if (this.aspectJAdvisorsBuilder != null) {
        //构建切面Advisor
        advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
    }
    return advisors;
}

/**
 * BeanFactoryAspectJAdvisorsBuilder
 * 第126行代码处：
 */
public List buildAspectJAdvisors() {
    //获取缓存中的切面名称
    List aspectNames = this.aspectBeanNames;

    //如果没有获取到
    if (aspectNames == null) {
        synchronized (this) {
            //双重检查
            aspectNames = this.aspectBeanNames;
            if (aspectNames == null) {
                //保存解析出来的Advisor集合
                List advisors = new ArrayList<>();
                aspectNames = new ArrayList<>();
                //因为传入的是Object，所以这里是在容器中获取所有的bean名称
                String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                        this.beanFactory, Object.class, true, false);
                for (String beanName : beanNames) {
                    //判断bean是否是合适的
                    if (!isEligibleBean(beanName)) {
                        continue;
                    }
                    //通过bean名称来获取到相应的bean类型
                    Class beanType = this.beanFactory.getType(beanName);
                    if (beanType == null) {
                        continue;
                    }
                    //判断bean是不是切面
                    if (this.advisorFactory.isAspect(beanType)) {
                        //如果是的话就加入到aspectNames集合中
                        aspectNames.add(beanName);
                        AspectMetadata amd = new AspectMetadata(beanType, beanName);
                        if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                            //构建切面的实例工厂
                            MetadataAwareAspectInstanceFactory factory =
                                    new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                            //获取Advisor集合
                            List classAdvisors = this.advisorFactory.getAdvisors(factory);
                            /*
                            加入到缓存中（如果是单例就放进advisorsCache缓存中，否则就放进aspectFactoryCache缓存中）
                            因为在上面第149行代码处是从容器中获取所有的bean名称，然后再逐个进行解析的，这个消耗是很大的
                            （如果bean很多的话），所以解析完是需要放入到缓存中的，以此来提高效率
                             */
                            if (this.beanFactory.isSingleton(beanName)) {
                                this.advisorsCache.put(beanName, classAdvisors);
                            } else {
                                this.aspectFactoryCache.put(beanName, factory);
                            }
                            //添加进advisors集合中
                            advisors.addAll(classAdvisors);
                        } else {
                            if (this.beanFactory.isSingleton(beanName)) {
                                throw new IllegalArgumentException("Bean with name '" + beanName +
                                        "' is a singleton, but aspect instantiation model is not singleton");
                            }
                            //构建多例对象切面的实例工厂
                            MetadataAwareAspectInstanceFactory factory =
                                    new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
                            //加入到aspectFactoryCache缓存中
                            this.aspectFactoryCache.put(beanName, factory);
                            //获取Advisor集合，并添加进advisors集合中
                            advisors.addAll(this.advisorFactory.getAdvisors(factory));
                        }
                    }
                }
                //给this.aspectBeanNames进行赋值，下次就不会进行重复解析了
                this.aspectBeanNames = aspectNames;
                return advisors;
            }
        }
    }

    if (aspectNames.isEmpty()) {
        return Collections.emptyList();
    }
    List advisors = new ArrayList<>();
    //把advisorsCache和aspectFactoryCache缓存融合进一个advisors集合中并最终返回
    for (String aspectName : aspectNames) {
        List cachedAdvisors = this.advisorsCache.get(aspectName);
        if (cachedAdvisors != null) {
            advisors.addAll(cachedAdvisors);
        } else {
            MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
            advisors.addAll(this.advisorFactory.getAdvisors(factory));
        }
    }
    return advisors;
}

/**
 * ReflectiveAspectJAdvisorFactory:
 * 第171行、第195行和第217行代码处：
 */
@Override
public List getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
    //获取切面类
    Class aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
    //获取切面名称
    String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
    validate(aspectClass);

    MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
            new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);

    List advisors = new ArrayList<>();
    //获取切面中的所有方法（除了被@Pointcut注解标注的方法）
    for (Method method : getAdvisorMethods(aspectClass)) {
        //解析切面中的方法
        Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);
        if (advisor != null) {
            advisors.add(advisor);
        }
    }

    //如果需要延迟初始化，就加入一个SyntheticInstantiationAdvisor
    if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
        Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
        advisors.add(0, instantiationAdvisor);
    }

    //如果有@DeclareParents注解，就加入一个DeclareParentsAdvisor
    for (Field field : aspectClass.getDeclaredFields()) {
        Advisor advisor = getDeclareParentsAdvisor(field);
        if (advisor != null) {
            advisors.add(advisor);
        }
    }

    return advisors;
}

/**
 * 第240行代码处：
 */
private List getAdvisorMethods(Class aspectClass) {
    final List methods = new ArrayList<>();
    ReflectionUtils.doWithMethods(aspectClass, method -> {
        //排除被@Pointcut注解标注的方法
        if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {
            methods.add(method);
        }
    }, ReflectionUtils.USER_DECLARED_METHODS);
    if (methods.size() > 1) {
        /*
        对方法进行排序（后面会看到AOP是通过责任链的方式来实现的，所以必须要进行排序，否则逻辑会有问题）
        会按照@Around->@Before->@After->@AfterReturning->@AfterThrowing这个顺序进行排序
         */
        methods.sort(METHOD_COMPARATOR);
    }
    return methods;
}

/**
 * ReflectionUtils:
 * 第270行代码处：
 */
public static void doWithMethods(Class clazz, MethodCallback mc, @Nullable MethodFilter mf) {
    //根据class类型获取到相应的所有方法
    Method[] methods = getDeclaredMethods(clazz, false);
    for (Method method : methods) {
        if (mf != null && !mf.matches(method)) {
            continue;
        }
        try {
            //回调doWith方法
            mc.doWith(method);
        } catch (IllegalAccessException ex) {
            throw new IllegalStateException("Not allowed to access method '" + method.getName() + "': " + ex);
        }
    }
    if (clazz.getSuperclass() != null && (mf != USER_DECLARED_METHODS || clazz.getSuperclass() != Object.class)) {
        //处理父类
        doWithMethods(clazz.getSuperclass(), mc, mf);
    } else if (clazz.isInterface()) {
        //处理接口
        for (Class superIfc : clazz.getInterfaces()) {
            doWithMethods(superIfc, mc, mf);
        }
    }
}

/**
 * ReflectiveAspectJAdvisorFactory:
 * 第242行代码处：
 */
@Override
@Nullable
public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
                          int declarationOrderInAspect, String aspectName) {

    validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());

    //获取切点表达式
    AspectJExpressionPointcut expressionPointcut = getPointcut(
            candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
    if (expressionPointcut == null) {
        return null;
    }

    //实例化一个切点Advisor实现类
    return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
            this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}

/**
 * InstantiationModelAwarePointcutAdvisorImpl:
 */
public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
                                                  Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
                                                  MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {

    //进行属性赋值
    this.declaredPointcut = declaredPointcut;
    this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
    this.methodName = aspectJAdviceMethod.getName();
    this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
    this.aspectJAdviceMethod = aspectJAdviceMethod;
    this.aspectJAdvisorFactory = aspectJAdvisorFactory;
    this.aspectInstanceFactory = aspectInstanceFactory;
    this.declarationOrder = declarationOrder;
    this.aspectName = aspectName;

    //判断当前的切面对象是否需要延迟实例化
    if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
        Pointcut preInstantiationPointcut = Pointcuts.union(
                aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);

        this.pointcut = new InstantiationModelAwarePointcutAdvisorImpl.PerTargetInstantiationModelPointcut(
                this.declaredPointcut, preInstantiationPointcut, aspectInstanceFactory);
        this.lazy = true;
    } else {
        this.pointcut = this.declaredPointcut;
        this.lazy = false;
        //实例化Advice对象
        this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
    }
}

private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) {
    Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut,
            this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
    return (advice != null ? advice : EMPTY_ADVICE);
}

/**
 * ReflectiveAspectJAdvisorFactory:
 * 第373行代码处：
 */
@Override
@Nullable
public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
                        MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {

    //获取切面类Class对象
    Class candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
    validate(candidateAspectClass);

    //获取切面方法上的注解
    AspectJAnnotation aspectJAnnotation =
            AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
    if (aspectJAnnotation == null) {
        return null;
    }

    //判断是否是切面类
    if (!isAspect(candidateAspectClass)) {
        throw new AopConfigException("Advice must be declared inside an aspect type: " +
                "Offending method '" + candidateAdviceMethod + "' in class [" +
                candidateAspectClass.getName() + "]");
    }

    if (logger.isDebugEnabled()) {
        logger.debug("Found AspectJ method: " + candidateAdviceMethod);
    }

    AbstractAspectJAdvice springAdvice;

    //获取方法上的注解
    switch (aspectJAnnotation.getAnnotationType()) {
        case AtPointcut:
            //如果是@Pointcut注解，就直接返回null，因为在之前第272行代码处已经排除了@Pointcut注解标注的方法
            if (logger.isDebugEnabled()) {
                logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
            }
            return null;
        case AtAround:
            //如果是@Around注解，构建AspectJAroundAdvice
            springAdvice = new AspectJAroundAdvice(
                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            break;
        case AtBefore:
            //如果是@Before注解，构建AspectJMethodBeforeAdvice
            springAdvice = new AspectJMethodBeforeAdvice(
                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            break;
        case AtAfter:
            //如果是@After注解，构建AspectJAfterAdvice
            springAdvice = new AspectJAfterAdvice(
                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            break;
        case AtAfterReturning:
            //如果是@AfterReturning注解，构建AspectJAfterReturningAdvice
            springAdvice = new AspectJAfterReturningAdvice(
                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
            if (StringUtils.hasText(afterReturningAnnotation.returning())) {
                springAdvice.setReturningName(afterReturningAnnotation.returning());
            }
            break;
        case AtAfterThrowing:
            //如果是@AfterThrowing注解，构建AspectJAfterThrowingAdvice
            springAdvice = new AspectJAfterThrowingAdvice(
                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
            if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
                springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
            }
            break;
        default:
            throw new UnsupportedOperationException(
                    "Unsupported advice type on method: " + candidateAdviceMethod);
    }

    //配置Advice属性
    springAdvice.setAspectName(aspectName);
    springAdvice.setDeclarationOrder(declarationOrder);
    String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
    if (argNames != null) {
        springAdvice.setArgumentNamesFromStringArray(argNames);
    }
    springAdvice.calculateArgumentBindings();

    return springAdvice;
}

/**
 * AbstractAspectJAdvisorFactory:
 * 第393行代码处：
 */
@SuppressWarnings("unchecked")
@Nullable
protected static AspectJAnnotation findAspectJAnnotationOnMethod(Method method) {
    /*
    获取切面方法上的注解，找到一个就直接返回（ASPECTJ_ANNOTATION_CLASSES包含
    @Pointcut、@Around、@Before、@After、@AfterReturning和@AfterThrowing注解）
     */
    for (Class clazz : ASPECTJ_ANNOTATION_CLASSES) {
        AspectJAnnotation foundAnnotation = findAnnotation(method, (Class) clazz);
        if (foundAnnotation != null) {
            return foundAnnotation;
        }
    }
    return null;
}

5 postProcessAfterInitialization & getEarlyBeanReference
方法

        再次强调一下：如果是在正常的情况下，创建AOP对象是在initializeBean方法中的applyBeanPostProcessorsAfterInitialization方法中进行的；而如果有循环依赖的话，创建AOP对象则是放在了getEarlyBeanReference方法中。

        正常情况下的调用链：(AnnotationConfigApplicationContext)->refresh(AbstractApplicationContext)->finishBeanFactoryInitialization(AbstractApplicationContext)->preInstantiateSingletons(DefaultListableBeanFactory)->getBean(AbstractBeanFactory)->doGetBean(AbstractBeanFactory)->getSingleton(DefaultSingletonBeanRegistry)->getObject(AbstractBeanFactory)->createBean(AbstractAutowireCapableBeanFactory)->doCreateBean(AbstractAutowireCapableBeanFactory)->initializeBean(AbstractAutowireCapableBeanFactory)->applyBeanPostProcessorsAfterInitialization(AbstractAutowireCapableBeanFactory)->postProcessAfterInitialization(AbstractAutoProxyCreator)

        循环依赖时的调用链：(AnnotationConfigApplicationContext)->refresh(AbstractApplicationContext)->finishBeanFactoryInitialization(AbstractApplicationContext)->preInstantiateSingletons(DefaultListableBeanFactory)->getBean(AbstractBeanFactory)->（省略中间循环依赖的过程，直接跳到第二次调用同一个bean的时候）->getBean(AbstractBeanFactory)->doGetBean(AbstractBeanFactory)->getSingleton(DefaultSingletonBeanRegistry)->getSingleton(DefaultSingletonBeanRegistry)->getObject(AbstractAutowireCapableBeanFactory)->getEarlyBeanReference(AbstractAutowireCapableBeanFactory)->getEarlyBeanReference(AbstractAutoProxyCreator)（注：其中红色表示的是重载方法）

/**
 * AbstractAutoProxyCreator:
 * 正常情况下
 */
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        //构建缓存key
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        /*
        因为循环依赖时会在下面的getEarlyBeanReference方法中创建AOP对象，而该方法会往earlyProxyReferences集合中
        放入cacheKey。所以在正常情况下也就是本方法中，此时已经不是循环依赖了，就需要remove掉。remove的结果不等于bean，
        说明此时earlyProxyReferences集合中没有当前bean；而如果相等，就没有必要调用wrapIfNecessary方法了，因为肯定
        已经在getEarlyBeanReference方法中调用过了
         */
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

/**
 * 循环依赖时
 */
@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
    //构建缓存key
    Object cacheKey = getCacheKey(bean.getClass(), beanName);
    //往earlyProxyReferences集合中放入当前cacheKey
    this.earlyProxyReferences.put(cacheKey, bean);
    return wrapIfNecessary(bean, beanName, cacheKey);
}

/**
 * 第17行和第32行代码处：
 */
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    //已经被处理过，直接返回
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    //不需要代理增强的，直接返回
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    /*
    这里会再次调用isInfrastructureClass和shouldSkip方法来判断是不是基础的bean，或者是不是需要跳过的
    （其中会再次走进findCandidateAdvisors->buildAspectJAdvisors方法中，但这次不会再重新解析了，
    因为aspectBeanNames缓存中已经有值了）
     */
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        //如果属于上面的条件之一，就将其设置为不需要代理的
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    //找到合适的Advisors
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        //需要代理就设置成TRUE
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        //创建AOP代理对象
        Object proxy = createProxy(
                bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        //放入到缓存中
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    //如果不需要代理，就设置成FALSE
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

/**
 * AbstractAdvisorAutoProxyCreator:
 * 第59行代码处：
 */
@Override
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(
        Class beanClass, String beanName, @Nullable TargetSource targetSource) {

    //找到合适的Advisor
    List advisors = findEligibleAdvisors(beanClass, beanName);
    //如果没找到就返回DO_NOT_PROXY
    if (advisors.isEmpty()) {
        return DO_NOT_PROXY;
    }
    //否则就返回找到的Advisor
    return advisors.toArray();
}

/**
 * 第86行代码处：
 */
protected List findEligibleAdvisors(Class beanClass, String beanName) {
    /*
    这里和上面一样，也会调用findCandidateAdvisors方法，以此来寻找缓存中的候选Advisor集合
    但因为之前已经缓存了，所以这里不用再解析一遍了
     */
    List candidateAdvisors = findCandidateAdvisors();
    //从候选的Advisor集合中找出能匹配的上切点的Advisor
    List eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    //在Advisor集合中添加一个内置的Advisor（ExposeInvocationInterceptor）
    extendAdvisors(eligibleAdvisors);
    //这里又会再一次对Advisor进行排序
    if (!eligibleAdvisors.isEmpty()) {
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}

/**
 * 第105行代码处：
 */
protected List findAdvisorsThatCanApply(
        List candidateAdvisors, Class beanClass, String beanName) {

    //用来记录当前代理Bean的名称
    ProxyCreationContext.setCurrentProxiedBeanName(beanName);
    try {
        //从候选的Advisor中找出能匹配的上切点的Advisor
        return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
    } finally {
        //清除当前代理Bean的名称
        ProxyCreationContext.setCurrentProxiedBeanName(null);
    }
}

/**
 * AopUtils:
 * 第125行代码处：
 */
public static List findAdvisorsThatCanApply(List candidateAdvisors, Class clazz) {
    //如果候选的Advisor为空，就直接返回
    if (candidateAdvisors.isEmpty()) {
        return candidateAdvisors;
    }
    List eligibleAdvisors = new ArrayList<>();
    for (Advisor candidate : candidateAdvisors) {
        /*
        如果候选的Advisor是IntroductionAdvisor类型的（@DeclareParents），并且能匹配的上切点的话，
        就添加进eligibleAdvisors集合中
         */
        if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
            eligibleAdvisors.add(candidate);
        }
    }
    boolean hasIntroductions = !eligibleAdvisors.isEmpty();
    for (Advisor candidate : candidateAdvisors) {
        //如果候选的Advisor是IntroductionAdvisor类型的
        if (candidate instanceof IntroductionAdvisor) {
            //在上面已经处理过了，这里不需要再处理
            continue;
        }
        /*
        如果候选的Advisor不是IntroductionAdvisor类型的，也去判断是否能匹配的上切点
        如果能就也添加进eligibleAdvisors集合中
         */
        if (canApply(candidate, clazz, hasIntroductions)) {
            eligibleAdvisors.add(candidate);
        }
    }
    return eligibleAdvisors;
}

/**
 * 第147行代码处：
 */
public static boolean canApply(Advisor advisor, Class targetClass) {
    return canApply(advisor, targetClass, false);
}

/**
 * 第162行和第173行代码处：
 */
public static boolean canApply(Advisor advisor, Class targetClass, boolean hasIntroductions) {
    if (advisor instanceof IntroductionAdvisor) {
        //如果Advisor是IntroductionAdvisor类型的，就使用它的方法来查看是否匹配切点
        return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
    } else if (advisor instanceof PointcutAdvisor) {
        //如果Advisor是PointcutAdvisor类型的，就进行强转
        PointcutAdvisor pca = (PointcutAdvisor) advisor;
        //并且判断是否能真正匹配上切点
        return canApply(pca.getPointcut(), targetClass, hasIntroductions);
    } else {
        //没有切入点就假设它能用
        return true;
    }
}

/**
 * 第187行代码处：
 */
public static boolean canApply(Pointcut pc, Class targetClass, boolean hasIntroductions) {
    Assert.notNull(pc, "Pointcut must not be null");
    //查看是否匹配切点，如果不匹配，就直接返回false
    if (!pc.getClassFilter().matches(targetClass)) {
        return false;
    }

    //获取方法匹配器
    MethodMatcher methodMatcher = pc.getMethodMatcher();
    if (methodMatcher == MethodMatcher.TRUE) {
        return true;
    }

    //判断方法匹配器是不是IntroductionAwareMethodMatcher类型的，如果是就进行强转
    IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
    if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
        introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
    }

    Set> classes = new LinkedHashSet<>();
    //判断当前Class是否是动态生成的目标类，如果不是的话
    if (!Proxy.isProxyClass(targetClass)) {
        //添加当前Class进classes集合中，如果是CGLIB生成的子类，则添加其父类进classes集合中
        classes.add(ClassUtils.getUserClass(targetClass));
    }
    //添加当前Class所实现的所有接口进classes集合中
    classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));

    for (Class clazz : classes) {
        //获取到classes集合中每一个class中的所有方法
        Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
        for (Method method : methods) {
            //通过方法匹配器进行匹配（匹配成功一个就直接返回true）
            if (introductionAwareMethodMatcher != null ?
                    introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
                    methodMatcher.matches(method, targetClass)) {
                return true;
            }
        }
    }

    return false;
}

/**
 * AbstractAutoProxyCreator
 * 第64行代码处：
 */
protected Object createProxy(Class beanClass, @Nullable String beanName,
                             @Nullable Object[] specificInterceptors, TargetSource targetSource) {

    if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
        //如果当前容器是ConfigurableListableBeanFactory类型的，就设置originalTargetClass属性
        AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    }

    //创建一个代理工厂
    ProxyFactory proxyFactory = new ProxyFactory();
    //复制配置属性
    proxyFactory.copyFrom(this);

    //如果@EnableAspectJAutoProxy注解中的proxyTargetClass属性为false（为false代表JDK动态代理）
    if (!proxyFactory.isProxyTargetClass()) {
        //检查bean定义的preserveTargetClass属性值是否为true
        if (shouldProxyTargetClass(beanClass, beanName)) {
            //如果为true就设置代理工厂的proxyTargetClass属性为true
            proxyFactory.setProxyTargetClass(true);
        } else {
            /*
            否则就将bean上实现的接口应用于proxyFactory上（如果要代理的类没有接口的话，
            即使proxyTargetClass为false，也会在这里被修正为true）
             */
            evaluateProxyInterfaces(beanClass, proxyFactory);
        }
    }

    //构建Advisor的集合（包含上面找到的能匹配上切点的Advisor以及通用拦截器）
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    //代理工厂加上这些Advisor
    proxyFactory.addAdvisors(advisors);
    //代理工厂设置TargetSource
    proxyFactory.setTargetSource(targetSource);
    //空实现，提供干预点
    customizeProxyFactory(proxyFactory);

    //此时冻结配置
    proxyFactory.setFrozen(this.freezeProxy);
    //是否预先筛选，如果是的话就将该属性设置进代理工厂里
    if (advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }

    //这里是在真正地创建代理对象
    return proxyFactory.getProxy(getProxyClassLoader());
}

/**
 * ProxyFactory:
 */
public Object getProxy(@Nullable ClassLoader classLoader) {
    return createAopProxy().getProxy(classLoader);
}

/**
 * ProxyCreatorSupport:
 */
protected final synchronized AopProxy createAopProxy() {
    if (!this.active) {
        //激活代理配置
        activate();
    }
    return getAopProxyFactory().createAopProxy(this);
}

/**
 * DefaultAopProxyFactory:
 * 有接口 proxyTargetClass = false 使用JDK
 * 有接口 proxyTargetClass = true 使用CGLIB
 * 没有接口 proxyTargetClass = false 使用CGLIB（这种情况下proxyTargetClass会在上面第269行代码处里面被修正为true）
 * 没有接口 proxyTargetClass = true 使用CGLIB
 */
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    /*
    是否设置的代理应该执行激进的优化；
    或者@EnableAspectJAutoProxy注解中的proxyTargetClass属性为true（为true代表CGLIB代理）；
    又或者配置类的代理接口是否实现了SpringProxy接口（或者根本没有实现任何代理接口）
     */
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
        Class targetClass = config.getTargetClass();
        if (targetClass == null) {
            throw new AopConfigException("TargetSource cannot determine target class: " +
                    "Either an interface or a target is required for proxy creation.");
        }
        //如果被代理的类是接口，又或者被代理的类是动态生成的，就创建JDK动态代理
        if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
            return new JdkDynamicAopProxy(config);
        }
        //否则就创建CGLIB代理
        return new ObjenesisCglibAopProxy(config);
    } else {
        //上面三个条件都不满足的话，就创建JDK动态代理
        return new JdkDynamicAopProxy(config);
    }
}

/**
 * JdkDynamicAopProxy:
 * 第297行代码处：
 * 这里以JDK动态代理为例
 */
@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
    if (logger.isTraceEnabled()) {
        logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
    }
    //获取所有JDK动态代理的接口
    Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
    //如果接口上有equals或者hashCode方法，就将这两个标志位置为true
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    //通过Proxy.newProxyInstance的方式来创建JDK动态代理
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

6 invoke方法

        方法调用以默认的JDK动态代理为例，在调用目标方法时会首先调用到JdkDynamicAopProxy的invoke方法：

/**
 * JdkDynamicAopProxy:
 */
@Override
@Nullable
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    Object oldProxy = null;
    boolean setProxyContext = false;

    //获取代理的目标类
    TargetSource targetSource = this.advised.targetSource;
    Object target = null;

    try {
        if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
            //判断代理的方法是否是equals方法，如果是的话就不进行代理
            return equals(args[0]);
        } else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
            //判断代理的方法是否是hashCode方法，如果是的话就不进行代理
            return hashCode();
        } else if (method.getDeclaringClass() == DecoratingProxy.class) {
            //如果调用的是DecoratingProxy类中的getDecoratedClass方法，就不会使用增强，直接返回目标类
            return AopProxyUtils.ultimateTargetClass(this.advised);
        } else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                method.getDeclaringClass().isAssignableFrom(Advised.class)) {
            //如果代理的是Advised的子接口，就直接反射调用目标方法，也不会进行增强
            return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
        }

        Object retVal;

        /*
        这里就是在找@EnableAspectJAutoProxy注解中的exposeProxy配置值，如果为true，就是需要暴露代理对象的
        JDK动态代理中一个方法调用同一个类中的其它方法时是不会被增强的，所以需要暴露代理对象，以解决这个问题
         */
        if (this.advised.exposeProxy) {
            //设置代理对象缓存（ThreadLocal）
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }

        //获取目标类实例
        target = targetSource.getTarget();
        //获取目标类Class对象
        Class targetClass = (target != null ? target.getClass() : null);

        //获取方法上的拦截器链（把之前获取到的Advisor转换成拦截器）
        List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

        if (chain.isEmpty()) {
            //如果没有拦截器链，就直接反射调用目标方法（连接点）就行了
            Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
            retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
        } else {
            //创建反射方法调用对象
            MethodInvocation invocation =
                    new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
            //通过责任链调用目标方法
            retVal = invocation.proceed();
        }

        //获取目标方法返回值类型
        Class returnType = method.getReturnType();
        if (retVal != null && retVal == target &&
                returnType != Object.class && returnType.isInstance(proxy) &&
                !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
            //如果返回值是目标类，就返回代理类
            retVal = proxy;
        } else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
            //如果返回值是null，但是返回类型不是Void，说明执行目标方法抛出异常了，所以也在这里抛出异常
            throw new AopInvocationException(
                    "Null return value from advice does not match primitive return type for: " + method);
        }
        return retVal;
    } finally {
        if (target != null && !targetSource.isStatic()) {
            targetSource.releaseTarget(target);
        }
        if (setProxyContext) {
            AopContext.setCurrentProxy(oldProxy);
        }
    }
}

/**
 * ReflectiveMethodInvocation:
 * 第59行代码处：
 * 调用各个通知和目标方法
 */
@Override
@Nullable
public Object proceed() throws Throwable {
    //当拦截器（通知）的索引计数已经到了最后一个，这个时候就需要调用目标方法（连接点）了
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return invokeJoinpoint();
    }

    //获取下一个通知（通过拦截器索引计数+1的方式来获取）
    Object interceptorOrInterceptionAdvice =
            this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
        //如果是InterceptorAndDynamicMethodMatcher类型的通知，则进行特殊处理
        InterceptorAndDynamicMethodMatcher dm =
                (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
        Class targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
        if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
            return dm.interceptor.invoke(this);
        } else {
            //动态匹配失败的话，就跳过当前通知，继续调用下一个
            return proceed();
        }
    } else {
        //这里会使用责任链模式和递归的方式来逐个调用所有的通知
        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}

/**
 * 第95行代码处：
 */
@Nullable
protected Object invokeJoinpoint() throws Throwable {
    //反射调用目标方法（连接点）
    return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
} 
  
6.1 ExposeInvocationInterceptor
 
  
/**
 * ExposeInvocationInterceptor:
 */
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
    //获取缓存中的旧值
    MethodInvocation oldInvocation = invocation.get();
    //缓存当前正在执行的方法调用信息（ThreadLocal）
    invocation.set(mi);
    try {
        //调用下一个通知或目标方法
        return mi.proceed();
    } finally {
        //缓存重新赋值为旧值
        invocation.set(oldInvocation);
    }
}
 
  
6.2 环绕通知
 
  
/**
 * AspectJAroundAdvice:
 */
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
    if (!(mi instanceof ProxyMethodInvocation)) {
        throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
    }
    ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
    ProceedingJoinPoint pjp = lazyGetProceedingJoinPoint(pmi);
    JoinPointMatch jpm = getJoinPointMatch(pmi);
    //执行环绕通知
    return invokeAdviceMethod(pjp, jpm, null, null);
}

/**
 * AbstractAspectJAdvice:
 */
protected Object invokeAdviceMethod(JoinPoint jp, @Nullable JoinPointMatch jpMatch,
                                    @Nullable Object returnValue, @Nullable Throwable t) throws Throwable {

    return invokeAdviceMethodWithGivenArgs(argBinding(jp, jpMatch, returnValue, t));
}

protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
    Object[] actualArgs = args;
    if (this.aspectJAdviceMethod.getParameterCount() == 0) {
        actualArgs = null;
    }
    try {
        //setAccessible(true)
        ReflectionUtils.makeAccessible(this.aspectJAdviceMethod);
        //这里最终会调用到使用者自己写的环绕通知代码
        return this.aspectJAdviceMethod.invoke(this.aspectInstanceFactory.getAspectInstance(), actualArgs);
    } catch (IllegalArgumentException ex) {
        throw new AopInvocationException("Mismatch on arguments to advice method [" +
                this.aspectJAdviceMethod + "]; pointcut expression [" +
                this.pointcut.getPointcutExpression() + "]", ex);
    } catch (InvocationTargetException ex) {
        throw ex.getTargetException();
    }
}

/**
 * MethodInvocationProceedingJoinPoint:
 * 在使用者自己写的环绕通知代码中，一般会调用“joinPoint.proceed();”，也就是本方法
 * 不调用的话就不会执行后续的通知或目标方法了
 */
@Override
public Object proceed() throws Throwable {
    //这里依然会调用到上面所说的ReflectiveMethodInvocation.proceed方法，也就是执行调用链的下一个通知或目标方法
    return this.methodInvocation.invocableClone().proceed();
}
 
  
6.3 前置通知
 
  
/**
 * MethodBeforeAdviceInterceptor:
 */
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
    //执行前置通知（可以看到，在目标方法前面执行，所以是前置通知）
    this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
    //调用下一个通知或目标方法
    return mi.proceed();
}
 
  
6.4 后置通知
 
  
/**
 * AspectJAfterAdvice:
 */
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
    try {
        //调用下一个通知或目标方法
        return mi.proceed();
    } finally {
        //执行后置通知（可以看到，finally子句保证了即使目标方法抛出异常了，后置通知也能继续执行下去）
        invokeAdviceMethod(getJoinPointMatch(), null, null);
    }
}
 
  
6.5 返回通知
 
  
/**
 * AfterReturningAdviceInterceptor:
 */
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
    //调用下一个通知或目标方法
    Object retVal = mi.proceed();
    //执行返回通知（可以看到，在目标方法后面执行，所以是返回通知。但如果目标方法抛出异常了，返回通知则不会执行）
    this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
    return retVal;
}
 
  
6.6 异常通知
 
  
/**
 * AspectJAfterThrowingAdvice:
 */
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
    try {
        //调用下一个通知或目标方法
        return mi.proceed();
    } catch (Throwable ex) {
        if (shouldInvokeOnThrowing(ex)) {
            //执行异常通知（可以看到，catch子句保证了如果目标方法抛出异常了会走到这里）
            invokeAdviceMethod(getJoinPointMatch(), null, ex);
        }
        //这里很重要，将异常继续往上抛出去，确保不会吞异常
        throw ex;
    }
}
 
  
 
  
7 责任链流程图
 
  
        各个通知之间是通过责任链和递归的方式来进行调用的，具体的执行逻辑如下图所示：
 
  
较真儿学源码系列-Spring AOP核心流程源码分析_第2张图片
 
  
 
  
 
   
原创不易，未得准许，请勿转载，翻版必究
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring,Framework,Spring,Spring,AOP,Spring,AOP源码分析)

        

            

                
    
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • JVM源码分析之堆外内存完全解读
                        HeapDump性能社区

                        
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • spring mvc @RequestBody String类型参数
                        zoyation
spring-mvcspringmvc
                        
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    
                    
    • 
                    
  • Java -jar 如何在后台运行项目
                        vincent_hahaha

                        
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    
                    
    • 
                    
  • spring security中几大组件的作用和执行顺序
                        阿信在这里
javaspring
                        
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    
                    
    • 
                    
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
                        网顺技术团队
成品程序项目javavue.js汽车课程设计springboot
                        
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    
                    
    • 
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                    
  • Java面试笔记记录6
                        今天背八股了吗
java面试笔记
                        
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    
                    
    • 
                    
  • 【C#生态园】深度剖析：C#嵌入式开发工具大揭秘
                        friklogff
C#生态园c#开发语言
                        
    C#嵌入式开发：全面了解六大框架与库前言随着物联网和嵌入式系统的快速发展，越来越多的开发者开始关注使用C#语言进行嵌入式开发。本文将介绍几种用于C#的嵌入式开发框架和相关库，以及它们的核心功能、安装配置方法和API概览，帮助读者了解并选择适合自己项目的工具和资源。欢迎订阅专栏：C#生态园文章目录C#嵌入式开发：全面了解六大框架与库前言1.nanoFramework：一个用于C#的嵌入式开发框架1.
    
                    
    • 
                    
  • Golang Channel
                        PandaSkr
golang
                        
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
    
                    
    • 
                    
  • Sentinel
                        眼泪落在琴弦
springcloudjavajava
                        
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    
                    
    • 
                    
  • Spring @Async 深度解读：默认线程池执行器的配置与优化
                        小码快撩
springjava前端
                        
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    
                    
    • 
                    
  • Sentinel实时监控不展示问题
                        朱杰jjj
sentinelsentinel
                        
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    
                    
    • 
                    
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    
                    
    • 
                    
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
                        码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
                        
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                    
  • 软件测试/测试开发/全日制 |利用Django REST framework构建微服务
                        霍格沃兹-慕漓
django微服务sqlite
                        
    霍格沃兹测试开发学社推出了《Python全栈开发与自动化测试班》。本课程面向开发人员、测试人员与运维人员，课程内容涵盖Python编程语言、人工智能应用、数据分析、自动化办公、平台开发、UI自动化测试、接口测试、性能测试等方向。为大家提供更全面、更深入、更系统化的学习体验，课程还增加了名企私教服务内容，不仅有名企经理为你1v1辅导，还有行业专家进行技术指导，针对性地解决学习、工作中遇到的难题。让找
    
                    
    • 
                    
  • 深入理解AOP（面向切面编程）及其应用
                        自身就是太阳
java开发语言spring
                        
    目录AOP的核心概念AOP的实现方式1.定义DAO接口和实现类2.定义通知类3.开启AOP注解驱动切入点表达式通配符的使用：AOP通知类型案例分析：测量业务层接口的执行效率结论概述：AOP（Aspect-OrientedProgramming，面向切面编程）是一种编程范式，主要用于将共性功能从具体的业务逻辑中分离出来，实现松耦合的代码设计。其作用是在不修改原始代码的情况下，对现有方法进行增强，广泛
    
                    
    • 
                    
  • Java集合类框架源码分析 之 RoleList源码解析 【6】
                        yunzhonghefei
Java集合类源码分析RoleList源码解析
                        
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    
                    
    • 
                    
  • Spring Security静态资源过滤（11）
                        小黑屋说YYDS
spring
                        
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
    
                    
    • 
                    
  • Spring Security定义多个过滤器链（10）
                        小黑屋说YYDS
spring
                        
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
    
                    
    • 
                                
  • 解读Servlet原理篇二---GenericServlet与HttpServlet
                                    周凡杨
javaHttpServlet源理GenericService源码
                                    
    在上一篇《解读Servlet原理篇一》中提到，要实现javax.servlet.Servlet接口（即写自己的Servlet应用），你可以写一个继承自javax.servlet.GenericServletr的generic Servlet ，也可以写一个继承自java.servlet.http.HttpServlet的HTTP Servlet（这就是为什么我们自定义的Servlet通常是exte
    
                                
    • 
                                
  • MySQL性能优化
                                    bijian1013
数据库mysql
                                    
            性能优化是通过某些有效的方法来提高MySQL的运行速度，减少占用的磁盘空间。性能优化包含很多方面，例如优化查询速度，优化更新速度和优化MySQL服务器等。本文介绍方法的主要有： 
        a.优化查询 
        b.优化数据库结构 
  
    
                                
    • 
                                
  • ThreadPool定时重试
                                    dai_lm
javaThreadPoolthreadtimertimertask
                                    
    项目需要当某事件触发时，执行http请求任务，失败时需要有重试机制，并根据失败次数的增加，重试间隔也相应增加，任务可能并发。 
由于是耗时任务，首先考虑的就是用线程来实现，并且为了节约资源，因而选择线程池。 
为了解决不定间隔的重试，选择Timer和TimerTask来完成 
 
 

package threadpool;

public class ThreadPoolTest {


    
                                
    • 
                                
  • Oracle 查看数据库的连接情况
                                    周凡杨
sqloracle 连接
                                    
    首先要说的是，不同版本数据库提供的系统表会有不同，你可以根据数据字典查看该版本数据库所提供的表。 
 
select * from dict where table_name like '%SESSION%'; 
就可以查出一些表，然后根据这些表就可以获得会话信息 
 
select sid,serial#,status,username,schemaname,osuser,terminal,ma
    
                                
    • 
                                
  • 类的继承
                                    朱辉辉33
java
                                    
    类的继承可以提高代码的重用行，减少冗余代码；还能提高代码的扩展性。Java继承的关键字是extends 
格式:public class 类名（子类）extends 类名（父类）{ } 
子类可以继承到父类所有的属性和普通方法，但不能继承构造方法。且子类可以直接使用父类的public和 
protected属性，但要使用private属性仍需通过调用。 
子类的方法可以重写，但必须和父类的返回值类
    
                                
    • 
                                
  • android 悬浮窗特效
                                    肆无忌惮_
android
                                    
    最近在开发项目的时候需要做一个悬浮层的动画，类似于支付宝掉钱动画。但是区别在于，需求是浮出一个窗口，之后边缩放边位移至屏幕右下角标签处。效果图如下： 
  
一开始考虑用自定义View来做。后来发现开线程让其移动很卡，ListView+动画也没法精确定位到目标点。 
  
后来想利用Dialog的dismiss动画来完成。 
  
自定义一个Dialog后，在styl
    
                                
    • 
                                
  • hadoop伪分布式搭建
                                    林鹤霄
hadoop
                                    
    要修改4个文件    1: vim hadoop-env.sh  第九行    2: vim core-site.xml            <configuration>     &n
    
                                
    • 
                                
  • gdb调试命令
                                    aigo
gdb
                                    
    原文：http://blog.csdn.net/hanchaoman/article/details/5517362 
  
一、GDB常用命令简介 
     r run 运行.程序还没有运行前使用   c             cuntinue 
    
                                
    • 
                                
  • Socket编程的HelloWorld实例
                                    alleni123
socket
                                    
    public class Client
{
	
	
	public static void main(String[] args)
	{	
		Client c=new Client();
	 	c.receiveMessage();
	}
	
	public void receiveMessage(){
		Socket s=null;
		
		BufferedRea
    
                                
    • 
                                
  • 线程同步和异步
                                    百合不是茶
线程同步异步
                                    
    多线程和同步 : 如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行；B依言执行，再将结果给A；A再继续操作。  所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法  
  
多线程和异步:多线程可以做不同的事情,涉及到线程通知 
  
  
&
    
                                
    • 
                                
  • JSP中文乱码分析
                                    bijian1013
javajsp中文乱码
                                    
            在JSP的开发过程中，经常出现中文乱码的问题。 
        首先了解一下Java中文问题的由来： 
        Java的内核和class文件是基于unicode的，这使Java程序具有良好的跨平台性，但也带来了一些中文乱码问题的麻烦。原因主要有两方面，
    
                                
    • 
                                
  • js实现页面跳转重定向的几种方式
                                    bijian1013
JavaScript重定向
                                    
            js实现页面跳转重定向有如下几种方式： 
一.window.location.href 
<script language="javascript"type="text/javascript"> 
	window.location.href="http://www.baidu.c
    
                                
    • 
                                
  • 【Struts2三】Struts2 Action转发类型
                                    bit1129
struts2
                                    
     在【Struts2一】 Struts Hello World http://bit1129.iteye.com/blog/2109365中配置了一个简单的Action，配置如下 
  
<!DOCTYPE struts PUBLIC  
        "-//Apache Software Foundation//DTD Struts Configurat
    
                                
    • 
                                
  • 【HBase十一】Java API操作HBase
                                    bit1129
hbase
                                    
    Admin类的主要方法注释： 
  1. 创建表 
 /**
   * Creates a new table. Synchronous operation.
   *
   * @param desc table descriptor for table
   * @throws IllegalArgumentException if the table name is res
    
                                
    • 
                                
  • nginx gzip
                                    ronin47
nginx gzip
                                    
    Nginx GZip 压缩  
Nginx GZip 模块文档详见：http://wiki.nginx.org/HttpGzipModule 
常用配置片段如下：  
gzip on; gzip_comp_level 2; # 压缩比例，比例越大，压缩时间越长。默认是1 gzip_types text/css text/javascript; # 哪些文件可以被压缩 gzip_disable &q
    
                                
    • 
                                
  • java-7.微软亚院之编程判断俩个链表是否相交 给出俩个单向链表的头指针，比如 h1 ， h2 ，判断这俩个链表是否相交
                                    bylijinnan
java
                                    
    

public class LinkListTest {

	/**
	 * we deal with two main missions:
	 * 
	 * A.
	 * 1.we create two joined-List(both have no loop)
	 * 2.whether list1 and list2 join
	 * 3.print the join
    
                                
    • 
                                
  • Spring源码学习-JdbcTemplate batchUpdate批量操作
                                    bylijinnan
javaspring
                                    
    Spring JdbcTemplate的batch操作最后还是利用了JDBC提供的方法，Spring只是做了一下改造和封装 
 
JDBC的batch操作： 
 
 


String sql = "INSERT INTO CUSTOMER " +
				  "(CUST_ID, NAME, AGE) VALUES (?, ?, ?)";
				
    
                                
    • 
                                
  • [JWFD开源工作流]大规模拓扑矩阵存储结构最新进展
                                    comsci
工作流
                                    
        生成和创建类已经完成,构造一个100万个元素的矩阵模型,存储空间只有11M大,请大家参考我在博客园上面的文档"构造下一代工作流存储结构的尝试",更加相信的设计和代码将陆续推出......... 
 
    竞争对手的能力也很强.......,我相信..你们一定能够先于我们推出大规模拓扑扫描和分析系统的....
    
                                
    • 
                                
  • base64编码和url编码
                                    cuityang
base64url
                                    
    import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.io.PrintWriter; 
import java.io.StringWriter; 
import java.io.UnsupportedEncodingException; 
    
                                
    • 
                                
  • web应用集群Session保持
                                    dalan_123
session
                                    
    关于使用 memcached 或redis 存储 session ，以及使用 terracotta 服务器共享。建议使用 redis，不仅仅因为它可以将缓存的内容持久化，还因为它支持的单个对象比较大，而且数据类型丰富，不只是缓存 session，还可以做其他用途，一举几得啊。1、使用 filter 方法存储这种方法比较推荐，因为它的服务器使用范围比较多，不仅限于tomcat ，而且实现的原理比较简
    
                                
    • 
                                
  • Yii 框架里数据库操作详解-[增加、查询、更新、删除的方法 'AR模式']
                                    dcj3sjt126com
数据库
                                    
        public function getMinLimit () {        $sql = "...";        $result = yii::app()->db->createCo
    
                                
    • 
                                
  • solr StatsComponent（聚合统计）
                                    eksliang
solr聚合查询solr stats
                                    
    StatsComponent 
转载请出自出处：http://eksliang.iteye.com/blog/2169134 
http://eksliang.iteye.com/ 一、概述 
       Solr可以利用StatsComponent 实现数据库的聚合统计查询，也就是min、max、avg、count、sum的功能 
  二、参数
    
                                
    • 
                                
  • 百度一道面试题
                                    greemranqq
位运算百度面试寻找奇数算法bitmap 算法
                                    
    那天看朋友提了一个百度面试的题目：怎么找出{1,1,2,3,3,4,4,4,5,5,5,5}  找出出现次数为奇数的数字. 
  
我这里复制的是原话，当然顺序是不一定的，很多拿到题目第一反应就是用map,当然可以解决，但是效率不高。 
  
还有人觉得应该用算法xxx,我是没想到用啥算法好...！ 
  
还有觉得应该先排序... 
  
还有觉
    
                                
    • 
                                
  • Spring之在开发中使用SpringJDBC
                                    ihuning
spring
                                    
      
在实际开发中使用SpringJDBC有两种方式： 
  
1. 在Dao中添加属性JdbcTemplate并用Spring注入； 
    JdbcTemplate类被设计成为线程安全的，所以可以在IOC 容器中声明它的单个实例，并将这个实例注入到所有的 DAO 实例中。JdbcTemplate也利用了Java 1.5 的特定(自动装箱，泛型，可变长度
    
                                
    • 
                                
  • JSON API 1.0 核心开发者自述 | 你所不知道的那些技术细节
                                    justjavac
json
                                    
    2013年5月，Yehuda Katz 完成了JSON API(英文，中文) 技术规范的初稿。事情就发生在 RailsConf 之后，在那次会议上他和 Steve Klabnik 就 JSON 雏形的技术细节相聊甚欢。在沟通单一 Rails 服务器库—— ActiveModel::Serializers 和单一 JavaScript 客户端库——&
    
                                
    • 
                                
  • 网站项目建设流程概述
                                    macroli
工作
                                    
    一.概念 
网站项目管理就是根据特定的规范、在预算范围内、按时完成的网站开发任务。 
二.需求分析 
项目立项 
　　我们接到客户的业务咨询，经过双方不断的接洽和了解，并通过基本的可行性讨论够，初步达成制作协议，这时就需要将项目立项。较好的做法是成立一个专门的项目小组，小组成员包括：项目经理，网页设计，程序员，测试员，编辑/文档等必须人员。项目实行项目经理制。 
客户的需求说明书 
　　第一步是需
    
                                
    • 
                                
  • AngularJs 三目运算 表达式判断
                                    qiaolevip
每天进步一点点学习永无止境众观千象AngularJS
                                    
    事件回顾：由于需要修改同一个模板，里面包含2个不同的内容，第一个里面使用的时间差和第二个里面名称不一样，其他过滤器，内容都大同小异。希望杜绝If这样比较傻的来判断if-show or not，继续追究其源码。 
var b = "{{",
      a = "}}";
        this.startSymbol = function(a) {

    
                                
    • 
                                
  • Spark算子：统计RDD分区中的元素及数量
                                    superlxw1234
sparkspark算子Spark RDD分区元素
                                    
    关键字：Spark算子、Spark RDD分区、Spark RDD分区元素数量 
  
  
Spark RDD是被分区的，在生成RDD时候，一般可以指定分区的数量，如果不指定分区数量，当RDD从集合创建时候，则默认为该程序所分配到的资源的CPU核数，如果是从HDFS文件创建，默认为文件的Block数。 
  
可以利用RDD的mapPartitionsWithInd
    
                                
    • 
                                
  • Spring 3.2.x将于2016年12月31日停止支持
                                    wiselyman
Spring 3
                                    
          
        Spring 团队公布在2016年12月31日停止对Spring Framework 3.2.x（包含tomcat 6.x）的支持。在此之前spring团队将持续发布3.2.x的维护版本。 
  
       请大家及时准备及时升级到Spring 
    
                                
    • 
                                
  • fis纯前端解决方案fis-pure
                                    zccst
JavaScript
                                    
    作者：zccst 
 
FIS通过插件扩展可以完美的支持模块化的前端开发方案，我们通过FIS的二次封装能力，封装了一个功能完备的纯前端模块化方案pure。 
 
 
1，fis-pure的安装 
$ fis install -g fis-pure 
$ pure -v 
0.1.4 
 
 
2，下载demo到本地 
git clone https://github.com/hefangshi/f
    
                                
    •