#Spring 核心原理

// 最简 IoC 容器实现
public class SimpleContainer {
    private Map<String, Object> beans = new HashMap<>();

    public void register(String name, Object bean) {
        beans.put(name, bean);
    }

    public Object getBean(String name) {
        return beans.get(name);
    }
}

// BeanDefinition 描述 Bean 的元信息
public class BeanDefinition {
    private Class<?> beanClass;
    private String scope;
    private boolean lazyInit;
    private PropertyValues propertyValues;  // 依赖注入的值
}

// 容器核心接口
public interface BeanFactory {
    Object getBean(String name);
    boolean containsBean(String name);
}

// 扩展点：BeanPostProcessor
public interface BeanPostProcessor {
    Object postProcessBeforeInitialization(Object bean, String beanName);
    Object postProcessAfterInitialization(Object bean, String beanName);
}

// Spring 三级缓存解决循环依赖
public class DefaultSingletonBeanRegistry {
    // 一级缓存：成品 Bean
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
    // 二级缓存：提前暴露的 Bean（未完成属性注入）
    private final Map<String, Object> earlySingletonObjects = new HashMap<>();
    // 三级缓存：Bean 工厂
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();

    public Object getSingleton(String beanName) {
        // 1. 先从一级缓存拿
        Object singleton = singletonObjects.get(beanName);
        if (singleton == null && isSingletonCurrentlyInCreation(beanName)) {
            // 2. 从二级缓存拿（早期暴露）
            singleton = earlySingletonObjects.get(beanName);
            if (singleton == null) {
                // 3. 从三级缓存拿工厂创建
                ObjectFactory<?> factory = singletonFactories.get(beanName);
                if (factory != null) {
                    singleton = factory.getObject();
                    earlySingletonObjects.put(beanName, singleton);
                    singletonFactories.remove(beanName);
                }
            }
        }
        return singleton;
    }
}

// JDK 动态代理：要求目标类实现接口
public class JdkDynamicProxy implements InvocationHandler {
    private Object target;

    public JdkDynamicProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法执行前...");
        Object result = method.invoke(target, args);
        System.out.println("方法执行后...");
        return result;
    }
}

// CGLIB 动态代理：基于继承，不需要接口
public class CglibDynamicProxy implements MethodInterceptor {
    private Object target;

    public Object createProxy(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("方法执行前...");
        Object result = methodProxy.invokeSuper(proxy, args);
        System.out.println("方法执行后...");
        return result;
    }
}

// JdkDynamicAopProxy 和 CglibAopProxy 的选择逻辑
public class DefaultAopProxyFactory {
    public AopProxy createAopProxy(AdvisedSupport config) {
        // 如果目标是接口，或者配置了优化项，使用 JDK 代理
        if (config.getTargetSource().getTargetClass().length > 0 &&
            !config.getProxyTargetClass()) {
            return new JdkDynamicAopProxy(config);
        }
        // 否则使用 CGLIB
        return new CglibAopProxy(config);
    }
}

// Spring Boot 的默认行为
// Spring Boot 2.0 开始，默认 proxyTargetClass = true，即默认使用 CGLIB

// 正确的事务配置示例
@Service
public class TransferService {
    @Autowired
    private AccountMapper accountMapper;

    @Transactional(rollbackFor = Exception.class)  // 指定所有异常都回滚
    public void transfer(String from, String to, BigDecimal amount) {
        accountMapper.decreaseBalance(from, amount);
        // 模拟异常
        if (amount.compareTo(BigDecimal.ZERO) > 10000) {
            throw new BusinessException("单笔转账超过限额");
        }
        accountMapper.increaseBalance(to, amount);
    }
}

// REQUIRED：加入当前事务，没有则创建新事务
@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    methodB();  // 会加入到 methodA 的事务中
}

// REQUIRES_NEW：每次都创建新事务，挂起当前事务
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void methodB() {
    // 独立事务，不受 methodA 影响
}

// 错误顺序：先解锁再提交，可能导致数据不一致
@Transactional
public void createOrder() {
    // 锁定库存
    lockStock(productId);
    // 扣减库存
    reduceStock(productId);
    // 创建订单
    createOrderRecord();
    // 这里如果异常，锁已经释放，但事务未提交
}

// 正确顺序：先操作再锁定，确保原子性
@Transactional
public void createOrder() {
    // 扣减库存（带乐观锁）
    reduceStockWithVersion(productId);
    // 创建订单
    createOrderRecord();
    // 事务提交时自动释放锁
}