/**
 * 订单服务 - 一个典型的 "坏代码" 示例
 * 问题：所有依赖都通过 new 直接创建
 */
public class OrderService {

    // 直接 new 出所有依赖对象
    private InventoryService inventoryService = new InventoryService();
    private PriceCalculator priceCalculator = new PriceCalculator();
    private OrderRepository orderRepository = new OrderRepository();
    private NotificationService notificationService = new EmailNotificationService();

    public Order createOrder(OrderRequest request) {
        // 1. 校验库存
        if (!inventoryService.checkStock(request.getProductId())) {
            throw new BusinessException("库存不足");
        }

        // 2. 计算价格
        BigDecimal totalPrice = priceCalculator.calculate(request);

        // 3. 创建并保存订单
        Order order = new Order(request, totalPrice);
        orderRepository.save(order);

        // 4. 发送通知
        notificationService.sendOrderConfirmation(order);

        return order;
    }
}

// 我们期望的测试方式
@Test
void shouldCreateOrderSuccessfully() {
    // 我想用一个假的 Repository，让它直接返回成功
    // 但 OrderService 内部已经写死了 new OrderRepository()
    // 我根本无法替换它！
}

// 修改前
private NotificationService notificationService = new EmailNotificationService();

// 修改后 - 但这要求修改 OrderService 的源代码！
private NotificationService notificationService = new SmsNotificationService();

// InventoryService 的构造变复杂了
public class InventoryService {
    public InventoryService(DataSource dataSource, RedisClient redis, InventoryConfig config) {
        // ...
    }
}

private InventoryService inventoryService = new InventoryService(
    new HikariDataSource(hikariConfig),  // 还要先创建 hikariConfig
    new RedisClient(redisConfig),         // 还要先创建 redisConfig
    new InventoryConfig()
);

public class OrderService {
    // OrderService 主动创建自己需要的依赖
    private OrderRepository repository = new OrderRepository();

    // "我需要什么，我自己去拿"
}

public class OrderService {
    // OrderService 只声明自己需要什么，不关心怎么来的
    private OrderRepository repository;

    // 依赖从外部 "注入" 进来
    public OrderService(OrderRepository repository) {
        this.repository = repository;
    }

    // "我需要什么，你给我送来"
}

public class ServiceFactory {
    public static OrderRepository createOrderRepository() {
        return new OrderRepository(dataSource);
    }
}

// 使用方式
public class OrderService {
    private OrderRepository repository = ServiceFactory.createOrderRepository();
}

public class ServiceLocator {
    private static Map<Class<?>, Object> services = new HashMap<>();

    public static <T> T getService(Class<T> type) {
        return (T) services.get(type);
    }
}

// 使用方式
public class OrderService {
    private OrderRepository repository = ServiceLocator.getService(OrderRepository.class);
}

public class OrderService {
    private final OrderRepository repository;

    // 依赖通过构造函数 "注入" 进来
    public OrderService(OrderRepository repository) {
        this.repository = repository;
    }
}

// 这是一个普通的 Java 对象
User user = new User();

// 这是一个 Bean（由容器创建和管理）
User user = applicationContext.getBean(User.class);

// ❌ 传统方式：自己去 "拿" 依赖
public class OrderService {
    private OrderRepository repository;

    public OrderService() {
        // 我要自己去创建依赖
        this.repository = new OrderRepository();
    }
}

// ✅ 依赖注入：等着 "送货上门"
public class OrderService {
    private OrderRepository repository;

    // 容器会把 OrderRepository 送过来
    public OrderService(OrderRepository repository) {
        this.repository = repository;
    }
}

public class OrderService {

    private OrderRepository orderRepository;
    private InventoryService inventoryService;

    // Spring 容器会调用这个方法注入依赖
    public void setOrderRepository(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }

    // Spring 容器会调用这个方法注入依赖
    public void setInventoryService(InventoryService inventoryService) {
        this.inventoryService = inventoryService;
    }

    public void createOrder(OrderRequest request) {
        // 使用注入的依赖
        inventoryService.checkStock(request.getProductId());
        orderRepository.save(new Order(request));
    }
}

@Service
public class OrderService {

    private OrderRepository orderRepository;
    private InventoryService inventoryService;

    @Autowired
    public void setOrderRepository(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }

    @Autowired
    public void setInventoryService(InventoryService inventoryService) {
        this.inventoryService = inventoryService;
    }
}

@Service
public class NotificationService {

    // 必需依赖：使用构造器注入
    private final MessageSender primarySender;

    // 可选依赖：使用 Setter 注入
    private MessageSender backupSender;

    public NotificationService(MessageSender primarySender) {
        this.primarySender = primarySender;
    }

    // 备用发送器是可选的，可能不配置
    @Autowired(required = false)
    public void setBackupSender(MessageSender backupSender) {
        this.backupSender = backupSender;
    }

    public void send(String message) {
        try {
            primarySender.send(message);
        } catch (Exception e) {
            if (backupSender != null) {
                backupSender.send(message);
            }
        }
    }
}

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    @Autowired
    private InventoryService inventoryService;

    @Autowired
    private NotificationService notificationService;

    public void createOrder(OrderRequest request) {
        // 直接使用，看起来很简洁
        inventoryService.checkStock(request.getProductId());
        Order order = new Order(request);
        orderRepository.save(order);
        notificationService.sendConfirmation(order);
    }
}

@Service
public class OrderService {

    // ❌ 编译错误！final 字段必须在构造器中初始化
    @Autowired
    private final OrderRepository orderRepository;
}

// 从类的公开接口（构造器、方法签名）完全看不出它依赖什么
@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    @Autowired
    private InventoryService inventoryService;

    @Autowired
    private PriceCalculator priceCalculator;

    @Autowired
    private NotificationService notificationService;

    @Autowired
    private AuditService auditService;

    // 这个类到底依赖多少东西？必须看源码才知道
}

// 如何在不启动 Spring 容器的情况下测试 OrderService？
@Test
void testCreateOrder() {
    // ❌ 问题：OrderService 没有公开的方式让我们传入 Mock 对象
    OrderService service = new OrderService();  // 所有 @Autowired 字段都是 null！

    // 必须使用反射或者 Spring 测试框架
    // 这增加了测试的复杂度和运行时间
}

@Test
void testCreateOrder() {
    // ✅ 简单直接：直接传入 Mock 对象
    OrderRepository mockRepo = mock(OrderRepository.class);
    InventoryService mockInventory = mock(InventoryService.class);

    OrderService service = new OrderService(mockRepo, mockInventory);

    // 测试逻辑...
}

// 加一个依赖太容易了，不知不觉就变成了这样
@Service
public class OrderService {

    @Autowired private OrderRepository orderRepository;
    @Autowired private InventoryService inventoryService;
    @Autowired private PriceCalculator priceCalculator;
    @Autowired private DiscountService discountService;
    @Autowired private TaxCalculator taxCalculator;
    @Autowired private NotificationService notificationService;
    @Autowired private AuditService auditService;
    @Autowired private MetricsService metricsService;
    @Autowired private CacheService cacheService;
    @Autowired private EventPublisher eventPublisher;
    // 10 个依赖！这个类是不是管太多了？
    // 但因为每个依赖只是一行代码，问题被掩盖了
}

@Service
public class OrderService {

    private final OrderRepository orderRepository;
    private final InventoryService inventoryService;

    // Spring 4.3+：只有一个构造器时，@Autowired 可以省略
    public OrderService(OrderRepository orderRepository,
                        InventoryService inventoryService) {
        this.orderRepository = orderRepository;
        this.inventoryService = inventoryService;
    }
}

@Service
@RequiredArgsConstructor  // Lombok 自动生成包含所有 final 字段的构造器
public class OrderService {

    private final OrderRepository orderRepository;
    private final InventoryService inventoryService;
    private final NotificationService notificationService;

    // 不需要手写构造器，Lombok 会自动生成：
    // public OrderService(OrderRepository orderRepository,
    //                     InventoryService inventoryService,
    //                     NotificationService notificationService) {
    //     this.orderRepository = orderRepository;
    //     this.inventoryService = inventoryService;
    //     this.notificationService = notificationService;
    // }

    public void createOrder(OrderRequest request) {
        // 业务逻辑
    }
}

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;
    // Spring 查找：容器中有没有类型为 OrderRepository 的 Bean？
}

// 假设容器中有两个 MessageSender 类型的 Bean
@Component("emailSender")
public class EmailSender implements MessageSender { }

@Component("smsSender")
public class SmsSender implements MessageSender { }

@Service
public class NotificationService {

    @Autowired
    private MessageSender messageSender;
    // 问题：容器中有两个 MessageSender，注入哪个？
}

@Service
public class NotificationService {

    @Autowired
    private MessageSender emailSender;  // 字段名是 emailSender
    // Spring 会尝试匹配名为 "emailSender" 的 Bean ✅

    @Autowired
    private MessageSender smsSender;    // 字段名是 smsSender
    // Spring 会尝试匹配名为 "smsSender" 的 Bean ✅
}

@Service
public class NotificationService {

    @Autowired
    @Qualifier("emailSender")  // 明确指定要注入的 Bean 名称
    private MessageSender primarySender;

    @Autowired
    @Qualifier("smsSender")
    private MessageSender backupSender;
}

@Component
@Primary  // 标记为首选 Bean
public class EmailSender implements MessageSender { }

@Component
public class SmsSender implements MessageSender { }

@Service
public class NotificationService {

    @Autowired
    private MessageSender messageSender;
    // 没有 @Qualifier 时，会注入 @Primary 标记的 EmailSender
}

@Service
public class NotificationService {

    private final MessageSender primarySender;
    private final MessageSender backupSender;

    public NotificationService(
            @Qualifier("emailSender") MessageSender primarySender,
            @Qualifier("smsSender") MessageSender backupSender) {
        this.primarySender = primarySender;
        this.backupSender = backupSender;
    }
}

public class Application {

    public static void main(String[] args) {
        // 1. 创建基础设施
        DataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/shop");
        dataSource.setUsername("root");
        dataSource.setPassword("password");

        MailConfig mailConfig = new MailConfig();
        mailConfig.setHost("smtp.example.com");
        mailConfig.setPort(587);

        SmsConfig smsConfig = new SmsConfig();
        smsConfig.setApiKey("xxx-xxx-xxx");

        // 2. 创建 Repository 层
        OrderRepository orderRepository = new OrderRepository(dataSource);
        InventoryRepository inventoryRepository = new InventoryRepository(dataSource);
        DiscountRepository discountRepository = new DiscountRepository(dataSource);

        // 3. 创建 Service 层
        DiscountService discountService = new DiscountService(discountRepository);
        PriceCalculator priceCalculator = new PriceCalculator(discountService);
        InventoryService inventoryService = new InventoryService(inventoryRepository);

        EmailSender emailSender = new EmailSender(mailConfig);
        SmsSender smsSender = new SmsSender(smsConfig);
        NotificationService notificationService = new NotificationService(emailSender, smsSender);

        OrderService orderService = new OrderService(
            orderRepository, inventoryService, priceCalculator, notificationService);

        // 4. 创建 Controller 层
        OrderController orderController = new OrderController(orderService);

        // 5. 启动应用...
        // 6. 应用关闭时，还要记得关闭 DataSource...
    }
}

// 有了 Spring 容器，启动代码变成这样
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        // 一行代码，容器自动完成：
        // 1. 扫描所有组件
        // 2. 分析依赖关系
        // 3. 按正确顺序创建对象
        // 4. 自动装配依赖
        // 5. 管理生命周期
        SpringApplication.run(Application.class, args);
    }
}

public interface BeanFactory {

    // ==== ==== ==== ==== ==== 获取 Bean 的方法 ==== ==== ==== ==== ====

    // 根据名称获取 Bean（返回 Object，需要强转）
    Object getBean(String name) throws BeansException;

    // 根据名称和类型获取 Bean（类型安全）
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;

    // 根据类型获取 Bean（最常用）
    <T> T getBean(Class<T> requiredType) throws BeansException;

    // 根据名称获取 Bean，并传入构造参数（用于 prototype 作用域）
    Object getBean(String name, Object... args) throws BeansException;


    // ==== ==== ==== ==== ==== 查询 Bean 的方法 ==== ==== ==== ==== ====

    // 判断容器中是否包含指定名称的 Bean
    boolean containsBean(String name);

    // 判断指定 Bean 是否为单例
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

    // 判断指定 Bean 是否为原型（每次获取都创建新实例）
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

    // 获取指定 Bean 的类型
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;

    // 获取指定 Bean 的所有别名
    String[] getAliases(String name);
}

// 早期 Spring 使用 BeanFactory 的方式（现已很少使用）
public class BeanFactoryExample {

    public static void main(String[] args) {
        // 1. 创建 BeanFactory 实例
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

        // 2. 创建 Bean 定义读取器
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);

        // 3. 加载 Bean 定义
        reader.loadBeanDefinitions(new ClassPathResource("beans.xml"));

        // 4. 获取 Bean（此时才真正创建 Bean 实例）
        OrderService orderService = beanFactory.getBean(OrderService.class);

        // 注意：BeanPostProcessor 需要手动注册
        // beanFactory.addBeanPostProcessor(new MyBeanPostProcessor());
    }
}

public interface ApplicationContext extends
        EnvironmentCapable,        // 环境配置能力（profiles、properties）
        ListableBeanFactory,       // 批量获取 Bean 的能力
        HierarchicalBeanFactory,   // 父子容器层级能力
        MessageSource,             // 国际化消息能力
        ApplicationEventPublisher, // 事件发布能力
        ResourcePatternResolver {  // 资源模式解析能力

    // 获取容器的唯一标识
    String getId();

    // 获取应用名称
    String getApplicationName();

    // 获取容器的友好显示名称
    String getDisplayName();

    // 获取容器启动的时间戳
    long getStartupDate();

    // 获取父容器（支持容器层级）
    ApplicationContext getParent();

    // 获取内部的 AutowireCapableBeanFactory（高级用法）
    AutowireCapableBeanFactory getAutowireCapableBeanFactory()
            throws IllegalStateException;
}

// BeanFactory：懒加载
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
// ... 加载 Bean 定义 ...
// 此时 Bean 还没有被创建！

OrderService service = beanFactory.getBean(OrderService.class);
// 调用 getBean 时才创建 OrderService 及其依赖


// ApplicationContext：预加载
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
// 容器启动完成时，所有单例 Bean 已经创建完毕！

OrderService service = context.getBean(OrderService.class);
// 直接从缓存中获取，不需要再创建

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {
        // SpringApplication.run() 内部会：
        // 1. 检测应用类型（Servlet Web / Reactive Web / 非 Web）
        // 2. 创建对应的 ApplicationContext 实现
        // 3. 加载配置、创建 Bean、启动应用
        ApplicationContext context = SpringApplication.run(MyApplication.class, args);

        // 返回的 context 类型取决于应用类型：
        // - Web 应用：AnnotationConfigServletWebServerApplicationContext
        // - WebFlux 应用：AnnotationConfigReactiveWebServerApplicationContext
        // - 非 Web 应用：AnnotationConfigApplicationContext
    }
}

// 假设 UserService 定义在父容器中
// UserController 定义在子容器中

// 从子容器获取 UserService —— 会向上查找父容器
UserService service = childContext.getBean(UserService.class);  // ✅ 成功

// 从父容器获取 UserController —— 无法向下查找子容器
UserController controller = parentContext.getBean(UserController.class);  // ❌ 失败

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {
        // Spring Boot 只创建一个容器
        // 所有 Bean（Controller、Service、Repository）都在同一个容器中
        ApplicationContext context = SpringApplication.run(MyApplication.class, args);
    }
}