脚踏实地

概览

Spring是一个轻量级的Java开源框架，是为了解决企业应用开发的复杂性而创建的。Spring的核心是控制反转（IOC）和面向切面（AOP）。

• IOC叫控制反转，在没用IOC之前都要手动new创建对象，使用IOC之后由容器进行对象的创建，并且由容器来管理对象，减去了开发上的成本，提高了工作效率。
• AOP叫面向切面编程，在实际项目开发中需要嵌入一些与业务不想关的代码的时候就可以使用AOP。比如，权限日志的增加。

Spring虽然把它当成框架来使用，但其本质是一个容器，即IOC容器。里面最核心是如何创建对象和管理对象，包含了Bean的生命周期和Spring的一些扩展点，也包含对AOP的应用。 除此之外，Spring真正的强大之处在于其生态，它包含了Spring Framework、SpringBoot、SpringCloud等一些列框架，极大提高了开发效率。

Spring Framework、SpringBoot和SpringCloud是Java生态系统中常见的三个框架：

• Spring Framework：是整个系列的基础。它提供了核心的IOC容器功能，负责对象的创建和管理，同时支持AOP的应用。Spring Framework的模块化设计使得它可以用于各种应用场景，从传统的Web应用到大规模的企业系统都能够灵活应对。
• SpringBoot构建在SpringFramework之上，是为了简化Spring应用的开发和部署。通过自动配置和起步依赖，SpringBoot大大减少了开发者的配置工作，使得快速搭建生产就绪的应用成为可能。SpringBoot提供了集成容器和简化的部署方式，使得开发者可以更专注于业务逻辑的开发，而不是繁琐的环境配置。
• SpringCloud则进一步扩展了SpringBoot，专注于解决分布式系统开发中的复杂性。它提供了诸如服务发现、配置中心、负载均衡、断路器、网关等微服务模式的实现。SpringCloud的出现使得开发者能够更轻松地构建和管理分布式系统，提高了系统的弹性和可伸缩性。

Spring启动流程

Spring启动流程的主要步骤及对应的代码如下：

1. 启动入口，从main方法调用SpringApplication.run。

   public class MyApplication {
       public static void main(String[] args) {
           SpringApplication.run(MyApplication.class, args);
       }
   }
   

2. 初始化，创建SpringApplication实例，并设置初始化器和监听器。

   public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
       return new SpringApplication(primarySource).run(args);
   }
   
   public SpringApplication(Object... sources) {
       initialize(sources);
   }
   
   private void initialize(Object[] sources) {
       this.sources = new LinkedHashSet<>(Arrays.asList(sources));
       this.initializers = getSpringFactoriesInstances(ApplicationContextInitializer.class);
       this.listeners = getSpringFactoriesInstances(ApplicationListener.class);
   }
   

3. 配置环境，准备Spring环境，如读取配置文件、系统属性等。

   public ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
       // 创建并配置环境
       ConfigurableEnvironment environment = getOrCreateEnvironment();
       configureEnvironment(environment, applicationArguments.getSourceArgs());
       listeners.environmentPrepared(environment);
       return environment;
   }
   

4. 创建上下文，根据应用类型创建合适的应用上下文。

   protected ConfigurableApplicationContext createApplicationContext() {
       Class<?> contextClass = this.applicationContextClass;
       if (contextClass == null) {
           try {
               contextClass = Class.forName(this.webApplicationType.getApplicationContextClassName());
           }
           catch (ClassNotFoundException ex) {
               throw new IllegalStateException(
                       "Unable to create a default ApplicationContext, "
                               + "please specify an ApplicationContextClass",
                       ex);
           }
       }
       return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
   }
   

5. 刷新上下文，初始化所有单例Bean，启动Spring生命周期。

   public void refresh() throws BeansException, IllegalStateException {
       synchronized (this.startupShutdownMonitor) {
           prepareRefresh();
           ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
           prepareBeanFactory(beanFactory);
           postProcessBeanFactory(beanFactory);
           invokeBeanFactoryPostProcessors(beanFactory);
           registerBeanPostProcessors(beanFactory);
           initMessageSource();
           initApplicationEventMulticaster();
           onRefresh();
           registerListeners();
           finishBeanFactoryInitialization(beanFactory);
           finishRefresh();
       }
   }
   

6. 通知监听器启动完成，执行ApplicationRunner和CommandLineRunner。

   private void callRunners(ApplicationContext context, ApplicationArguments args) {
       List<Object> runners = new ArrayList<>();
       runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
       runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
       AnnotationAwareOrderComparator.sort(runners);
       for (Object runner : new LinkedHashSet<>(runners)) {
           if (runner instanceof ApplicationRunner) {
               callRunner((ApplicationRunner) runner, args);
           }
           if (runner instanceof CommandLineRunner) {
               callRunner((CommandLineRunner) runner, args);
           }
       }
   }
   

其中核心方法为refresh()刷新上下文方法。

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 1. 准备刷新上下文
        prepareRefresh();

        // 2. 获取BeanFactory并进行初始化
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 3. 为BeanFactory配置上下文相关信息
        prepareBeanFactory(beanFactory);

        try {
            // 4. 子类覆盖方法，做进一步的BeanFactory初始化
            postProcessBeanFactory(beanFactory);

            // 5. 调用BeanFactoryPostProcessors
            invokeBeanFactoryPostProcessors(beanFactory);

            // 6. 注册BeanPostProcessors
            registerBeanPostProcessors(beanFactory);

            // 7. 初始化消息源（用于国际化）
            initMessageSource();

            // 8. 初始化事件广播器
            initApplicationEventMulticaster();

            // 9. 子类覆盖方法，在上下文刷新的时候进行进一步的处理
            onRefresh();

            // 10. 注册监听器以便监听事件
            registerListeners();

            // 11. 初始化所有单例Bean
            finishBeanFactoryInitialization(beanFactory);

            // 12. 完成刷新过程，通知生命周期处理器
            finishRefresh();
        }
        catch (BeansException ex) {
            // 如果在刷新过程中出现异常，则销毁已创建的单例Beans以避免资源泄漏
            destroyBeans();
            cancelRefresh(ex);
            throw ex;
        }
        finally {
            // 重置标志位
            resetCommonCaches();
        }
    }
}

1. prepareRefresh准备刷新容器，此方法做一些刷新容器的准备工作：
   • 设置开启时间和对应标志位。
   • 获取环境对象。
   • 设置监听器和一些时间的集合对象。
2. obtainFreshBeanFactory创建容器对象：DefaultListableBeanFactory；加载xml配置文件属性值到工厂中，最重要的是BeanDefinition。
3. prepareBeanFactory完成Bean工厂的某些初始化操作：
   • 设置BeanDefinition的类加载器。
   • 设置Spring容器默认的类型转换器。
   • 设置Spring解析EL表达式的解析器。
   • 添加一个Bean的后置处理器ApplicationContextAwareProcessor。
   • 将Bean工厂的一些类，比如ApplicationContext直接注册到单例池中。
   • 去除一些在byType或者byName的时候需要过滤掉的一些Bean（Spring在依赖注入的时候会先在这些默认注册的Bean中进行byType找，如果找到了，就加入到列表中，简单来说就是比如你在Bean中依赖注入了ApplicationContext，那么Spring会把默认注册的这些Bean中找到然后进行注册）。
   • 将系统的环境信息、Spring容器的启动环境信息、操作系统的环境信息直接注册成一个单例的Bean。
4. postProcessBeanFactory这里是一个空壳方法，Spring目前还没有对他进行实现;这个方法是留给子类进行实现的，后续可以添加一些用户自定义的或者默认的一些特殊的后置处理器工程到beanFactory中去。
5. invokeBeanFactoryPostProcessors 调用后置处理器；将系统中所有符合条件的普通类都扫描成了一个BeanDefinition并且放入到了beanDefinitionMap中，包括业务的Bean，Bean的后置处理器、Bean工厂的后置处理器等。
   • 将标记为容器单例类扫描成BeanDefinition放入BeanDefinitionMap。
   • 处理@Import注解。
   • 如果我们的配置类是@Configuration的，那么会生成这个配置类的CGLIB代理类，如果没有加@Configuration，则就是一个普通Bean。
6. registerBeanPostProcessors从beanDefinitionMap中取出Bean的后置处理器然后放入到后置处理器的缓存列表中。
7. initMessageSource初始化国际化资源信息。
8. initApplicationEventMulticaster事件注册器初始化。
9. onRefresh空壳方法，留给子类实现。
10. registerListeners将容器中和BeanDefinitionMap中的监听器添加到事件监听器中。
11. finishBeanFactoryInitialization创建单例池，将容器中非懒加载的Bean，单例Bean创建对象放入单例池中，包括容器的依赖注入。
12. finishRefresh容器启动过后，发布事件。

Spring循环依赖与三级缓存

Spring循环依赖是指两个或多个Bean相互依赖，导致Spring无法在不部分实例化这些Bean的情况下完成它们的创建。 在Spring框架中，为了解决循环依赖问题，Spring使用了三级缓存机制。

假设BeanA依赖BeanB，BeanB依赖BeanA，Spring循环依赖调用流程如下：

1. 初始化BeanA：
   • 检查一级缓存（singletonObjects），发现没有BeanA。
   • 检查二级缓存（earlySingletonObjects），发现没有BeanA。
   • 检查三级缓存（singletonFactories），发现没有BeanA。
   • 开始创建BeanA的实例。
2. 创建BeanA过程中发现需要BeanB：
   • 将BeanA的创建流程放入三级缓存（singletonFactories）。
3. 初始化BeanB：
   • 检查一级缓存（singletonObjects），发现没有BeanB。
   • 检查二级缓存（earlySingletonObjects），发现没有BeanB。
   • 检查三级缓存（singletonFactories），发现没有BeanB。
   • 开始创建BeanB的实例。
4. 创建BeanB过程中发现需要BeanA：
   • 检查一级缓存（singletonObjects），发现没有BeanA。
   • 检查二级缓存（earlySingletonObjects），发现没有BeanA。
   • 检查三级缓存（singletonFactories），发现有BeanA。
   • 从三级缓存中获取BeanA的创建流程，将BeanA提前暴露到二级缓存（earlySingletonObjects）。
5. 继续初始化BeanB：
   • 继续BeanB的初始化，完成依赖注入。
   • 将完全初始化好的BeanB放入一级缓存（singletonObjects），并从三级缓存中移除BeanB的工厂对象。
6. 完成初始化BeanA：
   • 从二级缓存中获取提前暴露的BeanA，并完成依赖注入。
   • 将完全初始化好的BeanA放入一级缓存（singletonObjects），并从二级缓存中移除BeanA的部分实例。

简单来说，首先检查一级、二级和三级缓存中是否有BeanA，如果没有，开始创建BeanA。因为BeanA依赖BeanB，在创建BeanA时将其创建流程放入三级缓存。 检查一级、二级和三级缓存中是否有BeanB，如果没有，开始创建BeanB。又因为BeanB依赖BeanA，此时三级缓存中有BeanA，从三级缓存中获取BeanA，然后将BeanA提前暴露到二级缓存。 继续初始化BeanB，完成后将BeanB放入一级缓存，并从三级缓存中移除。接着从二级缓存中获取提前暴露的BeanA，完成依赖注入。将完全初始化好的BeanA放入一级缓存，并从二级缓存中移除。

在Spring Boot 2.6.0之前，Spring可以通过其三级缓存机制自动解决循环依赖的问题。但从2.6.0开始，如果存在循环依赖问题，Spring会抛出异常。 在Spring Boot 2.6.0及之后的版本中，默认情况下，Spring不再自动解决循环依赖。如果在应用中遇到循环依赖问题，可以通过以下方法解决：

• 重新设计Bean的依赖关系：这是最推荐的方式。通过重新设计Bean的依赖关系，消除循环依赖，从根本上解决问题。
• 使用@Lazy注解：将其中一个Bean的依赖注入设置为懒加载，延迟依赖注入，从而打破循环依赖。
• 设置allow-circular-references属性：如果确实需要循环依赖，可以在配置文件中设置allow-circular-references属性为true，允许Spring处理循环依赖。

IOC

Spring的核心之一是IOC，IOC全称为Inversion of Control，中文译为控制反转，是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。 IOC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。

所谓IOC，对于Spring框架来说，就是由Spring来负责对象的创建、配置和管理，所以可将IOC理解为一个大容器。IOC通过将对象创建和管理的控制权从应用代码转移到Spring容器中，实现了松耦合设计。 IOC使用依赖注入（DI）来管理组成一个应用程序的组件，这些对象被称为Spring Beans。

管理Bean的创建、配置和生命周期，Spring提供了两个主要的IOC容器：BeanFactory和ApplicationContext。 IOC容器管理的对象，通常使用注解，如@Component、@Service、@Autowired，或XML配置声明Bean。 IOC容器的工作流程：

1. 读取配置，通过XML文件、注解或Java配置类读取Bean定义和依赖关系。
2. 创建和配置Bean，容器根据配置实例化Bean，并注入它们的依赖。
3. 管理Bean生命周期，容器负责调用Bean的初始化和销毁方法，管理其整个生命周期。

通过Spring的IOC容器，开发者可以更加专注于业务逻辑，而无需关心对象的创建和管理，从而提高了代码的可维护性和可扩展性。

IOC工作原理

IOC容器是Spring框架的核心，它负责管理应用程序中对象的生命周期和依赖关系。

1. 想要管理Bean，首先需要将Bean加载进来。IOC容器首先需要加载应用程序的配置元数据，这些配置可以通过XML文件、Java注解或者Java配置类等方式定义。 加载完配置之后，容器会使用相应的解析器（如Dom4j解析XML配置文件），将配置信息转换为容器可以理解的数据结构，通常是BeanDefinition对象。BeanDefinition包含了类的名称、依赖关系、初始化方法、销毁方法等元数据信息。

   <!-- applicationContext.xml -->
   <bean id="userRepository" class="com.example.UserRepository">
       <!-- 定义UserRepository的依赖或配置 -->
   </bean>
   
   <bean id="userService" class="com.example.UserService">
       <property name="userRepository" ref="userRepository" />
   </bean>
   
   // 加载和解析XML配置
   ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
   

2. 一旦容器解析了Bean的配置信息，它会根据这些信息使用Java的反射机制来创建Bean的实例。通常情况下，Spring会调用Bean的默认构造方法来实例化对象。

   // 获取UserService Bean
   UserService userService = (UserService) context.getBean("userService");
   

3. 对象实例化完成，容器会根据配置文件或者注解中定义的依赖关系，将其他Bean的实例或者值注入到当前Bean中。依赖注入可以通过构造函数注入、Setter方法注入或者字段注入来完成。

   public class UserService {
       private UserRepository userRepository;
   
       // Setter方法注入
       public void setUserRepository(UserRepository userRepository) {
           this.userRepository = userRepository;
       }
   
       // 其他方法
   }
   

4. 在依赖注入完成后，如果配置了初始化方法，例如使用init-method指定的方法、实现InitializingBean接口的方法或者使用@PostConstruct注解标记的方法），容器会调用这些方法来执行一些初始化的操作，例如加载资源、建立连接等。

   <!-- applicationContext.xml -->
   <bean id="userRepository" class="com.example.UserRepository" init-method="init" destroy-method="destroy">
       <!-- 定义UserRepository的依赖或配置 -->
   </bean>
   
   
   // UserRepository.java
   public class UserRepository {
       // 初始化方法
       public void init() {
       System.out.println("UserRepository 初始化方法被调用");
       }
   
       // 销毁方法
       public void destroy() {
           System.out.println("UserRepository 销毁方法被调用");
       }
   }
   

Bean的生命周期

Spring中的Bean是指由Spring容器管理的对象实例。 在Spring框架中，Bean是应用程序的核心组件，它们由Spring容器创建、组装和管理，以帮助开发者实现松耦合、可测试和可维护的代码。

Spring Bean的生命周期包含从创建到销毁的一系列过程。即Bean的 实例化->初始化->使用->销毁的过程。 Spring中的Bean可以根据其作用域的不同可分为，单例Bean、原型Bean，不同作用域的Bean生命周期也不同。

单实例Bean生命周期：

1. 实例化：在容器启动时创建该Bean的唯一实例。
2. 初始化：
   • 初始化前置处理：调用所有注册的BeanPostProcessor的postProcessBeforeInitialization方法，可以在初始化之前对Bean进行修改。
   • 初始化：按照顺序执行以下方法，如果Bean实现了InitializingBean接口，则调用其afterPropertiesSet方法；如果在Bean定义中指定了init-method，则调用这个方法；如果Bean中有用@PostConstruct注解标记的方法，则调用该方法。
   • 初始化后处理：调用所有注册的BeanPostProcessor的postProcessAfterInitialization方法，可以在初始化之后对Bean进行修改。
3. 使用：当Bean初始化之后，Bean处于就绪状态，可以被应用程序中的其他组件使用。
4. 销毁：
   • 销毁前处理：在销毁之前，Spring容器会依次调用注册的所有BeanPostProcessor的postProcessBeforeDestruction方法。如果Bean类中有用@PreDestroy注解标记的方法，Spring容器会在销毁之前调用该方法。
   • 销毁：如果在Bean的定义中通过配置destroy-method属性指定了销毁方法，Spring容器会调用这个方法来执行特定的清理操作。

单例Bean和多实例Bean的生命周期主要区别在于实例化和销毁的管理方式，单例Bean在容器启动时创建一个实例，并由容器负责管理其生命周期的完整过程。 而多实例Bean在每次请求时创建新的实例，并且销毁过程需要开发者手动管理。

@Configuration
public class AppConfig {

    @Bean(initMethod = "init", destroyMethod = "destroy")
    @Scope("singleton")
    public SingletonBean singletonBean() {
        return new SingletonBean();
    }

    @Bean(initMethod = "init", destroyMethod = "destroy")
    @Scope("prototype")
    public PrototypeBean prototypeBean() {
        return new PrototypeBean();
    }

    public static class SingletonBean implements InitializingBean, DisposableBean {
        public SingletonBean() {
            System.out.println("SingletonBean 实例化");
        }

        @PostConstruct
        public void postConstruct() {
            System.out.println("SingletonBean @PostConstruct 方法调用");
        }

        @Override
        public void afterPropertiesSet() {
            System.out.println("SingletonBean afterPropertiesSet 方法调用");
        }

        public void init() {
            System.out.println("SingletonBean 自定义初始化方法调用");
        }

        @PreDestroy
        public void preDestroy() {
            System.out.println("SingletonBean @PreDestroy 方法调用");
        }

        @Override
        public void destroy() {
            System.out.println("SingletonBean destroy 方法调用");
        }

        public void customDestroy() {
            System.out.println("SingletonBean 自定义销毁方法调用");
        }
    }

    public static class PrototypeBean implements InitializingBean, DisposableBean {
        public PrototypeBean() {
            System.out.println("PrototypeBean 实例化");
        }

        @PostConstruct
        public void postConstruct() {
            System.out.println("PrototypeBean @PostConstruct 方法调用");
        }

        @Override
        public void afterPropertiesSet() {
            System.out.println("PrototypeBean afterPropertiesSet 方法调用");
        }

        public void init() {
            System.out.println("PrototypeBean 自定义初始化方法调用");
        }

        @PreDestroy
        public void preDestroy() {
            System.out.println("PrototypeBean @PreDestroy 方法调用");
        }

        @Override
        public void destroy() {
            System.out.println("PrototypeBean destroy 方法调用");
        }

        public void customDestroy() {
            System.out.println("PrototypeBean 自定义销毁方法调用");
        }
    }

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        SingletonBean singletonBean1 = context.getBean(SingletonBean.class);
        SingletonBean singletonBean2 = context.getBean(SingletonBean.class);

        System.out.println("singletonBean1 == singletonBean2 : " + (singletonBean1 == singletonBean2));

        PrototypeBean prototypeBean1 = context.getBean(PrototypeBean.class);
        PrototypeBean prototypeBean2 = context.getBean(PrototypeBean.class);

        System.out.println("prototypeBean1 == prototypeBean2 : " + (prototypeBean1 == prototypeBean2));

        context.close();

        // 手动销毁 Prototype Bean
        prototypeBean1.destroy();
        prototypeBean2.destroy();
    }
}

举个例子，来更好的理解Bean的生命周期：

1. 首先，在Spring的配置文件（如XML配置）或者使用注解方式，我们定义UserService类作为一个Bean，并配置它的初始化方法、销毁方法以及其他属性。

   // UserService.java
   public class UserService implements InitializingBean, DisposableBean, BeanNameAware {
       private String message;
   
       // 初始化方法
       public void init() {
           System.out.println("UserService 初始化方法被调用");
       }
   
       // 销毁方法
       public void destroy() {
           System.out.println("UserService 销毁方法被调用");
       }
   
       // Setter 方法
       public void setMessage(String message) {
           this.message = message;
       }
   
       // Getter 方法
       public String getMessage() {
           return message;
       }
   
       // 实现 InitializingBean 接口的方法
       @Override
       public void afterPropertiesSet() throws Exception {
           System.out.println("UserService InitializingBean 的 afterPropertiesSet 方法被调用");
       }
   
       // 实现 DisposableBean 接口的方法
       @Override
       public void destroy() throws Exception {
           System.out.println("UserService DisposableBean 的 destroy 方法被调用");
       }
   
       // 实现 BeanNameAware 接口的方法
       @Override
       public void setBeanName(String name) {
           System.out.println("UserService BeanNameAware 的 setBeanName 方法被调用，Bean的名称为：" + name);
       }
   }
   

2. 在Spring的配置文件中，我们将UserService类定义为一个Bean，并配置初始化方法、销毁方法以及其他属性。

   <!-- applicationContext.xml -->
   <bean id="userService" class="com.example.UserService" init-method="init" destroy-method="destroy">
       <property name="message" value="Hello, Spring!" />
   </bean>
   

3. 当应用程序启动并且Spring容器加载配置时，将会执行以下步骤来管理UserServiceBean的生命周期：
   • 实例化：Spring容器根据配置文件或者注解，实例化 UserService 类的一个对象实例。
   • 依赖注入：将配置的属性（如message）注入到UserService实例中。
   • 初始化：调用init-method指定的初始化方法或者InitializingBean接口的afterPropertiesSet()方法，例如执行init()方法。在初始化过程中，还可以调用BeanNameAware接口的方法，获取和设置Bean的名称。
   • 使用：UserServiceBean可以被应用程序的其他组件使用，执行其业务逻辑，如打印消息。
   • 销毁：当应用程序关闭时，Spring容器会调用destroy-method指定的销毁方法或者DisposableBean接口的destroy()方法，例如执行destroy()方法。

Bean的自动装配

Bean的自动装配是Spring框架提供的一种便捷的方式，用于自动解析和设置Bean之间的依赖关系，而无需显式配置每一个依赖关系的方式。Spring支持以下几种自动装配的方式：

1. 根据类型自动装配：Spring会自动将一个属性与同一上下文中具有兼容类型的Bean进行匹配。如果容器中存在多个符合类型的Bean，则会抛出异常。

   public interface UserRepository {
       // 接口定义
   }
   
   @Component
   public class UserRepositoryImpl1 implements UserRepository {
       // 实现1
   }
   
   @Component
   public class UserRepositoryImpl2 implements UserRepository {
       // 实现2
   }
   
   // 示例：根据类型自动装配
   @Autowired
   private UserRepository userRepository;
   

2. 根据名称自动装配：Spring会自动将一个属性与容器中相同名称的Bean进行匹配，要求Bean的名称必须与属性名称完全一致。

   public interface UserRepository {
       // 接口定义
   }
   
   @Component("userRepository1")
   public class UserRepositoryImpl1 implements UserRepository {
       // 实现1
   }
   
   @Component("userRepository2")
   public class UserRepositoryImpl2 implements UserRepository {
       // 实现2
   }
   
   // 示例：根据名称自动装配
   @Autowired
   private UserRepository userRepository;
   

3. 构造函数自动装配：Spring会自动通过构造函数来注入依赖，从而避免了使用@Autowired注解的繁琐。Spring会查找与构造函数参数类型相匹配的Bean，并自动进行注入。

   // 示例：构造函数自动装配
   @Autowired
   public UserService(UserRepository userRepository) {
       this.userRepository = userRepository;
   }
   

4. 自动装配标识符：可以使用@Autowired注解结合@Qualifier注解来指定具体的Bean名称，来解决多个相同类型Bean的自动装配歧义问题。

   // 示例：结合@Qualifier注解指定Bean名称
   @Autowired
   @Qualifier("userRepository")
   private UserRepository userRepository;
   

5. 自动装配和主候选Bean：可以使用@Primary注解来标识一个主要的Bean候选者，当存在多个匹配的Bean时，Spring会优先选择标有@Primary注解的Bean进行注入。

   // 示例：使用@Primary注解标识主候选Bean
   @Component
   @Primary
   public class PrimaryUserRepository implements UserRepository {
       // 实现代码
   }
   

在Spring中用于实现自动装配的注解有三个，它们都能自动注入依赖，但在一些细节上有所区别。

在日常开发中，都是使用SpringBoot进行开发，一般使用@Autowired注解就够了，适合大多数Spring应用场景。

@Autowired

@Autowired是Spring框架中用于自动装配Bean的主要方式之一。它可以根据类型来自动注入依赖关系。

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {

	/**
	 * Declares whether the annotated dependency is required.
	 * <p>Defaults to {@code true}.
	 */
	boolean required() default true;

}

在使用@Autowired时，Spring会尝试将一个属性与容器中具有兼容类型的Bean进行匹配。

@Component
public class UserService {
    
    private UserRepository userRepository;
    
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

如果存在多个同类型的Bean，可以结合@Primary注解，指定优先级最高的Bean进行注入。

@Component
public class UserRepositoryImpl1 implements UserRepository {
    // implementation
}

@Component
@Primary
public class UserRepositoryImpl2 implements UserRepository {
    // implementation
}

@Component
public class UserService {
    
    private UserRepository userRepository;
    
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

除了使用@Primary还可以使用@Qualifier注解来指定具体的Bean名称，来解决多个相同类型Bean的自动装配歧义问题。

@Component("userRepository1")
public class UserRepositoryImpl1 implements UserRepository {
    // 实现1
}

@Component("userRepository2")
public class UserRepositoryImpl2 implements UserRepository {
    // 实现2
}

// 示例：结合@Qualifier注解指定Bean名称
@Autowired
@Qualifier("userRepository2")
private UserRepository userRepository;

@Autowired可以使用required属性控制是否要求依赖关系存在，默认为true，表示必须存在兼容的Bean，设为false可以允许null值注入。

@Component
public class UserService {
    
    private UserRepository userRepository;
    
    @Autowired(required = false)
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

@Autowired可以放在构造器、参数、方法、属性上。

1. 构造器注入：可以在构造器上使用@Autowired来完成构造器注入，Spring会自动根据类型进行注入。

   @Component
   public class UserService {
   
       private final UserRepository userRepository;
   
       @Autowired
       public UserService(UserRepository userRepository) {
           this.userRepository = userRepository;
       }
   }
   

2. 属性注入：可以直接在属性上使用@Autowired注解来进行依赖注入。

   @Component
   public class UserService {
   
       @Autowired
       private UserRepository userRepository;
   }
   

3. 方法注入：可以在方法上使用@Autowired注解，Spring会在初始化Bean时调用这些方法完成依赖注入。

   @Component
   public class UserService {
   
       private UserRepository userRepository;
   
       @Autowired
       public void setUserRepository(UserRepository userRepository) {
           this.userRepository = userRepository;
       }
   }
   

4. 参数注入：可以在方法参数上使用@Autowired注解，Spring会根据参数类型自动注入对应的Bean。

   @Component
   public class UserService {
   
       private UserRepository userRepository;
   
       @Autowired
       public void setUserRepository(UserRepository userRepository) {
           this.userRepository = userRepository;
       }
   
       public void processUserData(@Autowired User user) {
       }
   }
   

@Autowired的实现原理，是通过@Autowired后置处理器实现的。 在@Autowired注解文档注释上面，可以看到与之息息相关的一个类AutowiredAnnotationBeanPostProcessor，即@Autowired后置处理器。 看到该类实现了MergedBeanDefinitionPostProcessor接口，在postProcessMergedBeanDefinition方法上打一个断点，就可以看到@Autowired的调用栈。

/*
 * @see AutowiredAnnotationBeanPostProcessor
 */
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired{}

@Autowired注解调用栈：

AbstractApplicationContext.refresh(容器初始化)
    ---> registerBeanPostProcessors (注册AutowiredAnnotationBeanPostProcessor) 
    ---> finishBeanFactoryInitialization
    ---> AbstractAutowireCapableBeanFactory.doCreateBean
    ---> AbstractAutowireCapableBeanFactory.applyMergedBeanDefinitionPostProcessors
    ---> MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition
    ---> AutowiredAnnotationBeanPostProcessor.findAutowiringMetadata

核心调用：

postProcessMergedBeanDefinition
    --->findAutowiringMetadata
    --->buildAutowiringMetadata

@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
    // 调用 findAutowiringMetadata
    InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
    metadata.checkConfigMembers(beanDefinition);
}

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
    // Fall back to class name as cache key, for backwards compatibility with custom callers.
    String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
    // Quick check on the concurrent map first, with minimal locking.
    InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
    if (InjectionMetadata.needsRefresh(metadata, clazz)) {
        synchronized (this.injectionMetadataCache) {
            metadata = this.injectionMetadataCache.get(cacheKey);
            if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                if (metadata != null) {
                    metadata.clear(pvs);
                }
                // 调用buildAutowiringMetadata
                metadata = buildAutowiringMetadata(clazz);
                this.injectionMetadataCache.put(cacheKey, metadata);
            }
        }
    }
    return metadata;
}


private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
    LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<>();
    Class<?> targetClass = clazz;//需要处理的目标类
   
    do {
        final LinkedList<InjectionMetadata.InjectedElement> currElements = new LinkedList<>();

        // 通过反射获取该类所有的字段，并遍历每一个字段，并通过方法findAutowiredAnnotation遍历每一个字段的所用注解，
        // 如果用autowired修饰了，则返回auotowired相关属性
        ReflectionUtils.doWithLocalFields(targetClass, field -> {
            AnnotationAttributes ann = findAutowiredAnnotation(field);
            if (ann != null) {//校验autowired注解是否用在了static方法上
                if (Modifier.isStatic(field.getModifiers())) {
                    if (logger.isWarnEnabled()) {
                        logger.warn("Autowired annotation is not supported on static fields: " + field);
                    }
                    return;
                }//判断是否指定了required
                boolean required = determineRequiredStatus(ann);
                currElements.add(new AutowiredFieldElement(field, required));
            }
        });
        // 和上面一样的逻辑，但是是通过反射处理类的method
        ReflectionUtils.doWithLocalMethods(targetClass, method -> {
            Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
            if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
                return;
            }
            AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
            if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
                if (Modifier.isStatic(method.getModifiers())) {
                    if (logger.isWarnEnabled()) {
                        logger.warn("Autowired annotation is not supported on static methods: " + method);
                    }
                    return;
                }
                if (method.getParameterCount() == 0) {
                    if (logger.isWarnEnabled()) {
                        logger.warn("Autowired annotation should only be used on methods with parameters: " +
                                method);
                    }
                }
                boolean required = determineRequiredStatus(ann);
                PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                currElements.add(new AutowiredMethodElement(method, required, pd));
            }
        });
        // 用@Autowired修饰的注解可能不止一个，因此都加在currElements这个容器里面，一起处理		
        elements.addAll(0, currElements);
        targetClass = targetClass.getSuperclass();
    }
    while (targetClass != null && targetClass != Object.class);

    return new InjectionMetadata(clazz, elements);
}

通过上面的源码，可以看到Spring在运行时通过反射查找@Autowired注解，并自动注入相关字段。 Spring框架利用反射遍历目标类及其超类的所有字段和方法，查找并收集所有使用了@Autowired注解的元素。对于每个字段和方法，首先通过反射获取注解信息，如果字段或方法被@Autowired注解修饰且符合条件（如非静态），则将其封装成对应的注入元素（AutowiredFieldElement或AutowiredMethodElement）并添加到当前元素列表中。 最后，这些注入元素会被封装到InjectionMetadata对象中，并用于实际的依赖注入过程，从而实现Spring的自动注入功能。

@Resource

@Resource注解来自JSR-250，JDK自带，主要用于通过名称注入依赖。它的行为类似于@Autowired，但它更倾向于按名称进行注入。 默认情况下，@Resource注解按名称进行注入。如果找不到同名的Bean，再按类型进行匹配。它不支持@Primary，如果存在多个同类型的Bean且未指定name属性，会抛出异常。

@Component
public class UserService {
    
    @Resource(name = "userRepositoryImpl1")
    private UserRepository userRepository;
}

假设我们有一个旧项目，其中大量使用了JDK标准的@Resource注解进行依赖注入，而我们现在想要将项目迁移到Spring，同时保持现有的依赖注入逻辑不变。 在这种情况下，我们可以继续使用@Resource注解进行依赖注入。

@Inject

@Inject注解来自JSR-330，需要导入javax.inject包。它的行为与@Autowired类似，但没有任何属性。

<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>

@Inject注解按类型进行注入，可以结合@Primary注解，指定优先级最高的Bean进行注入。

@Component
public class UserService {

    @Inject
    @Named("userRepositoryImpl1")
    private UserRepository userRepository;
}

// Define multiple implementations
@Component
@Named("userRepositoryImpl1")
public class UserRepositoryImpl1 implements UserRepository {
    // implementation details
}

@Component
@Named("userRepositoryImpl2")
public class UserRepositoryImpl2 implements UserRepository {
    // implementation details
}

也可以结合@Named注解，显式指定要注入的Bean名称，解决多个同类型Bean的注入问题。

@Component("userRepository1")
public class UserRepositoryImpl1 implements UserRepository {
    // 实现1
}

@Primary
@Component("userRepository2")
public class UserRepositoryImpl2 implements UserRepository {
    // 实现2
}

@Component
public class UserService {

    @Inject
    @Named("userRepository1")
    private UserRepository userRepository;
}

假设我们有一个项目，需要在不同的环境中运行。在本地开发时，我们使用Spring，但在生产环境中，我们使用 Java EE 容器，这些容器使用 CDI（Contexts and Dependency Injection）作为依赖注入框架。 为了在不同的环境中都能够使用相同的代码进行依赖注入，我们可以使用JSR-330标准的@Inject注解。这种方式使得代码能够在Spring和Java EE环境中都能正常运行。

CDI（Contexts and Dependency Injection，上下文与依赖注入）是 Java EE 标准的一部分，定义了一种类型安全的依赖注入机制，主要用于管理 Java EE 应用程序中的生命周期和依赖关系。CDI 提供了一种统一的、标准的依赖注入方式，使得开发者可以更容易地管理对象的创建、销毁以及对象之间的依赖关系。

使用Spring底层组件

为了在Spring框架的基础上实现更加细粒度的控制或定制化需求，可以使用Spring底层组件。

Aware接口是一组特定于Spring容器的接口，允许beans感知和与Spring容器进行交互。 通过实现Aware接口的子接口，来使用Spring的底层的组件。Aware接口类似于回调方法的形式在Spring加载的时候将我们自定以的组件加载。

/**
 * A marker superinterface indicating that a bean is eligible to be notified by the
 * Spring container of a particular framework object through a callback-style method.
 * The actual method signature is determined by individual subinterfaces but should
 * typically consist of just one void-returning method that accepts a single argument.
 */
public interface Aware {}

常用的Aware接口：

• ApplicationContextAware，允许Bean访问ApplicationContext，从而可以访问容器中的其他Bean或执行更高级的容器操作。

  @Component
  public class MyBean implements ApplicationContextAware {
  
      private ApplicationContext applicationContext;
  
      @Override
      public void setApplicationContext(ApplicationContext applicationContext) {
          this.applicationContext = applicationContext;
      }
  
      public void someMethod() {
          // 使用 ApplicationContext 获取其他 Bean
          AnotherBean anotherBean = applicationContext.getBean(AnotherBean.class);
          // 执行更高级的容器操作，如发布事件等
          applicationContext.publishEvent(new CustomEvent(this, "Some message"));
      }
  }
  

• BeanFactoryAware允许Bean访问配置它的Bean工厂。

  @Component
  public class MyBean implements BeanFactoryAware {
  
      private BeanFactory beanFactory;
  
      @Override
      public void setBeanFactory(BeanFactory beanFactory) {
          this.beanFactory = beanFactory;
      }
  
      public void someMethod() {
          // 使用 BeanFactory 获取其他 Bean
          AnotherBean anotherBean = beanFactory.getBean(AnotherBean.class);
          // 可以进一步操作 BeanFactory，如获取 Bean 的定义信息等
          String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
      }
  }
  

BeanPostProcessor也是常用的底层组件。它是Bean的后置处理器，在初始化前后进行处理工作。 需要在Bean实例化后和初始化前后执行自定义的处理逻辑，如AOP切面的实现、自定义注解处理等。调用顺序为：

创建对象 --> postProcessBeforeInitialization --> 初始化 --> postProcessAfterInitialization --> 销毁

public class MainTest {
    public static void main(String[] args) {
        // 获取Spring IOC容器
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(DemoConfiguration.class);
        System.out.println("容器初始化完成...");

        annotationConfigApplicationContext.close();
        System.out.println("容器销毁了...");
    }
}

@Configuration
class DemoConfiguration implements BeanPostProcessor {

    @Bean(initMethod = "init", destroyMethod = "destroy")
    public DemoEntity getDemoEntity(){
       return new DemoEntity();
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("调用了 postProcessBeforeInitialization");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("调用了 postProcessAfterInitialization");
        return bean;
    }
}

@Component
class DemoEntity  {
    public DemoEntity(){
        System.out.println("调用了构造器...");
    }

    public void destroy(){
        System.out.println("调用了销毁方法...");
    }

    public void init() {
        System.out.println("调用了初始化方法...");
    }
}

通过打断点可以看到，在创建Bean的时候会调用AbstractAutowireCapableBeanFactory类的doCreateBean方法，这也是创建Bean的核心方法。

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    // 创建 Bean 实例
    Object beanInstance = createBeanInstance(mbd, beanName, args);
    
    // 提前暴露已经创建的 Bean 实例，用于解决循环依赖问题
    Object exposedObject = beanInstance;
    
    try {
        // 给 Bean 实例应用属性填充，包括依赖注入
        populateBean(beanName, mbd, instanceWrapper);
        
        // 初始化 Bean，执行各种初始化方法
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }catch (Exception ex) {
        throw new BeanCreationException(beanName, "Initialization of bean failed", ex);
    }
    
    // 注册销毁回调，用于在 Bean 销毁时执行清理操作
    registerDisposableBeanIfNecessary(beanName, exposedObject, mbd);
    
    return exposedObject;
}

doCreateBean方法中核心方法为populateBean方法，其调用栈大致如下：

populateBean(){
    applyBeanPostProcessorsBeforeInitialization() 
        --> invokeInitMethods()
        --> applyBeanPostProcessorsAfterInitialization()
}

在初始化之前调用populateBean()方法给Bean进行属性赋值，之后再调用applyBeanPostProcessorsBeforeInitialization方法。

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)throws BeansException {
    Object result = existingBean;
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        Object current = processor.postProcessBeforeInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}

该方法作用是，遍历容器中所有的BeanPostProcessor挨个执行postProcessBeforeInitialization方法，一旦返回null，将不会执行后面Bean的postProcessBeforeInitialization方法。 之后在调用invokeInitMethods方法，进行Bean的初始化，最后在执行applyBeanPostProcessorsAfterInitialization方法，执行一些初始化之后的工作。

AOP

Spring的另一个核心是AOP，AOP全称Aspect-Oriented Programming译为面向切面编程。AOP可以说是对OOP（面向对象编程）的补充和完善，在程序原有的纵向执行流程中，针对某一个或某些方法添加通知，形成横切面的过程就叫做面向切面编程。 简单来说，用于通过在方法执行前、执行后或抛出异常时动态地添加额外的功能就是面向切面编程。AOP 可以帮助解耦应用程序的横切关注点，如日志记录、事务管理、性能监控等，从而提高代码的模块性和复用性。

实现AOP的技术，主要分为两类，一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行； 二是采用静态织入的方式，引入特定的语法创建“切面”，从而使得编译器可以在编译期间织入有关“切面”的代码，属于静态代理。 AOP的工作原理主要基于对程序执行过程中特定点的拦截和增强。动态代理刚好就可以实现这个功能，AOP用的就是动态代理。

使用AOP

使用AOP大致可以分为三步：

1. 将业务逻辑组件和切面类都加入到容器中，并用Component、@Aspect注解标注切面类。

   @Aspect
   @Component
   public class LoggingAspect {}
   

2. 在切面类的通知方法上，要注意切面表达式的写法，标注通知注解，告诉Spring何时何地的运行：
   • @Before：前置通知，在目标方法运行之前执行；
   • @After：后置通知，在目标方法运行之后执行，无论方法是否出现异常都会执行；
   • @Around：环绕通知，通过joinPoint.proceed()方法手动控制目标方法的执行；
   • @AfterThrowing：异常通知，在目标方法出现异常之后执行；
   • @AfterReturning：返回通知，在目标方法返回之后执行；

   @Aspect
   @Component
   public class LoggingAspect {
   
       @Before("execution(* com.example.service.*.*(..))")
       public void logBefore() {
           System.out.println("Executing method in service layer...");
       }
   
       @After("execution(* com.example.service.*.*(..))")
       public void logAfter() {
           System.out.println("Method execution completed.");
       }
   
       @Around("execution(* com.example.service.*.*(..))")
       public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
           System.out.println("Before method execution.");
           Object result = joinPoint.proceed();
           System.out.println("After method execution.");
           return result;
       }
   
       @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "error")
       public void logAfterThrowing(Throwable error) {
           System.out.println("Exception occurred: " + error);
       }
   
       @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning = "result")
       public void logAfterReturning(Object result) {
           System.out.println("Method returned value: " + result);
       }
   }
   

3. 使用@EnableAspectJAutoProxy开启基于注解的AOP模式。

   @SpringBootApplication
   @EnableAspectJAutoProxy
   public class SpringAopApplication {
      public static void main(String[] args) {
         SpringApplication.run(SpringAopApplication.class, args);
      }
   }
   

execution表达式

execution表达式用于定义切入点，作用是什么时候触发切面。execution表达式语法：

execution(modifiers-pattern ret-type-pattern declaring-type-pattern name-pattern(param-pattern) throws-pattern)

• modifiers-pattern（可选）：方法修饰符模式，如public、protected。
• ret-type-pattern：返回类型模式，可以是具体类型，如String，也可以是通配符（*表示任意返回类型）。
• declaring-type-pattern（可选）：声明类型模式，即方法所属的类或接口，可以是具体类名，如com.example.MyClass或通配符，如com.example.*。
• name-pattern：方法名模式，可以是具体方法名（如myMethod），也可以是通配符（如*表示任意方法名）。
• param-pattern：参数模式，可以是具体参数类型，如(String, int)，也可以是通配符，如(..)表示任意参数类型和数量。
• throws-pattern（可选）：异常模式，可以是具体异常类型，如throws IOException。

execution表达式举例：

• 匹配任意方法。

  @Before("execution(* *(..))")
  public void logBeforeAllMethods() {
      System.out.println("Executing any method...");
  }
  

• 匹配特定类的所有方法。

  @Before("execution(* com.example.MyClass.*(..))")
  public void logBeforeMyClassMethods() {
      System.out.println("Executing method in MyClass...");
  }
  

• 匹配特定包中的所有方法。

  @Before("execution(* com.example..*.*(..))")
  public void logBeforePackageMethods() {
      System.out.println("Executing method in com.example package...");
  }
  

• 匹配特定返回类型的方法。

  @Before("execution(String *(..))")
  public void logBeforeStringMethods() {
      System.out.println("Executing method with String return type...");
  }
  

• 匹配特定方法名。

  @Before("execution(* myMethod(..))")
  public void logBeforeMyMethod() {
      System.out.println("Executing myMethod...");
  }
  

• 匹配特定参数类型的方法。

  @Before("execution(* *(String, int))")
  public void logBeforeStringIntMethods() {
      System.out.println("Executing method with String and int parameters...");
  }
  

• 匹配没有参数的方法。

  @Before("execution(* *())")
  public void logBeforeNoArgMethods() {
      System.out.println("Executing no-arg method...");
  }
  

• 匹配带有特定修饰符的方法。

  @Before("execution(public * *(..))")
  public void logBeforePublicMethods() {
      System.out.println("Executing public method...");
  }
  

切面执行顺序

在Spring AOP中，注意切面执行顺序非常重要，因为不同切面可能会对同一个方法执行不同的逻辑，这些逻辑的执行顺序可能会影响应用程序的行为和结果。

举一个例子，一个简单的银行转账操作，其中涉及日志记录、事务管理和安全检查三个切面。如果不考虑AOP的顺序，就是按照Spring加载顺序来，可能会导致事务管理在安全检查、日志记录的前面，这样可能会造成一些不安全的操作会被执行。 但是我们期望的是先执行安全检查，再执行事务管理，最后再执行日志记录。

@Order(1)  // 优先级最高
public class SecurityAspect {
   @Before("execution(* com.example.service.BankService.transfer(..))")
   public void checkSecurity() {
      System.out.println("Security: Performing security check...");
   }
}

@Order(2)  // 优先级中等
public class TransactionAspect {
   @Before("execution(* com.example.service.BankService.transfer(..))")
   public void startTransaction() {
      System.out.println("Transaction: Starting transaction...");
   }
}

@Order(3)  // 优先级最低 
public class LoggingAspect {
   @Before("execution(* com.example.service.BankService.transfer(..))")
   public void logBefore() {
      System.out.println("Logging: Starting method execution...");
   }
}

AOP工作原理

要想AOP起作用，就要加@EnableAspectJAutoProxy注解，所以AOP的原理可以从该注解入手研究。 它是一个复合注解，启动的时候，给容器中导入了一个AspectJAutoProxyRegistrar组件。

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

AspectJAutoProxyRegistrar该类实现了ImportBeanDefinitionRegistrar接口，而该接口的作用是给容器中注册Bean。 所以AspectJAutoProxyRegistrar作用是添加自定义组件给容器中注册Bean。

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

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

        // 注册了 AnnotationAwareAspectJAutoProxyCreator 组件
		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

		AnnotationAttributes enableAspectJAutoProxy =
				AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        // 获取 @EnableAspectJAutoProxy 中的属性，做一些工作
		if (enableAspectJAutoProxy != null) {
			if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
				AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
			}
			if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
				AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
			}
		}
	}
}

那AspectJAutoProxyRegistrar组件何时注册？关键代码如下：

AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

该方法是给容器中注册了一个AnnotationAwareAspectJAutoProxyCreator组件。

public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
            ParserContext parserContext, Element sourceElement) {
        //注册或者升级AutoProxyCreator定义beanName为
        // org.Springframework.aop.config.internalAutoProxyCreator的BeanDefinition
        BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
                parserContext.getRegistry(), parserContext.extractSource(sourceElement));
        //对于proxy-target-class以及expose-proxy属性的处理
        useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
        //注册组件并通知，便于监听器进一步处理，其中BeanDefinition的className
        // 为AnnotationAwareAspectJAutoProxyCreator
        registerComponentIfNecessary(beanDefinition, parserContext);
}