源码断点示例代码

AOP切面类

package orange;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.PriorityOrdered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class Aop implements PriorityOrdered {

    //指定切入点表达式，拦截那些方法，即为那些类生成代理对象
    //@Pointcut("execution(* com.bie.aop.UserDao.save(..))")  ..代表所有参数
    //@Pointcut("execution(* com.bie.aop.UserDao.*())")  指定所有的方法
    //@Pointcut("execution(* com.bie.aop.UserDao.save())") 指定save方法

    @Pointcut("execution(* tyrant.*.log(..))")
    public void pointCut(){

    }

    @Before("pointCut()")
    public void Before(){
        System.out.println("Before");
    }

    @After("pointCut()")
    public void After(){
        System.out.println("After");
    }

    @AfterThrowing("pointCut()")
    public void AfterThrowing(){
        System.out.println("AfterThrowing");
    }

    @AfterReturning("pointCut()")
    public void AfterReturning(){
        System.out.println("AfterReturning");
    }

    @Around("execution(* tyrant.*.log(..))")
    public void Around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Around Before");
        joinPoint.proceed();
        System.out.println("Around After");
    }

    @Override
    public int getOrder() {
        return 1;
    }
}

事务管理器

package orange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionException;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionStatus;
import org.springframework.transaction.support.SimpleTransactionStatus;

@Configuration("transactionManager")
public class MyPlatformTransactionManager implements PlatformTransactionManager {
    @Override
    public TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
            System.out.println("getTransaction");
            return new SimpleTransactionStatus();
    }

    @Override
    public void commit(TransactionStatus status) throws TransactionException {
            System.out.println("commit");
    }

    @Override
    public void rollback(TransactionStatus status) throws TransactionException {
            System.out.println("rollback");
    }
}

启动配置类

package orange;
import org.springframework.context.annotation.*;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import tyrant.Config;

@ComponentScan()
@EnableAspectJAutoProxy(proxyTargetClass = true)
@EnableTransactionManagement(mode = AdviceMode.PROXY)
@Configuration
public class BeanConfig  {
}

Bean

package orange;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

@Component
public class AopLog {
    @Transactional("transactionManager")
    public String log() {
            System.out.println("----切面----");
            return "1";
    }
}

启动类

package orange;

import org.springframework.context.annotation.AnnotatedBeanDefinitionReader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import java.util.Map;

public class TestOrangeCondition {
    public static void main(String[] args) {
		/**
		 * 创建一个BeanDefinition读取器 根据注解读取
		 * 创建一个BeanDefinition扫描器 能够扫描一个类或者包 转换成bd
		**/
        AnnotationConfigApplicationContext context = new 
            				AnnotationConfigApplicationContext();
        //注册配置类
        context.register(BeanConfig.class);
        context.refresh();
        Class<?>[] interfaces = AopLog.class.getInterfaces();
        AopLog aopLog =  context.getBean("aopLog",AopLog.class);
        aopLog.log();
    }
}

1.new AnnotationConfigApplicationContext()

public AnnotationConfigApplicationContext() {
    //java 用class描述类
    //spring 用BeanDefinition 描述bean
    //调用构造方法时需要首先调用父类GenericApplicationContext的构造方法
    //在父类的构造方法里会初始化一个DefaultListableBeanFactory
    //this.beanFactory = new DefaultListableBeanFactory();
    // this 代表的是AnnotationConfigApplicationContext
    /*
    注册了5个RootBeanDefinition
    RootBeanDefinition df = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
    RootBeanDefinition df = newRootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
    RootBeanDefinition df = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
    RootBeanDefinition df = new RootBeanDefinition(EventListenerMethodProcessor.class);
    RootBeanDefinition df = new RootBeanDefinition(DefaultEventListenerFactory.class);
    */
    //创建一个BeanDefinition读取器 可以根据注解读取 BeanDefinition
    this.reader = new AnnotatedBeanDefinitionReader(this);
    //创建一个BeanDefinition扫描器 能够扫描一个类或者包 转换成bd
    this.scanner = new ClassPathBeanDefinitionScanner(this);
}

1.1调用父类构造,创建DefaultListableBeanFactory

调用构造方法时需要首先调用父类GenericApplicationContext的构造方法,在父类GenericApplicationContext的构造方法里会初始化一个DefaultListableBeanFactory。

this.beanFactory = new DefaultListableBeanFactory();

1.2.new AnnotatedBeanDefinitionReader(this)

创建一个BeanDefinition读取器 可以根据注解读取BeanDefinition

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
        //registry 代表的是AnnotationConfigApplicationContext
        this(registry, getOrCreateEnvironment(registry));
    }

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    Assert.notNull(environment, "Environment must not be null");
    this.registry = registry;
    this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

1.2.1获取StandardEnvironment

private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
    //获取StandardEnvironment
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    if (registry instanceof EnvironmentCapable) {
        //获取 systemProperties  放入StandardEnvironment
        //获取 systemEnvironment 放入StandardEnvironment
        return ((EnvironmentCapable) registry).getEnvironment();
    }
    return new StandardEnvironment();
}

1.2.2注册5个ConfigProcessors的Definition

注册了5个RootBeanDefinition,添加到Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

//这个ConfigurationClassPostProcessor非常非常非常重要
RootBeanDefinition def = new 
            RootBeanDefinition(ConfigurationClassPostProcessor.class);
RootBeanDefinition def = new 
            RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
RootBeanDefinition def = new 
            RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
RootBeanDefinition def = new 
            RootBeanDefinition(EventListenerMethodProcessor.class);
RootBeanDefinition def = new 
            RootBeanDefinition(DefaultEventListenerFactory.class);

1.2.2.1ConfigurationClassPostProcessor

贴了2个比较重要的方法:

//BeanDefinitionRegistryPostProcessor:
//postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)

//BeanFactoryPostProcessor:
//postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 

@Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        System.out.println("tyrant ConfigurationClassPostProcessor");
        int registryId = System.identityHashCode(registry);
        if (this.registriesPostProcessed.contains(registryId)) {
            throw new IllegalStateException(
                    "postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
        }
        if (this.factoriesPostProcessed.contains(registryId)) {
            throw new IllegalStateException(
                    "postProcessBeanFactory already called on this post-processor against " + registry);
        }
        this.registriesPostProcessed.add(registryId);
        //处理配置类的bean定义信息
        processConfigBeanDefinitions(registry);
    }
​
    /**
     * Prepare the Configuration classes for servicing bean requests at runtime
     * by replacing them with CGLIB-enhanced subclasses.
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        System.out.println("tyrant postProcessBeanFactory");
        int factoryId = System.identityHashCode(beanFactory);
        if (this.factoriesPostProcessed.contains(factoryId)) {
            throw new IllegalStateException
                                ("postProcessBeanFactory already called on 
                                       this post-processor against " + beanFactory);
        }
        this.factoriesPostProcessed.add(factoryId);
        if (!this.registriesPostProcessed.contains(factoryId)) {
            // BeanDefinitionRegistryPostProcessor hook apparently not supported...
            // Simply call processConfigurationClasses lazily at this point then.
            processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
        }
        //用于增强配置类 给FULL类型的配置类增加2个增强回调
        enhanceConfigurationClasses(beanFactory);
        //这里还注册了一个ImportAwareBeanPostProcessor 是一个BeanPostProcessor
        //用于处理增强配置类
        beanFactory.addBeanPostProcessor(new 
                                         ImportAwareBeanPostProcessor(beanFactory));
    }
​

★1.2.2.2AutowiredAnnotationBeanPostProcessor

@AutoWired 和 @Value

@SuppressWarnings("unchecked")
    public AutowiredAnnotationBeanPostProcessor() {
        this.autowiredAnnotationTypes.add(Autowired.class);
        this.autowiredAnnotationTypes.add(Value.class);
        try {
            this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
                    ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
        }
        catch (ClassNotFoundException ex) {
            // JSR-330 API not available - simply skip.
        }
    }

★1.2.2.3CommonAnnotationBeanPostProcessor

@PostConstruct和@PreDestroy

    public CommonAnnotationBeanPostProcessor() {
        setOrder(Ordered.LOWEST_PRECEDENCE - 3);
        setInitAnnotationType(PostConstruct.class);
        setDestroyAnnotationType(PreDestroy.class);
        ignoreResourceType("javax.xml.ws.WebServiceContext");
    }

1.2.2.4EventListenerMethodProcessor

1.2.2.5DefaultEventListenerFactory

1.3.new ClassPathBeanDefinitionScanner(this)

创建一个BeanDefinition扫描器 能够扫描一个类或者包 转换成bd

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
        //默认是true代表的是useDefaultFilters
        this(registry, true);
    }

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
        this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
    }

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,Environment environment) {
        this(registry, useDefaultFilters, environment,
            (registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
    }

★1.3.1includeFilters注册:@Component

@Controller @Repository @Service

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,Environment environment, @Nullable ResourceLoader resourceLoader) {
​
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        this.registry = registry;
        /*
        注册了3个类型过滤器  这也是为什么可以扫描到下面这些注解的原因
        其中 @Component 包含 @Controller @Repository @Service
        this.includeFilters.add(new AnnotationTypeFilter(Component.class));
        下面2个如果没有相关依赖 就不会加入对应的filter
        this.includeFilters.add(javax.inject.ManagedBean)
        this.includeFilters.add(javax.inject.Named)
        */
        if (useDefaultFilters) {
            registerDefaultFilters();
        }
        setEnvironment(environment);
        setResourceLoader(resourceLoader);
    }

protected void registerDefaultFilters() {
        //其中 @Component 包含 @Controller @Repository @Service
        this.includeFilters.add(new AnnotationTypeFilter(Component.class));
        ClassLoader cl = ClassPathScanningCandidateComponentProvider
                                                    .class.getClassLoader();
        try {
            this.includeFilters
                .add(new AnnotationTypeFilter(
                   ((Class<? extends Annotation>) 
                     ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
            
        }
        catch (ClassNotFoundException ex) {
        }
        try {
            this.includeFilters
                .add(new AnnotationTypeFilter(
                    ((Class<? extends Annotation>) 
                        ClassUtils.forName("javax.inject.Named", cl)), false));
        }
        catch (ClassNotFoundException ex) {
    
        }
    }

2.new AnnotatedBeanDefinitionReader(this)

创建一个BeanDefinition读取器 可以根据注解读取BeanDefinition

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment){
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    Assert.notNull(environment, "Environment must not be null");
    this.registry = registry;
    this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
    /*
    注册了5个
    RootBeanDefinition df = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
    RootBeanDefinition df = newRootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
    RootBeanDefinition df = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
    RootBeanDefinition df = new RootBeanDefinition(EventListenerMethodProcessor.class);
    RootBeanDefinition df = new RootBeanDefinition(DefaultEventListenerFactory.class);
    */
    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

2.1获取StandardEnvironment

private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
    //获取StandardEnvironment
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    if (registry instanceof EnvironmentCapable) {
        //获取 systemProperties  放入StandardEnvironment
        //获取 systemEnvironment 放入StandardEnvironment
        return ((EnvironmentCapable) registry).getEnvironment();
    }
    return new StandardEnvironment();
}

2.2注册5个ConfigProcessors的Definition

注册了5个RootBeanDefinition。

然后添加到Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

//这个ConfigurationClassPostProcessor非常非常非常重要
//这个ConfigurationClassPostProcessor非常非常非常重要
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);

2.2.1ConfigurationClassPostProcessor

贴2个比较重要的方法:

//BeanDefinitionRegistryPostProcessor:
//postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)

//BeanFactoryPostProcessor:
//postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    System.out.println("tyrant ConfigurationClassPostProcessor");
    int registryId = System.identityHashCode(registry);
    if (this.registriesPostProcessed.contains(registryId)) {
            throw new IllegalStateException( "postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
    }
    if (this.factoriesPostProcessed.contains(registryId)) {
            throw new IllegalStateException ("postProcessBeanFactory already called on this post-processor against " + registry);
    }
    this.registriesPostProcessed.add(registryId);
    //处理配置类的bean定义信息
    processConfigBeanDefinitions(registry);
}

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    System.out.println("tyrant postProcessBeanFactory");
    int factoryId = System.identityHashCode(beanFactory);
    if (this.factoriesPostProcessed.contains(factoryId)) {
        throw new IllegalStateException("postProcessBeanFactory already called on this post-processor against " + beanFactory);
    }
    this.factoriesPostProcessed.add(factoryId);
    if (!this.registriesPostProcessed.contains(factoryId)) {
        // BeanDefinitionRegistryPostProcessor hook apparently not supported...
        // Simply call processConfigurationClasses lazily at this point then.
        processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
    }
    //用于增强配置类 给FULL类型的配置类增加2个增强回调
    enhanceConfigurationClasses(beanFactory);
    //这里还注册了一个ImportAwareBeanPostProcessor 是一个BeanPostProcessor
    //用于处理增强配置类
    beanFactory.addBeanPostProcessor(new 
                                 ImportAwareBeanPostProcessor(beanFactory));
}

2.2.2AutowiredAnnotationBeanPostProcessor:处理@Auowired@Value

主要用于处理@AutoWired和@Value

@SuppressWarnings("unchecked")
public AutowiredAnnotationBeanPostProcessor() {
    this.autowiredAnnotationTypes.add(Autowired.class);
    this.autowiredAnnotationTypes.add(Value.class);
    try {
        this.autowiredAnnotationTypes
            .add((Class<? extends Annotation>)ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
    }catch (ClassNotFoundException ex) {
    }
}

2.2.3CommonAnnotationBeanPostProcessor

@PostConstruct

@PreDestroy

public CommonAnnotationBeanPostProcessor() {
    setOrder(Ordered.LOWEST_PRECEDENCE - 3);
    setInitAnnotationType(PostConstruct.class);
    setDestroyAnnotationType(PreDestroy.class);
    ignoreResourceType("javax.xml.ws.WebServiceContext");
}

2.2.4EventListenerMethodProcessor

2.2.5DefaultEventListenerFactory

3.new ClassPathBeanDefinitionScanner(this)

创建一个BeanDefinition扫描器 能够扫描一个类或者包 转换成bd

3.1includeFilters注册:@Component

//@Component 包含 @Controller @Repository @Service @Configuration
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
this.includeFilters.add(javax.inject.ManagedBean)
this.includeFilters.add(javax.inject.Named)

4.context.register(BeanConfig.class);

for循环遍历注册配置类: 由register---->registerBean---->doRegisterBean

4.1用AnnotatedBeanDefinitionReader注册配置类BD

public <T> void doRegisterBean(Class<T> beanClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {

    //beanClass是配置类 且使用reader处理 所以使用AnnotatedGenericBeanDefinition
    AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);

    //判断是否需要跳过
    //如果没有加@Conditional注解需要解析。
    //反之需要执行@Conditional注解指定类的match方法来判断是否需要解析
    if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
        return;
    }
    
    //instanceSupplier 是 null
    abd.setInstanceSupplier(instanceSupplier);
    
    //解析@Scope注解 判断单例&多例
    ScopeMetadata scopeMetadata = 			
                    this.scopeMetadataResolver.resolveScopeMetadata(abd);
                    
    //获取类的作用域 getScopeName --->singleton 即单例
    abd.setScope(scopeMetadata.getScopeName());
    
    //生成beanName,默认的beanName是null  
    //判断有没有指定name,如果没有指定name,那么使用驼峰首字母小写的方式作为命名
    String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

    //解析配置类Appconfig上的@LazyInit @Primary @DependsOn @Role @Description 等注解
    //并设置到 AnnotatedGenericBeanDefinition的属性里
    AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
    
    //qualifiers限定符 是传入进来的参数null
    if (qualifiers != null) {  
        for (Class<? extends Annotation> qualifier : qualifiers) {
            if (Primary.class == qualifier) {
                abd.setPrimary(true);
            }
            else if (Lazy.class == qualifier) {
                abd.setLazyInit(true);
            }
            else {
                abd.addQualifier(new AutowireCandidateQualifier(qualifier));
            }
        }
    }
    
    //此处没细看 跳过
    for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
        customizer.customize(abd);
    }
    
    //BeanDefinitionHolder 是一个数据结构 封装了 bd 以及bd的额外信息
    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
    
    //ScopedProxyMode Springmvc
    //多例代理模式？ 此处是ScopedProxyMode.NO
    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode
                                    (scopeMetadata, definitionHolder, this.registry);
                                    
    //同名beanName通过isAllowBeanDefinitionOverriding判断是否可以覆盖
    //注册配置类到BeanDefinitionMap
    //此时有6个beanDefinition
    //5个ConfigProcessors的Definition + 1个BeanConfig的BeanDefinition
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}