// 构造器注入（✅ 推荐，Spring 官方推荐）
@Service
public class UserService {
    private final UserDao userDao;
    private final RoleDao roleDao;

    public UserService(UserDao userDao, RoleDao roleDao) {
        this.userDao = userDao;
        this.roleDao = roleDao;
    }
}

// 字段注入（⚠️ 最常见但非最佳）
@Service
public class UserService {
    @Autowired
    private UserDao userDao;
}

// BeanFactory：延迟加载
BeanFactory factory = new DefaultListableBeanFactory();
// userService 此时并未创建，直到 getBean() 被调用

// ApplicationContext：预实例化
ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
// 容器启动完成时，非懒加载的 singleton Bean 已经创建完毕

// DefaultSingletonBeanRegistry.java — Spring 源码
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    // 一级缓存：完全初始化的 Bean（成品池）
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    // 二级缓存：早期暴露的 Bean（半成品，属性未注入）
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

    // 三级缓存：Bean 工厂对象（用于生成早期代理）
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

    // 正在创建中的 Bean 名称集合（用于检测循环依赖）
    private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
}

// AbstractAutowireCapableBeanFactory.java — Spring 源码核心逻辑
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {

    // ──────────── 阶段一：实例化（创建原始对象） ────────────
    BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
    Object bean = instanceWrapper.getWrappedInstance();

    // ──────────── 阶段二：允许后置处理器修改 BeanDefinition ────────────
    // MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()
    // 例如：AutowiredAnnotationBeanPostProcessor 在这里解析 @Autowired 元数据
    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

    // ──────────── 阶段三：提前暴露引用（解决循环依赖的关键） ────────────
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences
            && isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        // ★ 将 lambda 放入三级缓存
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // ──────────── 阶段四：依赖注入（属性填充） ────────────
    Object exposedObject = bean;
    populateBean(beanName, mbd, instanceWrapper);  // ★ @Autowired 注入在这里发生
    //     └── InstantiationAwareBeanPostProcessor.postProcessProperties()
    //         └── AutowiredAnnotationBeanPostProcessor 处理 @Autowired

    // ──────────── 阶段五：初始化 ────────────
    exposedObject = initializeBean(beanName, exposedObject, mbd);

    // ──────────── 阶段六：循环依赖检查 ────────────
    if (earlySingletonExposure) {
        Object earlySingletonReference = getSingleton(beanName, false);
        if (earlySingletonReference != null) {
            // 如果 initializeBean() 返回了不同的对象（被代理了），但早期暴露的是另一个对象
            // 则以早期暴露的为准，保证引用一致性
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
        }
    }

    return exposedObject;
}

// AbstractBeanFactory.getBean() → doGetBean()
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType,
        @Nullable Object[] args, boolean typeCheckOnly) {

    // ① 转换 Bean 名称（处理别名、&前缀）
    String beanName = transformedBeanName(name);

    // ② ★ 从三级缓存中获取
    Object sharedInstance = getSingleton(beanName);
    //    ├── singletonObjects（一级缓存）→ 找到直接返回
    //    ├── earlySingletonObjects（二级缓存）→ 找到直接返回
    //    └── singletonFactories（三级缓存）→ 调用 ObjectFactory.getObject()
    //          └── 生成的 Bean 放入二级缓存，从三级缓存移除

    if (sharedInstance != null && args == null) {
        // ③ 处理 FactoryBean：如果 Bean 是 FactoryBean，调用 getObject()
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        return bean;
    }

    // ④ 检查循环依赖（prototype 作用域）
    if (isPrototypeCurrentlyInCreation(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName); // 循环依赖异常
    }

    // ⑤ 如果当前容器没有此 BeanDefinition，委派给父容器
    BeanFactory parentBeanFactory = getParentBeanFactory();
    if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
        return parentBeanFactory.getBean(name);
    }

    // ⑥ 标记 bean 正在创建中（循环依赖检测的基础）
    markBeanAsCreated(beanName);

    // ⑦ 合并 BeanDefinition（子定义 + 父定义）
    RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

    // ⑧ 先创建依赖的 Bean（@DependsOn）
    String[] dependsOn = mbd.getDependsOn();
    for (String dep : dependsOn) {
        getBean(dep); // 递归创建
    }

    // ⑨ 根据作用域创建 Bean
    if (mbd.isSingleton()) {
        // 单例：getSingleton() → createBean()
        //      → 放入 singletonObjects
        sharedInstance = getSingleton(beanName, () -> {
            return createBean(beanName, mbd, args);
        });
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }
    else if (mbd.isPrototype()) {
        // 原型：每次创建新实例
        Object prototypeInstance = createBean(beanName, mbd, args);
        bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    }
    else {
        // 其他作用域（request, session, application）
        String scopeName = mbd.getScope();
        Scope scope = this.scopes.get(scopeName);
        Object scopedInstance = scope.get(beanName, () -> {
            return createBean(beanName, mbd, args);
        });
        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    }

    return bean;
}

// AutowiredAnnotationBeanPostProcessor — @Autowired 的核心处理器
// 它实现了 InstantiationAwareBeanPostProcessor

// 第一步：在 postProcessMergedBeanDefinition() 中解析需要注入的元数据
//   对于每个 Bean，扫描其字段和方法，找到所有 @Autowired / @Value 标注的注入点
//   将元数据缓存到 InjectionMetadataCache 中

// 第二步：在 postProcessProperties() 中执行实际的注入
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    // ① 获取缓存的注入元数据
    InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);

    // ② 执行注入
    metadata.inject(bean, beanName, pvs);
    //     ├── AutowiredFieldElement.inject()    — 字段注入
    //     │     └── beanFactory.resolveDependency()
    //     │           └── doResolveDependency()
    //     │                 ├── 处理 @Value → 解析 SpEL
    //     │                 ├── 处理集合注入 → 按类型找到所有匹配 Bean
    //     │                 └── 处理单值注入 → 按类型找到唯一 Bean
    //     └── AutowiredMethodElement.inject()   — setter 方法注入

    return pvs;
}

// DefaultListableBeanFactory.doResolveDependency()
public Object doResolveDependency(DependencyDescriptor descriptor, ...) {

    // ① 尝试快捷方式：如果描述符可直接解析，直接返回
    Object shortcut = descriptor.resolveShortcut(this);
    if (shortcut != null) return shortcut;

    Class<?> type = descriptor.getDependencyType();

    // ② 处理 @Value 注解
    Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
    if (value != null) {
        // 解析表达式 ${...} 或 SpEL #{...}
        return resolveEmbeddedValue((String) value);
    }

    // ③ 处理集合/数组/Map 类型
    //    → 找到 type 的所有匹配 Bean → 返回 List/Map
    Object multipleBeans = resolveMultipleBeans(descriptor, ...);

    // ④ 处理单值类型 — ★ 核心逻辑
    Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
    //     └── 从容器中找到所有 type 类型的 Bean 名称
    //         └── 过滤掉自身、不匹配的 Bean

    if (matchingBeans.isEmpty()) {
        // ⑤ 没有找到匹配的 Bean
        if (isRequired(descriptor)) {
            raiseNoMatchingBeanFound(type, ...); // → NoSuchBeanDefinitionException
        }
        return null;
    }

    if (matchingBeans.size() > 1) {
        // ⑥ 多个候选 Bean — 候选已先经过 @Qualifier 等规则过滤，再进行消歧
        autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
        //     ├── @Primary
        //     ├── @Priority
        //     └── resolvableDependencies 或依赖名称匹配
        if (autowiredBeanName == null) {
            throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet());
        }
    }

    // ⑦ 唯一匹配 → 调用 getBean() —— 递归创建！
    return getBean(autowiredBeanName);
}

// @Autowired：默认按类型
@Autowired
private UserService userService;  // 按类型找 UserService

@Autowired
@Qualifier("userServiceImpl")     // 按名称精确定位
private UserService userService;

// @Resource：显式指定 name 时按该名称查找
@Resource(name = "userServiceImpl")
private UserService userService;

// singleton（默认）— 无状态，Spring 容器中仅一份
// 常见于 Controller、Service、Repository
@Service
public class UserService {
    // 无状态，所有线程共享 → 线程安全（前提是不持有可变状态）
}

// prototype — 有状态，每次获取都是新实例
@Scope("prototype")
@Service
public class ExportTask {
    private final List<Object> taskData = new ArrayList<>(); // 实例级状态
    // 每次任务获取一个新实例 → 不同任务互不干扰
}

// 方案 1：注入 ApplicationContext，每次手动获取
@Autowired
private ApplicationContext ctx;
public void doExport() {
    ExportService service = ctx.getBean(ExportService.class); // 每次获取新实例
}

// 方案 2：@Lookup 注解（Spring 会通过 CGLIB 生成方法体）
@Lookup
public ExportService getExportService() { return null; }

// 方案 3：使用 ObjectFactory / ObjectProvider
@Autowired
private ObjectProvider<ExportService> provider;
public void doExport() {
    ExportService service = provider.getObject(); // 每次获取新实例
}

// 实现 Scope 接口，实现 get() 和 remove() 方法
// 注册到 Spring 容器
@Component
public class ThreadScope implements Scope {
    private final ThreadLocal<Map<String, Object>> threadScope = ThreadLocal.withInitial(HashMap::new);

    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Map<String, Object> scope = threadScope.get();
        return scope.computeIfAbsent(name, k -> objectFactory.getObject());
    }

    @Override
    public Object remove(String name) {
        return threadScope.get().remove(name);
    }
}

// 项目中类似的使用模式（工作流引擎中的复杂对象构建）
@Component
public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory> {

    @Override
    public SqlSessionFactory getObject() throws Exception {
        // 复杂的创建逻辑
        return new SqlSessionFactoryBuilder().build(configuration);
    }

    @Override
    public Class<?> getObjectType() {
        return SqlSessionFactory.class;
    }

    @Override
    public boolean isSingleton() {
        return true;  // 单例
    }
}

// 获取方式：
// 1. getBean("sqlSessionFactoryBean") → 返回 SqlSessionFactory（getObject() 的返回值）
// 2. getBean("&sqlSessionFactoryBean") → 返回 SqlSessionFactoryBean 本身 ★

@Configuration  // ★ proxyBeanMethods = true（默认）
public class AppConfig {

    @Bean
    public UserDao userDao() {
        return new UserDaoImpl();
    }

    @Bean
    public UserService userService() {
        // 这里调用 userDao()，返回的是容器中的单例 Bean，而非 new UserDaoImpl()
        return new UserService(userDao());
    }
}

// CGLIB 生成的代理类（伪代码）
public class AppConfig$$SpringCGLIB$$0 extends AppConfig {

    @Override
    public UserDao userDao() {
        // 检查容器中是否有 userDao Bean
        if (beanFactory.containsSingleton("userDao")) {
            return beanFactory.getBean(UserDao.class);  // 返回已有单例
        }
        return super.userDao();  // 首次调用，执行原始方法
    }

    @Override
    public UserService userService() {
        return super.userService(); // 调用父类方法（父类中调 userDao() 已走代理）
    }
}

@Component  // 或者 @Configuration(proxyBeanMethods = false)
public class AppConfig {

    @Bean
    public UserDao userDao() {
        return new UserDaoImpl();
    }

    @Bean
    public UserService userService() {
        // ❌ 这样写每次都会创建新的 UserDaoImpl！
        return new UserService(userDao());
    }
}

@Configuration(proxyBeanMethods = false)
public class AppConfig {

    @Bean
    public UserDao userDao() {
        return new UserDaoImpl();
    }

    @Bean
    public UserService userService(UserDao userDao) {
        return new UserService(userDao);
    }
}

// 在所有 BeanDefinition 加载完成后、Bean 实例化之前执行
// 适合修改 BeanDefinition 的元数据
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 修改 BeanDefinition、注册新的 Bean、修改属性等
    }
}

// 在每个 Bean 初始化前后执行
// Spring AOP、@Autowired 都是基于此实现
public interface BeanPostProcessor {
    // 初始化前（在 @PostConstruct 之前）
    default Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }
    // 初始化后（在 @PostConstruct 之后）→ AOP 代理在此生成
    default Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }
}

// BeanPostProcessor 的子接口，更底层的控制
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {

    // ★ 实例化前：可在此返回代理对象，绕过默认的构造器实例化
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
        return null; // null = 继续默认流程
    }

    // 实例化后：可在此修改 Bean（如属性值处理）
    default boolean postProcessAfterInstantiation(Object bean, String beanName) {
        return true; // true = 继续属性注入
    }

    // 属性注入阶段：处理 @Autowired、@Value 等 ★
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        return pvs;
    }
}

// 自定义 BeanPostProcessor 的典型场景：
// 1. 租户上下文注入
// 2. 数据权限控制
// 3. 自定义注解的自动装配

// 实战模板：自定义注解处理器
@Component
public class CustomAnnotationBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        // 扫描 bean 上的自定义注解
        Field[] fields = bean.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(CustomInject.class)) {
                field.setAccessible(true);
                // 注入自定义值
            }
        }
        return bean;
    }
}

// ❌ 字段注入 — 虽然简洁，但有很多缺点
@Service
public class UserService {
    @Autowired
    private UserDao userDao;          // 不能声明为 final
    @Autowired
    private RoleService roleService;  // 依赖越来越多时难以发现
    // 问题：单元测试需要反射注入，依赖过多时没有编译期告警
}

// ✅ 构造器注入 — Spring 官方推荐
@Service
public class UserService {
    private final UserDao userDao;
    private final RoleService roleService;

    public UserService(UserDao userDao, RoleService roleService) {
        this.userDao = userDao;
        this.roleService = roleService;
    }
    // 优点：
    // 1. 依赖不可变（final）
    // 2. 构造器中保证不为 null
    // 3. 依赖过多时构造器会臃肿 → 提示需要重构
    // 4. 单元测试可以直接 new 并传入 mock
}

// ✅ 构造器注入的 Lombok 简化版
@Service
@RequiredArgsConstructor
public class UserService {
    private final UserDao userDao;  // final → Lombok 生成构造器
    private final RoleService roleService;
}

// ❌ 危险：同类型多个 Bean，未指定名称
@Component
public class MessageService { }

@Component
public class AliyunMessageService extends MessageService { }
// Spring Boot 启动时可能不报错，但 @Autowired 注入时抛出 NoUniqueBeanDefinitionException

// ✅ 方案 1：指定 Bean 名称
@Component("messageService")
public class MessageServiceImpl implements IMessageService { }

@Component("aliyunMessageService")
public class AliyunMessageServiceImpl implements IMessageService { }

// ✅ 方案 2：注入时指定名称
@Autowired
@Qualifier("messageService")
private IMessageService messageService;

// ✅ 方案 3：使用 @Primary
@Component
@Primary  // 默认使用的实现
public class DefaultMessageService implements IMessageService { }

// ✅ 方案 4：集合注入
@Autowired
private List<IMessageService> messageServices;  // 注入所有实现

// 场景：A 和 B 互相依赖，且都使用构造器注入
@Service
public class ServiceA {
    private final ServiceB serviceB;

    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

@Service
public class ServiceB {
    private final ServiceA serviceA;

    public ServiceB(ServiceA serviceA) {
        this.serviceA = serviceA;
    }
}
// 启动报错：BeanCurrentlyInCreationException ★

// ✅ 解决方案 1：@Lazy 打破循环
@Service
public class ServiceA {
    private final ServiceB serviceB;
    public ServiceA(@Lazy ServiceB serviceB) {
        this.serviceB = serviceB;  // 注入的是代理，首次调用时才真正获取
    }
}

// ✅ 解决方案 2：重构设计（最推荐）
// 构造器循环依赖往往是设计问题的信号
// - 提取第三个类 C，A 和 B 都依赖 C
// - 将部分功能合并到一个类
// - 使用事件驱动解耦（@EventListener / ApplicationEventPublisher）

// 全局懒加载
spring:
  main:
    lazy-initialization: true  # 所有 Bean 延迟初始

// 包级别懒加载
@ComponentScan(basePackages = "com.example", lazyInit = true)

// 单个 Bean 懒加载
@Component
@Lazy
public class HeavyInitService { ... }

// 仅在特定场景注入懒 Bean
@Autowired
@Lazy
private HeavyInitService heavyInitService;  // 实际使用时才创建

// 1. 实现 DisposableBean 或 @PreDestroy
@Service
public class ResourceService implements DisposableBean {

    @Override
    public void destroy() {
        // 释放外部资源：数据库连接池、文件句柄、网络连接等
        closeResources();
    }
}

// 2. 配合 Spring Boot 优雅关闭配置
// application.yml
server:
  shutdown: graceful  # 优雅关闭
spring:
  lifecycle:
    timeout-per-shutdown-phase: 30s  # 每个阶段超时 30 秒

// 3. 线程池的优雅关闭
@PreDestroy
public void shutdown() {
    executor.shutdown();
    try {
        if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
            executor.shutdownNow();  // 超时后强制关闭
        }
    } catch (InterruptedException e) {
        executor.shutdownNow();
        Thread.currentThread().interrupt();
    }
}

// ❌ 不推荐：字段注入
@Configuration
public class AppConfig {
    @Autowired
    private DataSource dataSource;  // 字段注入

    @Bean
    public JdbcTemplate jdbcTemplate() {
        return new JdbcTemplate(dataSource);
    }
}

// ✅ 推荐：方法参数注入
@Configuration
public class AppConfig {

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

// 1. 缩小扫描范围
// ❌
@ComponentScan(basePackages = "com.example")
// ✅
@ComponentScan(basePackages = {"com.example.order", "com.example.user"})

// 2. 排除不需要自动配置的类
@SpringBootApplication(exclude = {
    SomeUnusedAutoConfiguration.class
})

// 3. 使用 @Lazy 延迟初始化非核心 Bean

// 4. 关闭不必要的 @Configuration 代理
@Configuration(proxyBeanMethods = false)  // 如果没有跨 @Bean 方法引用
public class AppConfig { ... }