【阶段 10】进阶原理：源码、自定义 Starter 与 WebFlux

# 使用 Spring Initializr 快速生成（也可在 IDEA 里 New Project → Spring Initializr）
curl https://start.spring.io/starter.zip 
  -d dependencies=web,lombok 
  -d javaVersion=17 
  -d bootVersion=3.2.5 
  -d groupId=com.example 
  -d artifactId=advanced-principles 
  -d name=advanced-principles 
  -o advanced-principles.zip

unzip advanced-principles.zip && cd advanced-principles

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.5</version>
        <relativePath/>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>advanced-principles</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>advanced-principles</name>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 阶段 6 之后会用到 WebFlux，这里先不引入，避免两套栈冲突 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>

package com.example.advancedprinciples;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AdvancedPrinciplesApplication {

    public static void main(String[] args) {
        // 这行是「一切的原点」，背后是一个庞大的启动流水线
        SpringApplication.run(AdvancedPrinciplesApplication.class, args);
    }
}

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    // ① 推断应用类型：根据 classpath 上有无 DispatcherServlet / WebFlux 相关类
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    // ② 从 spring.factories / imports 里加载初始化器与监听器
    this.bootstrapRegistryInitializers = new ArrayList<>(
            getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    // ③ 推断 main 方法所在的类（用于日志打印「Started XxxApplication」）
    this.mainApplicationClass = deduceMainApplicationClass();
}

static WebApplicationType deduceFromClasspath() {
    // REACTIVE：有 WebFlux 的 DispatcherHandler 类，且没有 Servlet 相关类
    if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null)
            && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
            && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
        return WebApplicationType.REACTIVE;
    }
    // 如果都没有，就是非 Web 应用（比如纯命令行/批处理）
    for (String className : SERVLET_INDICATOR_CLASSES) {
        if (!ClassUtils.isPresent(className, null)) {
            return WebApplicationType.NONE;
        }
    }
    // 默认：Servlet Web 应用（最常见）
    return WebApplicationType.SERVLET;
}

public ConfigurableApplicationContext run(String... args) {
    // 计时器：启动耗时统计，最后会打出一行「Started ... in X seconds」
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();

    // 准备 BootstrapContext（引导上下文，Spring Boot 2.4+ 引入，用于早期 Bean）
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    ConfigurableApplicationContext context = null;

    // 设置 java.awt.headless 属性（无界面服务器环境必须）
    configureHeadlessProperty();

    // ① 获取运行监听器，并广播「starting」事件
    //    SpringApplicationRunListener 默认是 EventPublishingRunListener，负责把事件转发给 ApplicationListener
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting(bootstrapContext, this.mainApplicationClass);

    try {
        // ② 解析命令行参数，封装为 ApplicationArguments
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

        // ③ 准备 Environment：加载 application.yml / 命令行 / 环境变量 / 系统属性
        ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);

        // 打印 Banner（那个大大的 SPRING 字样）
        Banner printedBanner = printBanner(environment);

        // ④ 根据 webApplicationType 创建对应的 ApplicationContext
        //    SERVLET → AnnotationConfigServletWebServerApplicationContext
        //    REACTIVE → AnnotationConfigReactiveWebServerApplicationContext
        context = createApplicationContext();
        context.setApplicationStartup(this.applicationStartup);

        // ⑤ 准备上下文：设置 Environment、注册主配置类、执行所有 ApplicationContextInitializer
        prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);

        // ⑥ 核心：刷新上下文（见 1.4）
        refreshContext(context);

        // ⑦ refresh 之后：留给子类的空钩子
        afterRefresh(context, applicationArguments);

        stopWatch.stop();

        // 广播「应用就绪」事件（这是最常用的监听点，可在此做预热、清理缓存等）
        listeners.ready(context, timeTakenToStartup);

        // ⑧ 执行 ApplicationRunner 和 CommandLineRunner
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, listeners);
        throw new IllegalStateException(ex);
    }
    ...
    return context;
}

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // ① 准备刷新：记录启动时间、校验必填属性、初始化事件源集合
        prepareRefresh();

        // ② 获取 BeanFactory（Spring Boot 场景下此时其实早已创建好，这里做一个「刷新前处理」）
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // ③ 准备 BeanFactory：设置类加载器、SpEL 解析器、注册一些内置 BeanPostProcessor
        prepareBeanFactory(beanFactory);

        try {
            // ④ 子类扩展点：留给特定上下文实现注册特殊 BeanPostProcessor（Servlet 场景会注册 ServletContextAwareProcessor）
            postProcessBeanFactory(beanFactory);

            // ⑤ 执行 BeanFactoryPostProcessor（含 ConfigurationClassPostProcessor）
            //    这里完成：@Configuration 解析、@Bean 方法注册、@ComponentScan 扫描、
            //    @Import 处理（自动配置的入口 AutoConfigurationImportSelector 就在这里被触发！）
            invokeBeanFactoryPostProcessors(beanFactory);

            // ⑥ 注册 BeanPostProcessor（只是注册，不执行；执行时机在实例化 Bean 时）
            registerBeanPostProcessors(beanFactory);

            // ⑦ 初始化消息源（国际化 MessageSource）
            initMessageSource();

            // ⑧ 初始化事件广播器（ApplicationEventMulticaster）
            initApplicationEventMulticaster();

            // ⑨ 刷新钩子：ServletWebServerApplicationContext 在这里创建并启动内嵌 Tomcat（见 1.5）
            onRefresh();

            // ⑩ 注册监听器（ApplicationListener）
            registerListeners();

            // ⑪ 实例化所有非懒加载的单例 Bean（依赖注入、AOP 代理都发生在这里）
            finishBeanFactoryInitialization(beanFactory);

            // ⑫ 完成刷新：初始化 LifecycleProcessor、发布 ContextRefreshedEvent
            finishRefresh();
        }
        catch (BeansException ex) {
            // 销毁已创建的 Bean，避免残留
            destroyBeans();
            cancelRefresh(ex);
            throw ex;
        }
        finally {
            resetCommonCaches();
        }
    }
}

// ServletWebServerApplicationContext
@Override
protected void onRefresh() {
    super.onRefresh();
    try {
        // 关键：在 refresh 的第 ⑨ 步就创建 WebServer（Tomcat）
        createWebServer();
    }
    catch (Throwable ex) {
        throw new ApplicationContextException("Unable to start web server", ex);
    }
}

// TomcatWebServer
private void initialize() throws WebServerException {
    synchronized (this.monitor) {
        try {
            ...
            // 启动 Tomcat 引擎，触发初始化监听器；注意：此时「移除了 Connector」，还没绑定端口！
            this.tomcat.start();
            ...
        }
        catch (Exception ex) {
            throw new WebServerException("Unable to start embedded Tomcat", ex);
        }
    }
}

// TomcatWebServer
@Override
public void start() throws WebServerException {
    synchronized (this.monitor) {
        if (this.started) {
            return;
        }
        try {
            // 把之前移除的 Connector 重新加回来 → 绑定 8080 端口，开始接收请求
            addPreviouslyRemovedConnectors();
            Connector connector = this.tomcat.getConnector();
            if (connector != null && this.autoStart) {
                performDeferredLoadOnStartup();
            }
            checkThatConnectorsHaveStarted();
            this.started = true;
            logger.info("Tomcat started on port(s): " + getPortsDescription(true));
        }
        catch (ConnectorStartFailedException ex) {
            stopSilently();
            throw ex;
        }
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration        // ① 标记这是配置类（等价于 @Configuration）
@EnableAutoConfiguration        // ② 开启自动配置（本节的绝对主角）
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
                                // ③ 组件扫描，但排除自动配置类（避免被扫两次）
public @interface SpringBootApplication {
    ...
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage              // 记录「主类所在包」，用于 @Entity 扫描等
@Import(AutoConfigurationImportSelector.class)   // 核心：导入一个「选择器」
public @interface EnableAutoConfiguration {
    ...
}

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    }
    // ① 拿到 @EnableAutoConfiguration 注解的属性（exclude、excludeName）
    AnnotationAttributes attributes = getAttributes(annotationMetadata);

    // ② 核心：从 META-INF/spring/...AutoConfiguration.imports 文件读出「候选自动配置类」全限定名
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);

    // ③ 去重
    configurations = removeDuplicates(configurations);

    // ④ 处理手动排除的类（@EnableAutoConfiguration(exclude = ...) 或 spring.autoconfigure.exclude 配置）
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    configurations.removeAll(exclusions);

    // ⑤ 过滤：过滤掉 @AutoConfigureAfter/@AutoConfigureBefore 依赖关系不满足的（在 3.0 后基本靠 @AutoConfiguration 的顺序声明）
    configurations = getConfigurationClassFilter().filter(configurations);

    // ⑥ 触发 AutoConfigurationImportEvent（供 Actuator 等监听）
    fireAutoConfigurationImportEvents(configurations, exclusions);

    // ⑦ 返回「类全限定名 + 排除集合」
    return new AutoConfigurationEntry(configurations, exclusions);
}

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    // 关键：从指定的 imports 文件位置读取（3.x 已从 spring.factories 迁移到 .imports 文件）
    List<String> configurations = ImportCandidates.load(AutoConfiguration.class, getBeanClassLoader())
            .getCandidates();
    Assert.notEmpty(configurations,
            "No auto configuration classes found in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports.");
    return configurations;
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration(proxyBeanMethods = false)   // 内部就是一个 @Configuration
public @interface AutoConfiguration {

    // 声明「在哪个自动配置类之后」加载，取代旧的 @AutoConfigureAfter 的组合方式
    @AliasFor(annotation = Configuration.class)
    String value() default "";

    String[] after() default {};

    String[] before() default {};
}

@AutoConfiguration(before = SqlInitializationAutoConfiguration.class)
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })   // 有数据源相关类
@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory")       // 不是响应式数据源
@EnableConfigurationProperties(DataSourceProperties.class)               // 绑定 spring.datasource.* 配置
@Import({ DataSourcePoolMetadataProvidersConfiguration.class, ... })
public class DataSourceAutoConfiguration {
    // 内部还有一堆 @ConditionalOnMissingBean 的 @Bean 方法
}

# 打包后运行
java -jar target/advanced-principles-0.0.1-SNAPSHOT.jar --debug

# 或开发期直接在 IDEA 里加启动参数
# Run Configuration → Program arguments → 填入：--debug

package com.example.advancedprinciples.autoconfigure;

// 自动配置类：@AutoConfiguration 标记，proxyBeanMethods=false 关闭代理
@AutoConfiguration
// 只有当 UserService 相关类存在时才生效
@ConditionalOnClass(UserService.class)
// 绑定配置属性（可选，这里先演示无属性版本）
public class UserServiceAutoConfiguration {

    // 用户没自己定义 UserService 时才注册
    @Bean
    @ConditionalOnMissingBean
    public UserService userService() {
        // 生产级：这里应做参数校验、日志等，此处最小示例从简
        return new UserService();
    }
}

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    /** 一级缓存：存「完整可用的单例 Bean」（经过实例化+填充+初始化+可能的 AOP 代理） */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    /** 二级缓存：存「提前暴露的半成品 Bean」（已实例化，未填充完，可能是代理） */
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

    /** 三级缓存：存「能生产半成品 Bean 的工厂 ObjectFactory」 */
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

    /** 正在创建中的 Bean 名称集合（标记「这个 Bean 正在创建，还没完工」） */
    private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
}

package com.example.advancedprinciples.service;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
@RequiredArgsConstructor
public class UserService {

    // 字段注入：先演示字段注入能被三级缓存解决（构造器注入见 3.5）
    private final OrderService orderService;

    public void createUser(Long userId) {
        log.info("创建用户 {}", userId);
    }
}

package com.example.advancedprinciples.service;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
@RequiredArgsConstructor
public class OrderService {

    private final UserService userService;

    public void createOrder(Long orderId) {
        log.info("创建订单 {}", orderId);
    }
}

package com.example.advancedprinciples.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class UserService {

    // 字段注入：循环依赖的演示场景专用。
    // 生产环境请优先构造器注入（见 3.5 说明），这里仅用于观察三级缓存机制。
    @Autowired
    private OrderService orderService;

    public void createUser(Long userId) {
        log.info("创建用户 {}", userId);
    }
}

package com.example.advancedprinciples.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class OrderService {

    @Autowired
    private UserService userService;

    public void createOrder(Long orderId) {
        log.info("创建订单 {}", orderId);
    }
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 第一层：从一级缓存拿完整 Bean
    Object singletonObject = this.singletonObjects.get(beanName);
    // 一级没有，且该 Bean 正在创建中（说明发生了循环依赖）
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 第二层：从二级缓存拿「提前暴露的半成品」
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null && allowEarlyReference) {
            synchronized (this.singletonObjects) {
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null) {
                        // 第三层：从三级缓存拿「工厂」，现场生产半成品
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {
                            singletonObject = singletonFactory.getObject();  // 可能触发 AOP 代理创建
                            // 生产出来后，升级到二级缓存，并从三级缓存移除（工厂只执行一次）
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}

// AbstractAutowireCapableBeanFactory#doCreateBean 中，实例化后立即注册工厂
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

// 工厂内部
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
            // AbstractAutoProxyCreator 会在这里判断：要不要创建代理？
            // 要 → 返回代理对象；不要 → 返回原始对象
            exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
        }
    }
    return exposedObject;
}

package com.example.advancedprinciples.service;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
@RequiredArgsConstructor
public class UserService {

    private final OrderService orderService;   // 构造器注入

    public void createUser(Long userId) {
        log.info("创建用户 {}", userId);
    }
}

package com.example.advancedprinciples.service;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
@RequiredArgsConstructor
public class OrderService {

    private final UserService userService;   // 构造器注入

    public void createOrder(Long orderId) {
        log.info("创建订单 {}", orderId);
    }
}

package com.example.advancedprinciples.service;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
@RequiredArgsConstructor
public class OrderUserFacadeService {

    private final UserService userService;
    private final OrderService orderService;

    public void createOrderAndUser(Long userId, Long orderId) {
        // 组合两个服务，而不是让两个服务互相引用
        userService.createUser(userId);
        orderService.createOrder(orderId);
        log.info("组合服务完成：用户 {} 与订单 {}", userId, orderId);
    }
}

@Service
@RequiredArgsConstructor
public class UserService {

    // @Lazy 让注入的是一个「代理占位符」，真正用到时才去容器里取，从而打破构造期的循环
    @Lazy
    private final OrderService orderService;
}

package com.example.advancedprinciples.event;

import lombok.Getter;
import lombok.RequiredArgsConstructor;

// 领域事件：用户已创建
@Getter
@RequiredArgsConstructor
public class UserCreatedEvent {
    private final Long userId;
}

@Service
@RequiredArgsConstructor
public class UserService {

    private final ApplicationEventPublisher publisher;

    public void createUser(Long userId) {
        // 业务落库……
        // 发布事件，不直接依赖 OrderService
        publisher.publishEvent(new UserCreatedEvent(userId));
    }
}

@Service
@RequiredArgsConstructor
public class OrderService {

    // 监听用户创建事件，两者零直接依赖
    @EventListener
    public void onUserCreated(UserCreatedEvent event) {
        // 用户创建后，为新用户初始化订单相关逻辑
    }
}

package com.example.advancedprinciples.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 业务接口：JDK 动态代理的前提是必须有接口
public interface UserService {
    void createUser(Long userId);
}

package com.example.advancedprinciples.proxy;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class UserServiceImpl implements UserService {

    @Override
    public void createUser(Long userId) {
        // 模拟业务逻辑
        log.info("业务方法执行：创建用户 {}", userId);
    }
}

package com.example.advancedprinciples.proxy;

import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

@Slf4j
public class JdkProxyDemo {

    public static void main(String[] args) {
        // 目标对象：原始实现
        UserService target = new UserServiceImpl();

        // 生成代理对象：Proxy.newProxyInstance(类加载器, 目标接口数组, 调用处理器)
        UserService proxy = (UserService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxyObj, Method method, Object[] methodArgs) throws Throwable {
                        // 前置通知
                        log.info("【代理】方法 {} 执行前，记录日志", method.getName());
                        // 调用真实目标对象的方法
                        Object result = method.invoke(target, methodArgs);
                        // 后置通知
                        log.info("【代理】方法 {} 执行后，记录日志", method.getName());
                        return result;
                    }
                });

        // 调用方拿到的 proxy 是一个「实现 UserService 接口」的全新对象
        proxy.createUser(1001L);
    }
}

package com.example.advancedprinciples.proxy;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

@Slf4j
public class CglibProxyDemo {

    // 目标类：注意「没有接口」，JDK 动态代理做不了，CGLIB 可以做
    public static class OrderService {
        public void createOrder(Long orderId) {
            log.info("业务方法执行：创建订单 {}", orderId);
        }
    }

    public static void main(String[] args) {
        // Enhancer 是 CGLIB 的入口，用来生成子类
        Enhancer enhancer = new Enhancer();
        // 指定父类：生成的子类会继承 OrderService
        enhancer.setSuperclass(OrderService.class);
        // 设置方法拦截器
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, Method method, Object[] methodArgs, MethodProxy methodProxy) throws Throwable {
                log.info("【CGLIB】方法 {} 执行前", method.getName());
                // 调用父类（原始）方法
                Object result = methodProxy.invokeSuper(obj, methodArgs);
                log.info("【CGLIB】方法 {} 执行后", method.getName());
                return result;
            }
        });

        // 生成代理对象：它是 OrderService 的子类
        OrderService proxy = (OrderService) enhancer.create();
        proxy.createOrder(2001L);
    }
}

# application.yml（可选）—— 强制回到「有接口用 JDK，无接口用 CGLIB」的老策略
spring:
  aop:
    proxy-target-class: false   # 默认 true，即默认 CGLIB

@RestController
@RequiredArgsConstructor
public class ProxyCheckController {

    private final UserService userService;

    @GetMapping("/proxy/type")
    public String proxyType() {
        // 若输出含 "$$SpringCGLIB$$" 说明是 CGLIB；含 "$Proxy" 说明是 JDK 动态代理
        return userService.getClass().getName();
    }
}

// 精简示意：ProxyTransactionManagementConfiguration 注册了三个关键 Bean
@Configuration(proxyBeanMethods = false)
public class ProxyTransactionManagementConfiguration {

    // ① 事务拦截器：真正的「环绕通知」实现，负责开启/提交/回滚
    @Bean
    public TransactionInterceptor transactionInterceptor(TransactionAttributeSource txAttrSource, ...) {
        TransactionInterceptor interceptor = new TransactionInterceptor();
        interceptor.setTransactionAttributeSource(txAttrSource);
        interceptor.setTransactionManager(txManager);
        return interceptor;
    }

    // ② Advisor：把「事务拦截器」和「切点」绑定在一起
    @Bean
    public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(...) {
        BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
        advisor.setTransactionAttributeSource(txAttrSource);
        advisor.setAdvice(transactionInterceptor(...));
        return advisor;
    }
}

// TransactionInterceptor 是环绕通知，核心就是 invoke 方法
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
    Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
    // 委托给父类的 invokeWithinTransaction，完成「开事务 → 执行 → 提交/回滚」的环绕逻辑
    return invokeWithinTransaction(invocation.getMethod(), targetClass, new CoroutinesInvocationCallback() {
        @Override
        public Object proceedWithInvocation() throws Throwable {
            return invocation.proceed();   // 这里才真正执行目标方法
        }
        ...
    });
}

protected Object invokeWithinTransaction(Method method, Class<?> targetClass, InvocationCallback invocation) {
    // 1. 解析事务属性（传播行为、隔离级别、回滚规则）
    TransactionAttributeSource tas = getTransactionAttributeSource();
    TransactionAttribute txAttr = tas.getTransactionAttribute(method, targetClass);

    // 2. 获取事务管理器（根据数据源/事务类型选择）
    TransactionManager tm = determineTransactionManager(txAttr);

    if (txAttr == null || !(tm instanceof PlatformTransactionManager)) {
        // 没有事务属性 → 直接执行目标方法
        return invocation.proceedWithInvocation();
    }

    // 3. 开启事务（或加入已有事务，取决于传播行为）
    TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);

    Object retVal;
    try {
        // 4. 执行目标方法（环绕通知的「中间」）
        retVal = invocation.proceedWithInvocation();
    }
    catch (Throwable ex) {
        // 5. 异常 → 判断是否回滚（默认 RuntimeException/Error 回滚）
        completeTransactionAfterThrowing(txInfo, ex);
        throw ex;
    }
    finally {
        // 6. 清理线程绑定的连接等资源
        cleanupTransactionInfo(txInfo);
    }
    // 7. 正常返回 → 提交
    commitTransactionAfterReturning(txInfo);
    return retVal;
}

package com.example.advancedprinciples.service;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Slf4j
@Service
@RequiredArgsConstructor
public class PaymentService {

    private final PaymentMapper paymentMapper;

    // 没有 @Transactional：从外部调用这个方法
    public void process() {
        // 自调用：this.pay() 直接调用，绕过了代理对象
        this.pay(1001L);
    }

    // 有 @Transactional：期望这里开启事务
    @Transactional
    public void pay(Long paymentId) {
        paymentMapper.updateStatus(paymentId, "PAID");
    }
}

@Service
@RequiredArgsConstructor
public class PaymentProcessService {

    private final PaymentPayService paymentPayService;

    public void process() {
        // 通过注入的代理对象调用，事务生效
        paymentPayService.pay(1001L);
    }
}

@Service
@RequiredArgsConstructor
public class PaymentPayService {

    private final PaymentMapper paymentMapper;

    @Transactional
    public void pay(Long paymentId) {
        paymentMapper.updateStatus(paymentId, "PAID");
    }
}

@Service
@RequiredArgsConstructor
public class PaymentService {

    private final PaymentMapper paymentMapper;
    private final ApplicationContext applicationContext;

    public void process() {
        // 从容器里拿到的是「代理对象」，用它调用即可触发拦截
        PaymentService proxy = applicationContext.getBean(PaymentService.class);
        proxy.pay(1001L);
    }

    @Transactional
    public void pay(Long paymentId) {
        paymentMapper.updateStatus(paymentId, "PAID");
    }
}

// 需在配置里开启：@EnableAspectJAutoProxy(exposeProxy = true)
@Service
@RequiredArgsConstructor
public class PaymentService {

    private final PaymentMapper paymentMapper;

    public void process() {
        // AopContext.currentProxy() 拿到当前线程的代理对象
        ((PaymentService) AopContext.currentProxy()).pay(1001L);
    }

    @Transactional
    public void pay(Long paymentId) {
        paymentMapper.updateStatus(paymentId, "PAID");
    }
}

package com.example.snowflake;

import lombok.extern.slf4j.Slf4j;

/**
 * 雪花算法 ID 生成器（生产级实现）。
 *
 * 64 位结构：1 位符号位 + 41 位时间戳 + 5 位数据中心 + 5 位机器 + 12 位序列号。
 * 关键点：处理了「时钟回拨」问题——服务器时钟被回拨会导致生成重复 ID，必须防御。
 */
@Slf4j
public class SnowflakeIdGenerator {

    // 各部分的位数
    private static final long SEQUENCE_BITS = 12L;          // 序列号 12 位
    private static final long WORKER_ID_BITS = 5L;          // 机器 ID 5 位
    private static final long DATACENTER_ID_BITS = 5L;      // 数据中心 ID 5 位

    // 最大值（用于做位运算掩码）
    private static final long MAX_SEQUENCE = ~(-1L << SEQUENCE_BITS);              // 4095
    private static final long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS);            // 31
    private static final long MAX_DATACENTER_ID = ~(-1L << DATACENTER_ID_BITS);    // 31

    // 各部分的左移位数（拼接 64 位时用）
    private static final long WORKER_ID_SHIFT = SEQUENCE_BITS;                              // 12
    private static final long DATACENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;         // 17
    private static final long TIMESTAMP_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATACENTER_ID_BITS; // 22

    // 自定义纪元（2024-01-01 00:00:00 的毫秒时间戳），让时间戳部分能用更久
    private static final long EPOCH = 1704067200000L;

    private final long workerId;
    private final long datacenterId;

    private long sequence = 0L;          // 当前序列号
    private long lastTimestamp = -1L;    // 上一次生成 ID 的时间戳

    /**
     * 构造器：校验 workerId 和 datacenterId 的合法性（必须在校验范围 0~31）。
     * 这里做参数校验，保证「配置错了立刻失败」，而不是运行时产生重复 ID。
     */
    public SnowflakeIdGenerator(long workerId, long datacenterId) {
        if (workerId < 0 || workerId > MAX_WORKER_ID) {
            throw new IllegalArgumentException(
                    String.format("workerId 必须在 [0, %d] 之间，当前值：%d", MAX_WORKER_ID, workerId));
        }
        if (datacenterId < 0 || datacenterId > MAX_DATACENTER_ID) {
            throw new IllegalArgumentException(
                    String.format("datacenterId 必须在 [0, %d] 之间，当前值：%d", MAX_DATACENTER_ID, datacenterId));
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
        log.info("SnowflakeIdGenerator 初始化完成，workerId={}, datacenterId={}", workerId, datacenterId);
    }

    /**
     * 生成下一个 ID。用 synchronized 保证线程安全（序列号在同一毫秒内是共享状态）。
     * 也可以改用无锁的 AtomicLong + CAS，但雪花算法里锁的临界区极短，synchronized 足够且更清晰。
     */
    public synchronized long nextId() {
        long timestamp = currentTimeMillis();

        // 时钟回拨检测：如果当前时间小于上次时间，说明服务器时钟被回拨了
        if (timestamp < lastTimestamp) {
            long offset = lastTimestamp - timestamp;
            log.error("检测到时钟回拨，回拨了 {} 毫秒", offset);
            throw new IllegalStateException(
                    String.format("时钟回拨 %d 毫秒，拒绝生成 ID 以避免重复", offset));
        }

        if (timestamp == lastTimestamp) {
            // 同一毫秒内：序列号自增
            sequence = (sequence + 1) & MAX_SEQUENCE;
            if (sequence == 0) {
                // 序列号用完了（同一毫秒生成了 4096 个），自旋等待下一毫秒
                timestamp = waitNextMillis(lastTimestamp);
            }
        } else {
            // 新的毫秒：序列号归零
            sequence = 0L;
        }

        lastTimestamp = timestamp;

        // 拼接 64 位 ID：时间戳 + 数据中心 + 机器 + 序列号
        return ((timestamp - EPOCH) << TIMESTAMP_SHIFT)
                | (datacenterId << DATACENTER_ID_SHIFT)
                | (workerId << WORKER_ID_SHIFT)
                | sequence;
    }

    /** 自旋等待到下一毫秒 */
    private long waitNextMillis(long lastTimestamp) {
        long timestamp = currentTimeMillis();
        while (timestamp <= lastTimestamp) {
            timestamp = currentTimeMillis();
        }
        return timestamp;
    }

    private long currentTimeMillis() {
        return System.currentTimeMillis();
    }
}

package com.example.snowflake;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * 绑定 application.yml 里 snowflake.* 的配置项。
 * 前缀统一用 snowflake，避免与其他 starter 冲突。
 */
@Data
@ConfigurationProperties(prefix = "snowflake")
public class IdProperties {

    /** 是否启用雪花 ID 生成器，默认 true（配合 @ConditionalOnProperty 使用） */
    private boolean enabled = true;

    /** 机器 ID（0~31），不同机器/实例必须不同 */
    private long workerId = 1L;

    /** 数据中心 ID（0~31），不同机房必须不同 */
    private long datacenterId = 1L;
}

package com.example.snowflake;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;

/**
 * 雪花 ID 生成器的自动配置类。
 *
 * @AutoConfiguration         标记为自动配置类（proxyBeanMethods=false，性能更好）
 * @ConditionalOnClass        只有 classpath 存在 SnowflakeIdGenerator 才生效
 * @ConditionalOnProperty     只有 snowflake.enabled=true（默认）才生效，允许用户一键关闭
 * @EnableConfigurationProperties 把 IdProperties 注册进容器并绑定配置
 */
@Slf4j
@AutoConfiguration
@ConditionalOnClass(SnowflakeIdGenerator.class)
@ConditionalOnProperty(prefix = "snowflake", name = "enabled", havingValue = "true", matchIfMissing = true)
@EnableConfigurationProperties(IdProperties.class)
public class IdAutoConfiguration {

    /**
     * 注册 ID 生成器。
     * @ConditionalOnMissingBean 用户自己定义了 SnowflakeIdGenerator 时，不覆盖用户的。
     * 这是「默认配置可被用户覆盖」的关键。
     */
    @Bean
    @ConditionalOnMissingBean
    public SnowflakeIdGenerator snowflakeIdGenerator(IdProperties properties) {
        log.info("自动配置 SnowflakeIdGenerator，workerId={}, datacenterId={}",
                properties.getWorkerId(), properties.getDatacenterId());
        return new SnowflakeIdGenerator(properties.getWorkerId(), properties.getDatacenterId());
    }

    /**
     * 对外提供的门面服务：封装 nextId()，返回 String 类型（避免前端 JS 的 long 精度丢失）。
     */
    @Bean
    @ConditionalOnMissingBean
    public IdService idService(SnowflakeIdGenerator generator) {
        return new IdService(generator);
    }
}

package com.example.snowflake;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

/**
 * 对外提供的门面服务：业务方直接注入 IdService 即可。
 * 返回 String 而不是 long：前端 JavaScript 的 Number 只能精确表示到 2^53，
 * 雪花 ID（64 位）超过后会丢精度，故用 String 传输。
 */
@Slf4j
@RequiredArgsConstructor
public class IdService {

    private final SnowflakeIdGenerator generator;

    /** 生成一个 ID（String 形式，避免前端精度丢失） */
    public String nextId() {
        return String.valueOf(generator.nextId());
    }

    /** 批量生成 ID，返回 long 数组（内部使用时用 long 更高效） */
    public long[] nextIds(int count) {
        if (count <= 0) {
            throw new IllegalArgumentException("批量生成数量必须大于 0，当前值：" + count);
        }
        long[] ids = new long[count];
        for (int i = 0; i < count; i++) {
            ids[i] = generator.nextId();
        }
        return ids;
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>snowflake-spring-boot-starter</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>
    <name>snowflake-spring-boot-starter</name>

    <properties>
        <java.version>17</java.version>
        <spring-boot.version>3.2.5</spring-boot.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- 用 BOM 统一管理 Spring Boot 依赖版本 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!-- 只依赖「自动配置」所需的最小集合，不引入 spring-boot-starter-web 等重依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <!-- @ConfigurationProperties 的注解处理器：生成配置元数据，让 IDE 有提示 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>

mvn clean install

<dependency>
    <groupId>com.example</groupId>
    <artifactId>snowflake-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

# application.yml
snowflake:
  enabled: true          # 是否启用（默认 true）
  worker-id: 1           # 机器 ID，多实例部署时每个实例必须不同
  datacenter-id: 2       # 数据中心 ID

package com.example.advancedprinciples.controller;

import com.example.snowflake.IdService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@RestController
@RequiredArgsConstructor
public class IdController {

    private final IdService idService;   // 直接注入 Starter 提供的 Bean

    @GetMapping("/id")
    public Map<String, Object> nextId() {
        // 生产级：返回结构统一，包含生成的 ID
        Map<String, Object> result = new HashMap<>();
        result.put("id", idService.nextId());
        result.put("timestamp", System.currentTimeMillis());
        return result;
    }
}

package com.example.advancedprinciples.reactive;

import lombok.extern.slf4j.Slf4j;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.time.Duration;
import java.util.Arrays;
import java.util.List;

@Slf4j
public class ReactorDemo {

    public static void main(String[] args) {
        // Mono：0 或 1 个元素
        Mono<String> mono = Mono.just("Hello Reactive");
        // 订阅才会真正触发执行（惰性），onNext 拿到数据，onError 处理异常，onComplete 表示结束
        mono.subscribe(
                data -> log.info("Mono 收到：{}", data),
                err -> log.error("Mono 出错", err),
                () -> log.info("Mono 完成")
        );

        // Flux：0 到 N 个元素
        List<String> names = Arrays.asList("alice", "bob", "cindy");
        Flux<String> flux = Flux.fromIterable(names)
                // 操作符：过滤
                .filter(name -> name.length() > 3)
                // 操作符：转换
                .map(String::toUpperCase);
        flux.subscribe(name -> log.info("Flux 收到：{}", name));

        // 响应式是「流式编程」：像 Java Stream 一样链式操作，但底层是异步非阻塞的
        Flux.interval(Duration.ofMillis(100))   // 每 100ms 发一个数字
                .take(5)                         // 只取前 5 个
                .map(i -> "第 " + i + " 个")
                .subscribe(log::info);
    }
}

package com.example.advancedprinciples.reactive;

import lombok.extern.slf4j.Slf4j;
import org.reactivestreams.Subscription;
import reactor.core.publisher.Flux;
import reactor.core.publisher.FluxSink;

@Slf4j
public class BackpressureDemo {

    public static void main(String[] args) throws InterruptedException {
        // 用 create 手动控制数据流，模拟「上游能发很快」的场景
        Flux<Integer> flux = Flux.create((FluxSink<Integer> sink) -> {
            int i = 0;
            while (i < 1000) {
                log.info("上游尝试发出：{}", i);
                sink.next(i++);   // 发出元素
            }
            sink.complete();
        }, FluxSink.OverflowStrategy.DROP);   // 下游处理不过来时，丢弃新元素（策略之一）

        flux
                // onBackpressureBuffer：下游处理不过来时，先缓冲（默认有界 256）
                // 这里改用 limitRate 演示「下游主动请求」控制上游速率
                .limitRate(10)   // 每次最多请求 10 个元素
                .subscribe(new org.reactivestreams.Subscriber<Integer>() {
                    private Subscription subscription;

                    @Override
                    public void onSubscribe(Subscription s) {
                        this.subscription = s;
                        // 关键：下游只请求 5 个，上游就只发 5 个，这就是背压
                        subscription.request(5);
                    }

                    @Override
                    public void onNext(Integer value) {
                        log.info("下游处理：{}", value);
                        // 处理完再请求 1 个（慢消费者：一个接一个地要）
                        subscription.request(1);
                    }

                    @Override
                    public void onError(Throwable t) {
                        log.error("出错", t);
                    }

                    @Override
                    public void onComplete() {
                        log.info("处理完成");
                    }
                });

        Thread.sleep(3000);
    }
}