// 入口代码
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = 
            new AnnotationConfigApplicationContext(AppConfig.class);
        // 此时容器已初始化完毕
    }
}

1. 扫描（Scan）
   └─ 找到所有 @Component 类 → BeanDefinition 注册到 BeanFactory

2. 推断构建方法
   └─ 确定每个 Bean 使用哪个构造器

3. 实例化 + 初始化（生命周期回调）

flowchart TD
    A[创建 ApplicationContext] --> B[注册配置类 BeanDefinition]
    B --> C[调用 refresh 方法]
    C --> D[invokeBeanFactoryPostProcessors]
    D --> E[扫描包路径, 注册所有 BeanDefinition]
    E --> F[registerBeanPostProcessors]
    F --> G[finishBeanFactoryInitialization]
    G --> H[实例化所有非懒加载单例 Bean]

    D --> D1[BeanFactoryPostProcessor 处理 @Configuration]
    E --> E1[{
'beanDefinitions': 所有类都被扫描为 BeanDefinition
}]
    H --> H1[调用 getBean → doGetBean → createBean]

flowchart LR
    A[BeanDefinition] --> B[实例化 Instantiation]
    B --> C[属性赋值 Populate]
    C --> D[Aware 接口回调]
    D --> E[BeanPostProcessor before]
    E --> F[初始化方法 Init]
    F --> G[BeanPostProcessor after]
    G --> H[就绪 Ready]
    H --> I[销毁 Destroy]

    D --> D1[BeanNameAware / BeanFactoryAware<br/>ApplicationContextAware]
    E --> E1[@PostConstruct / InitializingBean]
    F --> F1[@Bean(initMethod)]
    G --> G1[AOP 代理创建点]
    I --> I1[@PreDestroy / DisposableBean]

// DefaultSingletonBeanRegistry
public class DefaultSingletonBeanRegistry {
    // 一级缓存：完整初始化的单例 Bean
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    // 二级缓存：早期暴露的 Bean（还未完全初始化）
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

    // 三级缓存：ObjectFactory 延迟生成代理
    private final Map<String, ObjectFactory> singletonFactories = new HashMap<>(16);
}

@Component
public class A {
    @Autowired
    private B b;
}

@Component
public class B {
    @Autowired
    private A a;
}

1. 创建 A：实例化 A → A 放入三级缓存 → 属性注入 B
2. 创建 B：实例化 B → B 放入三级缓存 → 属性注入 A
3. B 注入 A：从三级缓存取 A → 执行 ObjectFactory → 放入二级缓存
4. B 完成初始化：从二级缓存/或者finalAOP代理→put一级
5. A 完成初始化：从一级取B→注入→A完成→put一级

class AutowiredAnnotationBeanPostProcessor {
    @Override
    public PropertyValues postProcessProperties(
            PropertyValues pvs, Object bean, String beanName) {

        InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass());
        metadata.inject(bean, beanName, pvs);
        return pvs;
    }
}

// Spring 遍历所有构造器，选最优的
@Component
public class UserService {
    private final UserRepository userRepository;

    // Spring 自动选这个构造器（唯一或最"肥"的）
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

public abstract class AbstractAutoProxyCreator {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof AopInfrastructureBean) {
            return bean;
        }

        // 检查是否有 Advisor 匹配该 Bean
        Advisor[] advisors = getAdvicesAndAdvisorsForBean(
                bean.getClass(), beanName, null);

        if (advisors != null) {
            // 创建代理对象
            return createProxy(bean.getClass(), beanName, 
                    specificInterceptors, new SingletonTargetSource(bean));
        }
        return bean;
    }
}

sequenceDiagram
    participant Client as 调用方
    participant Proxy as AOP 代理对象
    participant Chain as 拦截器链
    participant Target as 目标方法

    Client->>Proxy: userService.findUser()
    Proxy->>Chain: 调用拦截器链
    Note over Chain: 第一个拦截器: @Around
    Chain->>Chain: 第二个拦截器: @Before
    Chain->>Target: proceed() 调用目标
    Chain->>Chain: 第三个拦截器: @AfterReturning
    Chain-->>Proxy: 返回结果
    Proxy-->>Client: 结果

    Note over Chain: 责任链模式
    Note over Chain: 顺序: Around → Before → 目标 → After → AfterReturning

@Service
public class UserService {

    @Transactional
    public void methodA() {
        methodB(); // 自调用：不会触发事务
    }

    @Transactional
    public void methodB() {
        // 数据库操作
    }
}

// 1. 注入自身代理（Spring 5+ 可用 @Lazy 解决循环依赖）
@Autowired
@Lazy
private UserService self;

public void methodA() {
    self.methodB(); // 通过代理调用
}

// 2. 提取到另一个 Service（推荐）
public void methodA() {
    auditService.methodB(); // 独立 Bean
}

public class TransactionInterceptor extends TransactionAspectSupport 
        implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // 获取事务属性
        TransactionAttribute txAttr = getTransactionAttributeSource()
                .getTransactionAttribute(invocation.getMethod(), targetClass);

        // 获取 PlatformTransactionManager
        PlatformTransactionManager tm = getTransactionManager();

        // 执行带事务的调用
        return invokeWithinTransaction(invocation.getMethod(), targetClass, 
                invocation::proceed, txAttr, tm);
    }
}

@Override
protected Object doBeginTransaction(
        Object transaction, TransactionDefinition definition) {
    DataSourceTransactionObject txObject = 
        (DataSourceTransactionObject) transaction;

    Connection con = txObject.getConnectionHolder().getConnection();

    // REQUIRES_NEW：挂起当前事务，获取新连接
    if (txObject.hasTransaction()) {
        suspend(txObject);  // 保存当前事务状态
    }

    // 设置自动提交关闭、隔离级别等
    con.setAutoCommit(false);
    // ...
}

flowchart TD
    subgraph "隔离级别与问题"
        READ_UNCOMMITTED -->|脏读+不可重复读+幻读| LOW[并发高, 一致性低]
        READ_COMMITTED -->|不可重复读+幻读| MID[PG/默认]
        REPEATABLE_READ -->|幻读| HIGH
        SERIALIZABLE -->|无并发问题| HIGHEST[并发极低]
    end

// JDBC 的原始写法——每个方法都要重复的样板代码
public class UserJdbcDao {

    public User findById(Long id) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            // 1. 获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db", 
                                                 "user", "password");

            // 2. 创建 PreparedStatement，设置参数
            ps = conn.prepareStatement("SELECT * FROM user WHERE id = ?");
            ps.setLong(1, id);

            // 3. 执行 SQL
            rs = ps.executeQuery();

            // 4. 处理结果集，手动映射为对象
            User user = null;
            if (rs.next()) {
                user = new User();
                user.setId(rs.getLong("id"));
                user.setName(rs.getString("name"));
                user.setEmail(rs.getString("email"));
                // 如果表有 20 列，这里就要写 20 行
            }
            return user;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            // 5. 关闭资源（最容易忘记的一步）
            try { if (rs != null) rs.close(); } catch (Exception e) {}
            try { if (ps != null) ps.close(); } catch (Exception e) {}
            try { if (conn != null) conn.close(); } catch (Exception e) {}
        }
    }

    // 每个方法都要重复上述整个流程！
}

flowchart LR
    JDBC[纯 JDBC\n灵活但代码冗长] -->|MyBatis\n封装了这层| SEMI[SQL 写在 XML\n映射交给框架]
    Hibernate[全自动 ORM\nSQL 由框架生成] -->|但 SQL 调优困难| SEMI
    SEMI -->|MyBatis 的定位| M[半自动 ORM\nSQL 可控\n映射自动]

flowchart TD
    subgraph 接口层
        API[SqlSession\n核心 API]
        API2[SqlSessionFactory\n工厂]
    end

    subgraph 核心处理层
        C1[Configuration\n全局配置]
        MAP[MapperRegistry\n映射器注册]
        SQL[SqlSource\nSQL 语句封装]
        PA[ParameterHandler\n参数处理器]
        RS[ResultSetHandler\n结果集处理器]
        STMT[StatementHandler\nStatement 处理器]
        EXEC[Executor\n执行器]
    end

    subgraph 基础支持层
        D1[数据源模块]
        D2[事务管理]
        D3[缓存模块\n一级/二级]
        D4[TypeHandler\n类型处理器]
        D5[日志模块]
        D6[反射工具箱\nMetaObject]
    end

    subgraph JDBC
        JDBC_PKG[java.sql.*]
    end

    API --> EXEC
    EXEC --> STMT
    STMT --> PA
    STMT --> RS
    EXEC --> D3
    STMT --> JDBC_PKG

// 一个典型的 MyBatis 查询
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = mapper.findById(1L);

// 内部流转：
// 1. mapper.findById(1L) → MapperProxy.invoke()
// 2. → MapperMethod.execute()
// 3. → SqlSession.selectOne()
// 4. → Executor.query()
// 5. → StatementHandler.query()
// 6. → ParameterHandler.setParameters()
// 7. → PreparedStatement.executeQuery()
// 8. → ResultSetHandler.handleResultSets()
// 9. → 返回 User 对象

public class XMLConfigBuilder extends BaseBuilder {

    // 解析 MyBatis 全局配置文件的入口
    public Configuration parse() {
        if (parsed) {
            throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        }
        parsed = true;

        // 从 XML 根节点  开始，按顺序解析子元素：
        parseConfiguration(parser.evalNode("/configuration"));
        return configuration;
    }

    // 配置元素解析顺序（必须遵循这个顺序，否则报错）
    private void parseConfiguration(XNode root) {
        try {
            // 1. 解析 （外部属性文件）
            propertiesElement(root.evalNode("properties"));
            // 2. 解析 （全局配置参数）
            Properties settings = settingsAsProperties(root.evalNode("settings"));
            // 3. 解析 
            loadCustomVfs(settings);
            loadCustomLogImpl(settings);
            // 4. 解析 （类型别名）
            typeAliasesElement(root.evalNode("typeAliases"));
            // 5. 解析 （拦截器插件）
            pluginElement(root.evalNode("plugins"));
            // 6. 解析 
            objectFactoryElement(root.evalNode("objectFactory"));
            // 7. 解析 
            objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
            // 8. 解析 
            reflectorFactoryElement(root.evalNode("reflectorFactory"));
            // 9. 解析  应用到 Configuration
            settingsElement(settings);
            // 10. 解析 （数据源 + 事务管理器）
            environmentsElement(root.evalNode("environments"));
            // 11. 解析 
            databaseIdProviderElement(root.evalNode("databaseIdProvider"));
            // 12. 解析 （自定义类型处理器）
            typeHandlerElement(root.evalNode("typeHandlers"));
            // 13. 解析 （映射器文件）
            mapperElement(root.evalNode("mappers"));
        } catch (Exception e) {
            throw new BuilderException("Error parsing SQL Mapper Configuration.", e);
        }
    }
}

public class MapperRegistry {

    private final Configuration config;
    // Mapper 接口 → MapperProxyFactory 的映射
    private final Map<Class, MapperProxyFactory> knownMappers = new HashMap<>();

    // 注册 Mapper 接口
    public <T> void addMapper(Class<T> type) {
        // 检查：必须是接口
        if (type.isInterface()) {
            if (hasMapper(type)) {
                throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
            }
            boolean loadCompleted = false;
            try {
                // 创建 MapperProxyFactory
                knownMappers.put(type, new MapperProxyFactory<>(type));

                // 解析 Mapper 接口上的注解（@Options 等）
                XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(
                    type.getResourceAsStream(type.getName().replace('.', '/') + ".xml"),
                    config, type.getName(), config.getSqlFragments());
                xmlMapperBuilder.parse();

                loadCompleted = true;
            } finally {
                if (!loadCompleted) {
                    knownMappers.remove(type);
                }
            }
        }
    }
}

// 为什么 Mapper 接口不需要实现类？
// 答案：通过 JDK 动态代理
public class MapperProxy<T> implements InvocationHandler, Serializable {

    private final SqlSession sqlSession;
    private final Class<T> mapperInterface;
    private final Map<Method, MapperMethodInvoker> methodCache;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            // 如果是 Object 类的方法，直接调用
            if (Object.class.equals(method.getDeclaringClass())) {
                return method.invoke(this, args);
            }

            // 处理默认方法（JDK 8+）
            if (method.isDefault()) {
                return invokeDefaultMethod(proxy, method, args);
            }

            // 核心：通过缓存获取 MapperMethodInvoker
            // 每个 MapperMethod 对应一个 SQL 操作
            return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
        } catch (Throwable t) {
            throw ExceptionUtil.unwrapThrowable(t);
        }
    }
}

flowchart LR
    subgraph 应用层
        M[UserMapper 接口] -->|getMapper 返回代理对象| MP[MapperProxy]
    end

    subgraph MyBatis 内部
        MP -->|invoke 调起| MM[MapperMethod]
        MM -->|execute| SS[SqlSession]
        SS -->|selectOne / selectList| EX[Executor]
    end

    subgraph JDBC 层
        EX --> ST[StatementHandler]
        ST -->|PreparedStatement| DB[(Database)]
        DB --> RS[ResultSet]
        RS -->|handleResultSets| MM
        MM -->|返回结果| MP
        MP -->|返回| M
    end

public class XMLStatementBuilder extends BaseBuilder {

    // 解析  节点
    public void parseStatementNode() {
        // 提取 SQL 节点的各个属性
        String id = context.getStringAttribute("id");
        String databaseId = context.getStringAttribute("databaseId");
        String parameterType = context.getStringAttribute("parameterType");
        String resultType = context.getStringAttribute("resultType");
        String resultMap = context.getStringAttribute("resultMap");
        String flushCache = context.getStringAttribute("flushCache");
        String useCache = context.getStringAttribute("useCache");

        // SQL 语句解析（核心）
        // 使用 XNodeParser 将包含 ${}、#{}、、 的 SQL 文本
        // 解析为 SqlSource 对象
        SqlSource sqlSource = langDriver.createSqlSource(configuration, 
            context, parameterTypeClass);

        // 构建 MappedStatement（一个 MappedStatement 对应一个 Mapper 方法）
        MappedStatement.Builder statementBuilder = new MappedStatement.Builder(
            configuration, id, sqlSource, sqlCommandType);
        // ... 设置各种属性
    }
}

// 动态 SQL 的处理节点
public class IfSqlNode implements SqlNode {
    private final ExpressionEvaluator evaluator;
    private final String test;       // OGNL 表达式
    private final SqlNode contents;  // 子节点

    public IfSqlNode(SqlNode contents, String test) {
        this.test = test;
        this.contents = contents;
        this.evaluator = new ExpressionEvaluator();
    }

    @Override
    public boolean apply(DynamicContext context) {
        // 评估 OGNL 表达式
        if (evaluator.evaluateBoolean(test, context.getBindings())) {
            contents.apply(context);  // 条件满足 → 拼接 SQL
            return true;
        }
        return false;
    }
}

//  标签的实现
public class WhereSqlNode implements SqlNode {
    // 自动处理 WHERE 关键字和 AND/OR 前缀
    // 如果子节点以 AND 或 OR 开头，自动移除

    @Override
    public boolean apply(DynamicContext context) {
        // 1. 让子节点拼接 SQL
        contents.apply(context);
        // 2. 检查拼接结果：开头不能是 AND 或 OR
        // 3. 如果没有子节点有内容，就不加 WHERE
        // 4. 否则在前面加上 WHERE
    }
}

 id="findByCondition" resultType="User">
    SELECT * FROM user
    
         test="name != null">
            AND name = #{name}
        
         test="email != null">
            AND email = #{email}
        
    

// 参数绑定的核心——将用户传入的参数设置到 PreparedStatement
public class DefaultParameterHandler implements ParameterHandler {

    private final TypeHandlerRegistry typeHandlerRegistry;
    private final MappedStatement mappedStatement;
    private final Object parameterObject;
    private final BoundSql boundSql;

    @Override
    public void setParameters(PreparedStatement ps) {
        // 遍历 SQL 中的参数占位符
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();

        if (parameterMappings != null) {
            for (int i = 0; i < parameterMappings.size(); i++) {
                ParameterMapping parameterMapping = parameterMappings.get(i);

                // 获取参数值
                Object value;
                if (parameterMapping.getMode() == ParameterMode.OUT) {
                    // 存储过程输出参数
                    value = null;
                } else {
                    // 普通参数：通过 MetaObject 获取值
                    MetaObject metaObject = configuration.newMetaObject(parameterObject);
                    value = metaObject.getValue(parameterMapping.getProperty());
                }

                // 获取类型处理器
                TypeHandler typeHandler = parameterMapping.getTypeHandler();
                JdbcType jdbcType = parameterMapping.getJdbcType();

                // 设置参数到 PreparedStatement
                typeHandler.setParameter(ps, i + 1, value, jdbcType);
            }
        }
    }
}

// TypeHandler 接口——各种类型转换的抽象
public interface TypeHandler<T> {
    // Java → JDBC（写入数据库时）
    void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) 
        throws SQLException;

    // JDBC → Java（从数据库读取时，通过列名）
    T getResult(ResultSet rs, String columnName) throws SQLException;

    // JDBC → Java（通过列索引）
    T getResult(ResultSet rs, int columnIndex) throws SQLException;
}

// 例如：StringTypeHandler
public class StringTypeHandler extends BaseTypeHandler<String> {
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, String parameter, 
                                     JdbcType jdbcType) throws SQLException {
        ps.setString(i, parameter);
    }

    @Override
    public String getNullableResult(ResultSet rs, String columnName) throws SQLException {
        return rs.getString(columnName);
    }
}

// 自定义枚举 TypeHandler
public class GenderTypeHandler extends BaseTypeHandler<Gender> {
    // 将 Gender 枚举转为数据库的 VARCHAR
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, Gender parameter, 
                                     JdbcType jdbcType) throws SQLException {
        ps.setString(i, parameter.getCode());
    }

    @Override
    public Gender getNullableResult(ResultSet rs, String columnName) throws SQLException {
        return Gender.fromCode(rs.getString(columnName));
    }
}

flowchart TD
    subgraph Executor 层级
        BASE[BaseExecutor\n抽象基类]
        SIMPLE[SimpleExecutor\n每次执行创建 Statement]
        REUSE[ReuseExecutor\n缓存 Statement 复用]
        BATCH[BatchExecutor\n批量执行]
        CACHE[CachingExecutor\n二级缓存装饰器]
    end

    BASE --> SIMPLE
    BASE --> REUSE
    BASE --> BATCH
    CACHE -->|装饰| BASE

    style CACHE fill:#27ae60,color:#fff

public abstract class BaseExecutor implements Executor {

    // 一级缓存：PerpetualCache（HashMap）
    protected PerpetualCache localCache;

    // 查询逻辑
    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, 
                              RowBounds rowBounds, ResultHandler resultHandler,
                              CacheKey key, BoundSql boundSql) throws SQLException {
        if (closed) {
            throw new ExecutorException("Executor was closed.");
        }

        // 清空一级缓存的时机：flushCache=true 或执行了 update 操作
        if (queryStack == 0 && ms.isFlushCacheRequired()) {
            clearLocalCache();
        }

        List<E> list;
        try {
            queryStack++;

            // 从一级缓存中查找
            list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;

            if (list != null) {
                // 缓存命中
                handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
            } else {
                // 缓存未命中 → 从数据库查询
                list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
            }
        } finally {
            queryStack--;
        }

        if (queryStack == 0) {
            // 延迟加载的处理
            for (DeferredLoad deferredLoad : deferredLoads) {
                deferredLoad.load();
            }
            deferredLoads.clear();

            if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
                // STATEMENT 级别：查询完成后立即清除缓存
                clearLocalCache();
            }
        }

        return list;
    }

    // 一级缓存的生命周期：
    // 1. 同一个 SqlSession 中，同一个 SQL + 参数，第二次查询直接返回缓存
    // 2. 执行 UPDATE/INSERT/DELETE 后，清除缓存
    // 3. SqlSession close 或 commit 后，清除缓存
    // 4. 跨 SqlSession 不共享（一级缓存是 SqlSession 级别的）
}

// CachingExecutor 通过装饰器模式为 Executor 添加二级缓存
public class CachingExecutor implements Executor {

    private final Executor delegate;  // 被装饰的 Executor
    private final TransactionalCacheManager tcm = new TransactionalCacheManager();

    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, 
                              RowBounds rowBounds, ResultHandler resultHandler,
                              CacheKey key, BoundSql boundSql) throws SQLException {

        // 获取 MappedStatement 关联的二级缓存
        Cache cache = ms.getCache();

        if (cache != null) {
            // 先尝试从二级缓存获取
            List<E> list = tcm.getObject(cache, key);

            if (list == null) {
                // 二级缓存未命中 → 委派给底层 Executor 查询
                list = delegate.query(ms, parameter, rowBounds, resultHandler, key, boundSql);

                // 查询结果放入二级缓存
                tcm.putObject(cache, key, list);
            }

            return list;
        }

        // 没有二级缓存 → 直接查询
        return delegate.query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }
}

public class DefaultResultSetHandler implements ResultSetHandler {

    @Override
    public List<Object> handleResultSets(Statement stmt) throws SQLException {
        List<Object> multipleResults = new ArrayList<>();

        int resultSetCount = 0;
        ResultSetWrapper rsw = new ResultSetWrapper(stmt.getResultSet(), configuration);

        // 处理多结果集（存储过程等场景）
        List<ResultMap> resultMaps = mappedStatement.getResultMaps();
        while (rsw != null && resultMapCount > resultSetCount) {
            ResultMap resultMap = resultMaps.get(resultSetCount);

            // 核心：将 ResultSet 当前行映射为 Java 对象
            handleResultSet(rsw, resultMap, multipleResults, null);

            rsw = getNextResultSet(stmt);
            cleanUpAfterHandlingResultSet();
            resultSetCount++;
        }

        // 处理 ResultSet 结果
        return collapseSingleResultList(multipleResults);
    }

    // 单行映射
    private Object handleRowValueForResultMap(ResultSetWrapper rsw, 
                                               ResultMap resultMap,
                                               CacheKey combinedKey,
                                               String columnPrefix,
                                               Object partialObject) throws SQLException {

        // 创建默认映射对象（通过无参构造器）
        Object resultObject = createResultObject(rsw, resultMap, constructor, columnPrefix);

        if (resultObject != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
            // 创建 MetaObject 用于设置属性
            MetaObject metaObject = configuration.newMetaObject(resultObject);

            // 遍历结果映射
            List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
            for (ResultMapping propertyMapping : propertyMappings) {
                // 处理嵌套映射（association、collection）
                if (propertyMapping.getNestedResultMapId() != null) {
                    handleRowValuesForNestedResultMap(rsw, resultMap, ...);
                } else {
                    // 普通列 → 属性映射
                    String columnName = propertyMapping.getColumn();
                    TypeHandler typeHandler = propertyMapping.getTypeHandler();
                    Object value = typeHandler.getResult(rsw.getResultSet(), columnName);
                    metaObject.setValue(propertyMapping.getProperty(), value);
                }
            }
        }

        return resultObject;
    }
}

// 插件本质上是通过 JDK 动态代理实现的拦截器

@Intercepts({
    @Signature(type = Executor.class, 
               method = "update",
               args = {MappedStatement.class, Object.class})
})
public class SqlMonitorPlugin implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        long start = System.currentTimeMillis();

        try {
            // 执行原方法
            return invocation.proceed();
        } finally {
            long duration = System.currentTimeMillis() - start;

            MappedStatement ms = (MappedStatement) invocation.getArgs()[0];
            String sqlId = ms.getId();

            if (duration > 1000) {
                log.warn("Slow SQL [{}] took {}ms", sqlId, duration);
            }
        }
    }

    @Override
    public Object plugin(Object target) {
        // 使用 Plugin.wrap 创建代理
        return Plugin.wrap(target, this);
    }
}

-- 语法
SET GLOBAL TRANSACTION ISOLATION LEVEL 级别名称;
-- 或
SET @@global.tx_isolation = '级别名称';
-- MySQL 8.0+ 新系统变量
SET @@global.transaction_isolation = '级别名称';

-- 示例
SET GLOBAL TRANSACTION ISOLATION LEVEL READ COMMITTED;
SET @@global.tx_isolation = 'READ-COMMITTED';

-- 语法
SET SESSION TRANSACTION ISOLATION LEVEL 级别名称;
-- 或
SET @@session.tx_isolation = '级别名称';

-- 示例
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;
SET @@session.tx_isolation = 'REPEATABLE-READ';

-- 语法
SET TRANSACTION ISOLATION LEVEL 级别名称;

-- 示例
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;

SELECT @@session.tx_isolation;
-- 或（MySQL 8.0 推荐）
SELECT @@session.transaction_isolation;

-- 结果示例
-- +-------------------------------+
-- | @@session.tx_isolation        |
-- +-------------------------------+
-- | REPEATABLE-READ              |
-- +-------------------------------+

SELECT @@global.tx_isolation;
-- 或
SELECT @@global.transaction_isolation;

[mysqld]
# 设置默认隔离级别
transaction-isolation = READ-COMMITTED

# 可选值：
# READ-UNCOMMITTED
# READ-COMMITTED
# REPEATABLE-READ（默认）
# SERIALIZABLE

# 重启 MySQL
systemctl restart mysqld

-- MySQL 5.x 兼容写法
SET @@session.tx_isolation = 'READ-COMMITTED';
SELECT @@session.tx_isolation;

-- MySQL 8.0 推荐写法
SET @@session.transaction_isolation = 'READ-COMMITTED';
SELECT @@session.transaction_isolation;

-- 这些在 8.0 中仍有效
SET PERSIST transaction_isolation = 'READ-COMMITTED';  -- 持久化到数据目录 + 运行时
SET PERSIST_ONLY transaction_isolation = 'READ-COMMITTED';  -- 仅持久化，下次重启生效

-- 在应用连接池初始化时设置
-- Java (JDBC):
-- jdbc:mysql://localhost:3306/db?transactionIsolation=READ_COMMITTED

-- Python (SQLAlchemy):
-- engine = create_engine('mysql://...', isolation_level="READ_COMMITTED")

-- 如果业务可以接受，推荐降级到 READ COMMITTED
-- 可以减少间隙锁带来的锁冲突
SET GLOBAL TRANSACTION ISOLATION LEVEL READ COMMITTED;

-- 排查问题时临时提升隔离级别
SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;
-- 执行怀疑有并发问题的查询
-- ... 执行完切回正常级别

-- 设置隔离级别
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;

-- 事务 A
START TRANSACTION;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
-- 未提交

-- 事务 B
-- 可以读取 A 未提交的数据！
SELECT balance FROM accounts WHERE id = 1;
-- 返回：修改后的值（比如 400）

脏读的后果：
事务 A 扣了 100 元（未提交）
事务 B 读到余额 400 元
事务 A 回滚 → 余额回到 500 元
事务 B 基于 400 元做决策 → 业务不一致！

几乎不用。唯一场景可能是"我只需要一个大概值"的监控查询。
但即便如此，也不推荐。

SET TRANSACTION ISOLATION LEVEL READ COMMITTED;

-- 事务 A
START TRANSACTION;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
-- 未提交

-- 事务 B
SELECT balance FROM accounts WHERE id = 1;
-- 返回：旧值 500（读不到未提交的修改）

-- 事务 A 提交
COMMIT;

-- 事务 B 再次查询
SELECT balance FROM accounts WHERE id = 1;
-- 返回：新值 400（可以读到已提交的修改）

SET TRANSACTION ISOLATION LEVEL READ COMMITTED;

START TRANSACTION;

SELECT balance FROM accounts WHERE id = 1;
-- 第一次：500

-- 其他事务此时提交了修改
-- UPDATE accounts SET balance = 400 WHERE id = 1; COMMIT;

SELECT balance FROM accounts WHERE id = 1;
-- 第二次：400（同个事务中值变了！）

COMMIT;

- 很多数据库的默认级别（如 Oracle、PostgreSQL）
- 适合：对一致性要求不是极端严格，但需要避免脏读
- 不适合：一个事务需要多次读取同一数据并做业务判断

SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;

START TRANSACTION;

SELECT balance FROM accounts WHERE id = 1;
-- 第一次：500

-- 即使其他事务修改并提交
-- UPDATE accounts SET balance = 400 WHERE id = 1; COMMIT;

SELECT balance FROM accounts WHERE id = 1;
-- 第二次：500（不变！）

SELECT balance FROM accounts WHERE id = 1;
-- 第三次：500（始终不变）

COMMIT;

-- 理论上的幻读
-- 事务 A
SELECT * FROM orders WHERE amount > 100;
-- 返回：10 行

-- 其他事务插入了一行 amount=200 并提交

SELECT * FROM orders WHERE amount > 100;
-- 理论上应该返回 11 行（多了 1 行 "幻影"）

-- 但 InnoDB 的 REPEATABLE READ 不会！
-- 因为 InnoDB 用间隙锁 + MVCC 解决了幻读

-- 适合场景：需要事务内多次读取数据一致
-- 比如：报表生成、数据导出无需每次都重新查

-- MySQL 的默认级别
-- 大多数应用可以放心使用

SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;

START TRANSACTION;

-- 普通的 SELECT 也会加锁
SELECT * FROM accounts WHERE id = 1;
-- 自动转为 SELECT ... LOCK IN SHARE MODE
-- 其他事务无法修改 id=1 的数据

-- 直到事务提交，锁才释放
COMMIT;

SERIALIZABLE 对所有读操作自动加 S 锁：
- 读读：不冲突
- 读写：互斥！
- 性能下降明显（并发度极低）

几乎所有场景都不推荐，除非：
- 数据一致性高于一切
- 并发极低或没有
- 需要调试/测试时

-- 查看当前隔离级别
SELECT @@transaction_isolation;
-- MySQL 8.0：REPEATABLE READ

-- 设置全局
SET GLOBAL transaction_isolation = 'READ-COMMITTED';

-- 设置当前会话
SET SESSION transaction_isolation = 'READ-COMMITTED';

-- 设置下一个事务
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;

-- 配置文件（永久）
-- [mysqld]
-- transaction-isolation = READ-COMMITTED

业务场景                   推荐隔离级别
──────────────────────────────────────
大多数 Web 应用            REPEATABLE READ（MySQL 默认）
高并发、数据一致性要求一般  READ COMMITTED
数据导出、长事务报表查询    REPEATABLE READ
银行/金融核心系统          SERIALIZABLE（或 RR+显式锁）
几乎不会用                 READ UNCOMMITTED

flowchart TD
    subgraph 传统方式
        T1["UserService"] --> T2["new UserDao()"]
        T2 --> T3["new JdbcTemplate()"]
        T3 --> T4["new DataSource()"]
        T1 -.->|"反向依赖
主动创建所有依赖"| T4
    end

    subgraph IoC方式
        I1["UserService
@Autowired"] -- "请求" --> I2["IoC容器"]
        I2 --> I3["UserDao 实例"]
        I3 --> I4["JdbcTemplate 实例"]
        I4 --> I5["DataSource 实例"]
        I2 -.->|"正转向
容器自动注入"| I1
    end

// ❌ 传统方式：对象自己创建依赖（紧耦合）
public class UserService {
    private UserDao userDao = new UserDao(); // 硬编码创建

    public User findUser(Long id) {
        return userDao.findById(id);
    }
}

// ✅ IoC 方式：容器注入依赖（松耦合）
public class UserService {
    private final UserDao userDao; // 依赖由外部注入

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

    public User findUser(Long id) {
        return userDao.findById(id);
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    // 1️⃣ 字段注入（Field Injection）— ❌ 不推荐
    @Autowired
    private OrderDao orderDao;

    // 2️⃣ 构造器注入（Constructor Injection）— ✅ 推荐
    private final PaymentService paymentService;
    private final InventoryService inventoryService;

    @Autowired
    public OrderService(PaymentService paymentService,
                        InventoryService inventoryService) {
        this.paymentService = paymentService;
        this.inventoryService = inventoryService;
    }

    // 3️⃣ Setter 注入（Setter Injection）— ⚠️ 可选注入时使用
    private DiscountService discountService;

    @Autowired
    public void setDiscountService(DiscountService discountService) {
        this.discountService = discountService;
    }
}

flowchart TD
    SUBJ["选择注入方式"] --> Q1{"字段是否需要可变?"}
    Q1 -->|"否（推荐）"| CON["构造器注入
✅ 推荐
final 不可变
保证不为null
方便测试"]
    Q1 -->|"是"| Q2{"是否存在循环依赖?"}
    Q2 -->|"是"| SET["Setter注入
可解决循环依赖
（但应重构避免）"]
    Q2 -->|"否"| CON
    SET -.->|"不推荐"| FIELD["字段注入
@Autowired on field
代码最简洁
但无法测试"]

flowchart TD
    subgraph 业务逻辑
        A["方法A"] -->|"执行"| B["方法B"]
        B --> C["方法C"]
    end

    subgraph 横切关注点-AOP
        LOG["切面: 日志记录"]
        TX["切面: 事务管理"]
        SEC["切面: 权限校验"]
    end

    LOG -.->|"@Before"| A
    TX -.->|"@Around"| B
    SEC -.->|"@Before"| B
    LOG -.->|"@AfterReturning"| C

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    // 定义切入点（可复用）
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceMethods() {}

    // 1. @Before：方法执行前
    @Before("serviceMethods()")
    public void beforeAdvice() {
        System.out.println("【前置通知】方法开始执行");
    }

    // 2. @AfterReturning：方法正常返回后（可获取返回值）
    @AfterReturning(value = "serviceMethods()", returning = "result")
    public void afterReturningAdvice(Object result) {
        System.out.println("【返回通知】返回结果: " + result);
    }

    // 3. @AfterThrowing：方法抛出异常后
    @AfterThrowing(value = "serviceMethods()", throwing = "ex")
    public void afterThrowingAdvice(Throwable ex) {
        System.out.println("【异常通知】异常: " + ex.getMessage());
    }

    // 4. @After：方法结束后（finally 语义，不管是否异常）
    @After("serviceMethods()")
    public void afterAdvice() {
        System.out.println("【后置通知】方法执行结束（finally）");
    }

    // 5. @Around：环绕通知（最强大，可控制方法执行）
    @Around("serviceMethods()")
    public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("【环绕前置】方法: " + pjp.getSignature().getName());

        Object result = pjp.proceed(); // 执行目标方法

        long elapsed = System.currentTimeMillis() - start;
        System.out.println("【环绕后置】耗时: " + elapsed + "ms");
        return result;
    }
}

flowchart TD
    subgraph Spring Framework
        CORE["Core Container
核心容器"]
        AOP["AOP + Aspects
切面编程"]
        DATA["Data Access
数据访问"]
        WEB["Web
Web 层"]
        TEST["Test
测试"]
    end

    subgraph Core Container
        BEANS["Beans
BeanFactory"]
        CORE_CORE["Core
IoC容器"]
        CONTEXT["Context
ApplicationContext"]
        SPEL["SpEL
表达式语言"]
    end

    subgraph Data Access
        JDBC["JDBC
JdbcTemplate"]
        ORM["ORM
JPA/MyBatis"]
        TX["Transactions
事务管理"]
    end

    subgraph Web
        WS["Web MVC
Spring MVC"]
        WSOCKET["WebSocket"]
    end

    CORE --> AOP
    CORE --> DATA
    CORE --> WEB
    CORE --> TEST

flowchart LR
    subgraph 传统方式：正向控制
        A["UserService"] -->|"主动创建"| B["UserDao"]
        B -->|"主动创建"| C["DataSource"]
        A -.->|"高耦合
修改需改代码"| C
    end

    subgraph IoC方式：控制反转
        D["UserService"] -->|"申请依赖"| E["IoC容器"]
        E -->|"管理并注入"| F["UserDao
（由容器创建）"]
        E -->|"管理并注入"| G["DataSource
（由容器创建）"]
        E -.->|"松耦合
配置化"| D
    end

// ❌ 传统方式 — 主动创建依赖
public class OrderService {
    private OrderDao orderDao = new OrderDao();      // 硬编码
    private PaymentService paymentService = new PaymentService(); // 硬编码

    public void createOrder(Order order) {
        orderDao.save(order);
        paymentService.pay(order.getAmount());
    }
}

// ✅ IoC 方式 — 由容器注入
@Service
public class OrderService {
    private final OrderDao orderDao;
    private final PaymentService paymentService;

    // 构造器注入：依赖由 IoC 容器自动提供
    public OrderService(OrderDao orderDao, PaymentService paymentService) {
        this.orderDao = orderDao;
        this.paymentService = paymentService;
    }

    public void createOrder(Order order) {
        orderDao.save(order);
        paymentService.pay(order.getAmount());
    }
}

flowchart TD
    subgraph IoC容器体系
        BF["BeanFactory
顶级接口
延迟加载"]
        AC["ApplicationContext
BeanFactory的子接口
预加载"]
    end

    BF -->|"功能: 
getBean()
isSingleton()"| CORE["核心IoC功能"]
    AC -->|"额外功能: 
国际化(MessageSource)
事件发布
AOP集成
资源访问"| EXT["高级容器功能"]

    subgraph 常用实现
        XML["ClassPathXmlApplicationContext
XML配置"]
        ANNOT["AnnotationConfigApplicationContext
注解配置"]
        WEB["WebApplicationContext
Web应用"]
    end

    XML --> AC
    ANNOT --> AC
    WEB --> AC

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class PaymentService {

    // 1️⃣ 字段注入（Field Injection）— 不推荐
    @Autowired
    private PaymentGateway paymentGateway;

    // 2️⃣ 构造器注入（Constructor Injection）— ✅ 推荐
    private final TransactionRepository transactionRepository;
    private final PolicyService policyService;

    public PaymentService(TransactionRepository transactionRepository,
                          PolicyService policyService) {
        this.transactionRepository = transactionRepository;
        this.policyService = policyService;
    }

    // 3️⃣ Setter 注入（Setter Injection）— 可选注入
    private NotificationService notificationService;

    @Autowired
    public void setNotificationService(NotificationService notificationService) {
        this.notificationService = notificationService;
    }
}

sequenceDiagram
    participant APP as 应用程序
    participant CTX as IoC容器<br>ApplicationContext
    participant REG as BeanDefinitionRegistry
    participant FACT as BeanFactory
    participant BEAN as Bean实例

    APP->>CTX: 初始化容器<br>new AnnotationConfigApplicationContext(...)
    CTX->>CTX: 扫描包/解析配置类/XML
    CTX->>REG: 注册 BeanDefinition
    REG->>FACT: 开始创建 Bean

    Note over FACT: 单例 Bean 预实例化

    FACT->>BEAN: 实例化（反射创建对象）
    BEAN->>BEAN: 依赖注入（populateBean）
    BEAN->>BEAN: 初始化（InitializingBean/init-method）
    BEAN-->>CTX: Bean 就绪

    CTX-->>APP: 容器初始化完成
    APP->>CTX: getBean("userService")
    CTX-->>APP: 返回 UserService Bean