Spring第一性原理：为什么我们需要框架？

/**
 * 订单服务 - 纯Java实现
 * 问题：硬编码依赖、事务手动管理、横切关注点混杂
 */
public class OrderService {

    // 依赖对象（硬编码new）
    private UserService userService;
    private ProductService productService;
    private InventoryService inventoryService;
    private PaymentService paymentService;
    private NotificationService notificationService;

    // 数据库连接（硬编码配置）
    private static final String DB_URL = "jdbc:mysql://localhost:3306/mydb";
    private static final String DB_USER = "root";
    private static final String DB_PASSWORD = "123456";

    /**
     * 构造函数：手动创建所有依赖
     * 问题1：依赖层级深，任何一个依赖变化都需要修改这里
     */
    public OrderService() {
        // 每个依赖都要手动new，且需要传入它们的依赖
        this.userService = new UserService(
            new UserRepository(getDataSource())
        );

        this.productService = new ProductService(
            new ProductRepository(getDataSource())
        );

        this.inventoryService = new InventoryService(
            new InventoryRepository(getDataSource()),
            new RedisClient("localhost", 6379)
        );

        // 支付服务硬编码为支付宝（无法切换）
        this.paymentService = new AlipayPaymentService(
            new AlipayConfig("app_id_xxx", "private_key_xxx")
        );

        this.notificationService = new EmailNotificationService(
            new EmailConfig("smtp.qq.com", 587, "user@qq.com", "password")
        );
    }

    /**
     * 创建订单
     * 问题2：横切关注点混杂（事务、日志、权限散落在业务代码中）
     */
    public Order createOrder(OrderRequest request) {
        // ========== 横切关注点1：日志记录 ==========
        System.out.println("========================================");
        System.out.println("开始创建订单: " + request);
        System.out.println("时间: " + new Date());
        long startTime = System.currentTimeMillis();

        Connection conn = null;

        try {
            // ========== 横切关注点2：权限校验 ==========
            User user = userService.getUser(request.getUserId());
            if (user == null) {
                throw new BusinessException("用户不存在");
            }
            if (!user.hasPermission("CREATE_ORDER")) {
                System.err.println("权限拒绝: 用户 " + user.getId() + " 无CREATE_ORDER权限");
                throw new PermissionException("无权限创建订单");
            }

            // ========== 横切关注点3：参数校验 ==========
            if (request.getProductId() == null) {
                throw new ValidationException("商品ID不能为空");
            }
            if (request.getQuantity() == null || request.getQuantity() <= 0) {
                throw new ValidationException("购买数量必须大于0");
            }

            // ========== 横切关注点4：手动事务管理 ==========
            conn = getConnection();
            conn.setAutoCommit(false);  // 关闭自动提交

            try {
                // ========== 核心业务逻辑开始（只占20%代码） ==========

                // 1. 查询商品
                Product product = productService.getProduct(request.getProductId());
                if (product == null) {
                    throw new BusinessException("商品不存在");
                }
                if (product.getStatus() != 1) {
                    throw new BusinessException("商品已下架");
                }

                // 2. 扣减库存
                boolean deductSuccess = inventoryService.deduct(
                    product.getId(),
                    request.getQuantity(),
                    conn  // 传递同一个连接，保证事务一致性
                );
                if (!deductSuccess) {
                    throw new BusinessException("库存不足");
                }

                // 3. 创建订单
                Order order = new Order();
                order.setOrderNo(generateOrderNo());
                order.setUserId(user.getId());
                order.setProductId(product.getId());
                order.setProductName(product.getName());
                order.setQuantity(request.getQuantity());
                order.setPrice(product.getPrice());
                order.setAmount(product.getPrice().multiply(
                    new BigDecimal(request.getQuantity())
                ));
                order.setStatus(0);  // 待支付
                order.setCreateTime(new Date());

                // 4. 保存订单到数据库
                saveOrder(order, conn);

                // 5. 调用支付服务
                boolean paymentSuccess = paymentService.pay(
                    order.getOrderNo(),
                    order.getAmount()
                );
                if (!paymentSuccess) {
                    throw new BusinessException("支付失败");
                }

                // 6. 更新订单状态
                order.setStatus(1);  // 已支付
                updateOrderStatus(order, conn);

                // ========== 核心业务逻辑结束 ==========

                // 提交事务
                conn.commit();

                // ========== 横切关注点5：发送通知（异步） ==========
                try {
                    notificationService.sendEmail(
                        user.getEmail(),
                        "订单创建成功",
                        "您的订单 " + order.getOrderNo() + " 已创建成功"
                    );
                } catch (Exception e) {
                    // 通知失败不影响主流程
                    System.err.println("发送邮件失败: " + e.getMessage());
                }

                // ========== 横切关注点6：日志记录 ==========
                long endTime = System.currentTimeMillis();
                System.out.println("订单创建成功: " + order.getOrderNo());
                System.out.println("耗时: " + (endTime - startTime) + "ms");
                System.out.println("========================================");

                return order;

            } catch (Exception e) {
                // 回滚事务
                if (conn != null) {
                    try {
                        conn.rollback();
                        System.err.println("事务回滚成功");
                    } catch (SQLException rollbackEx) {
                        System.err.println("事务回滚失败: " + rollbackEx.getMessage());
                    }
                }

                // ========== 横切关注点7：异常日志 ==========
                System.err.println("订单创建失败: " + e.getMessage());
                e.printStackTrace();

                throw new BusinessException("订单创建失败: " + e.getMessage(), e);
            }

        } catch (Exception e) {
            throw new RuntimeException("系统异常", e);
        } finally {
            // 释放连接
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    System.err.println("关闭连接失败: " + e.getMessage());
                }
            }
        }
    }

    /**
     * 获取数据库连接（硬编码配置）
     */
    private Connection getConnection() throws SQLException {
        return DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD);
    }

    /**
     * 获取数据源
     */
    private DataSource getDataSource() {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl(DB_URL);
        ds.setUsername(DB_USER);
        ds.setPassword(DB_PASSWORD);
        ds.setMaximumPoolSize(10);
        return ds;
    }

    /**
     * 生成订单号
     */
    private String generateOrderNo() {
        return "ORD" + System.currentTimeMillis() +
               (int)(Math.random() * 1000);
    }

    /**
     * 保存订单
     */
    private void saveOrder(Order order, Connection conn) throws SQLException {
        String sql = "INSERT INTO orders (order_no, user_id, product_id, " +
                    "product_name, quantity, price, amount, status, create_time) " +
                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)";

        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setString(1, order.getOrderNo());
            pstmt.setLong(2, order.getUserId());
            pstmt.setLong(3, order.getProductId());
            pstmt.setString(4, order.getProductName());
            pstmt.setInt(5, order.getQuantity());
            pstmt.setBigDecimal(6, order.getPrice());
            pstmt.setBigDecimal(7, order.getAmount());
            pstmt.setInt(8, order.getStatus());
            pstmt.setTimestamp(9, new Timestamp(order.getCreateTime().getTime()));

            pstmt.executeUpdate();
        }
    }

    /**
     * 更新订单状态
     */
    private void updateOrderStatus(Order order, Connection conn) throws SQLException {
        String sql = "UPDATE orders SET status = ? WHERE order_no = ?";

        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, order.getStatus());
            pstmt.setString(2, order.getOrderNo());
            pstmt.executeUpdate();
        }
    }
}

/**
 * 订单服务 - Spring实现
 * 优势：依赖注入、声明式事务、AOP横切关注点分离
 */
@Service
@Slf4j
@Transactional(rollbackFor = Exception.class)
public class OrderService {

    // 依赖注入：Spring自动装配
    @Autowired
    private UserService userService;

    @Autowired
    private ProductService productService;

    @Autowired
    private InventoryService inventoryService;

    @Autowired
    private PaymentService paymentService;  // 接口，实现类由配置决定

    @Autowired
    private NotificationService notificationService;

    @Autowired
    private OrderRepository orderRepository;

    /**
     * 创建订单
     * 注解说明：
     * - @Transactional: 声明式事务，自动commit/rollback
     * - @RequirePermission: 自定义AOP，权限校验
     * - @Loggable: 自定义AOP，日志记录
     * - @Valid: JSR-303参数校验
     */
    @RequirePermission("CREATE_ORDER")
    @Loggable(value = "创建订单", level = LogLevel.INFO)
    public Order createOrder(@Valid OrderRequest request) {

        // ========== 100%纯粹的业务逻辑 ==========

        // 1. 获取用户（权限已由@RequirePermission校验）
        User user = userService.getUser(request.getUserId());

        // 2. 查询商品
        Product product = productService.getProduct(request.getProductId());
        if (product == null || product.getStatus() != 1) {
            throw new BusinessException("商品不存在或已下架");
        }

        // 3. 扣减库存
        boolean deductSuccess = inventoryService.deduct(
            product.getId(),
            request.getQuantity()
        );
        if (!deductSuccess) {
            throw new BusinessException("库存不足");
        }

        // 4. 创建订单
        Order order = Order.builder()
                .orderNo(generateOrderNo())
                .userId(user.getId())
                .productId(product.getId())
                .productName(product.getName())
                .quantity(request.getQuantity())
                .price(product.getPrice())
                .amount(product.getPrice().multiply(
                    new BigDecimal(request.getQuantity())
                ))
                .status(OrderStatus.UNPAID)
                .createTime(LocalDateTime.now())
                .build();

        // 5. 保存订单（Spring Data JPA）
        order = orderRepository.save(order);

        // 6. 调用支付服务
        boolean paymentSuccess = paymentService.pay(
            order.getOrderNo(),
            order.getAmount()
        );
        if (!paymentSuccess) {
            throw new BusinessException("支付失败");
        }

        // 7. 更新订单状态
        order.setStatus(OrderStatus.PAID);
        order = orderRepository.save(order);

        // 8. 异步发送通知
        notificationService.sendOrderNotification(user, order);

        return order;
    }

    /**
     * 生成订单号
     */
    private String generateOrderNo() {
        return "ORD" + System.currentTimeMillis() +
               ThreadLocalRandom.current().nextInt(1000);
    }
}

/**
 * 订单请求DTO - JSR-303参数校验
 */
@Data
public class OrderRequest {

    @NotNull(message = "用户ID不能为空")
    private Long userId;

    @NotNull(message = "商品ID不能为空")
    private Long productId;

    @NotNull(message = "购买数量不能为空")
    @Min(value = 1, message = "购买数量必须大于0")
    private Integer quantity;
}

/**
 * 自定义AOP：权限校验
 */
@Aspect
@Component
@Slf4j
public class PermissionAspect {

    @Autowired
    private UserService userService;

    @Before("@annotation(requirePermission)")
    public void checkPermission(JoinPoint joinPoint, RequirePermission requirePermission) {
        // 获取当前用户
        User currentUser = UserContext.getCurrentUser();

        // 校验权限
        String permission = requirePermission.value();
        if (!currentUser.hasPermission(permission)) {
            log.warn("权限拒绝: 用户 {} 无 {} 权限", currentUser.getId(), permission);
            throw new PermissionException("无权限: " + permission);
        }

        log.debug("权限校验通过: 用户 {} 具有 {} 权限", currentUser.getId(), permission);
    }
}

/**
 * 自定义AOP：日志记录
 */
@Aspect
@Component
@Slf4j
public class LoggingAspect {

    @Around("@annotation(loggable)")
    public Object logMethod(ProceedingJoinPoint pjp, Loggable loggable) throws Throwable {
        String methodName = pjp.getSignature().getName();
        Object[] args = pjp.getArgs();

        log.info("========================================");
        log.info("开始执行: {}", loggable.value());
        log.info("方法: {}", methodName);
        log.info("参数: {}", Arrays.toString(args));
        log.info("时间: {}", LocalDateTime.now());

        long startTime = System.currentTimeMillis();

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

            long endTime = System.currentTimeMillis();
            log.info("执行成功: {}", loggable.value());
            log.info("耗时: {}ms", endTime - startTime);
            log.info("========================================");

            return result;

        } catch (Throwable e) {
            log.error("执行失败: {}", loggable.value());
            log.error("异常信息: {}", e.getMessage(), e);
            log.info("========================================");
            throw e;
        }
    }
}

# application.yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: ${DB_PASSWORD}  # 环境变量，安全
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5

  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

# 支付服务配置（可切换实现）
payment:
  type: alipay  # 可切换为：wechat、unionpay
  alipay:
    app-id: xxx
    private-key: ${ALIPAY_PRIVATE_KEY}

// 问题1：手动管理对象创建
OrderService orderService = new OrderService();

// 问题2：手动管理依赖关系
UserService userService = new UserService();
orderService.setUserService(userService);

// 问题3：手动管理生命周期
// 何时创建？何时销毁？谁来管理？

// 问题4：依赖层级深
// UserService需要UserRepository
// UserRepository需要DataSource
// DataSource需要配置...
// 每增加一层依赖，复杂度指数级增长

// Spring容器管理一切
@Service
public class OrderService {
    @Autowired
    private UserService userService;  // 容器自动注入
}

// 你只需要声明依赖，容器负责：
// 1. 创建对象
// 2. 管理依赖
// 3. 管理生命周期

public class OrderService {
    private UserService userService;
    private ProductService productService;
    private InventoryService inventoryService;
    private PaymentService paymentService;
    private NotificationService notificationService;

    // 问题：如何创建这些依赖？
}

public class OrderService {
    private UserService userService = new UserService();
    private PaymentService paymentService = new AlipayPaymentService();

    // 问题清单：
    // ❌ 1. 强耦合：无法切换实现（如切换到微信支付）
    // ❌ 2. 硬编码：配置写死在代码里
    // ❌ 3. 难测试：无法注入mock对象
    // ❌ 4. 依赖层级深：UserService也有依赖，需要递归创建
}

public class OrderService {
    private PaymentService paymentService = PaymentServiceFactory.create();

    // 优点：
    // ✅ 解耦：可以通过工厂切换实现

    // 问题：
    // ❌ 1. 每个依赖都要写一个工厂
    // ❌ 2. 依赖关系散落在各处
    // ❌ 3. 生命周期难以管理
}

@Service
public class OrderService {
    @Autowired
    private PaymentService paymentService;  // 接口

    // Spring容器负责：
    // 1. 扫描所有PaymentService的实现类
    // 2. 根据配置选择合适的实现
    // 3. 自动创建实例并注入

    // 开发者只需要：
    // 1. 声明依赖
    // 2. 配置文件指定实现
}

# application-dev.yml（开发环境使用Mock）
payment:
  type: mock

# application-prod.yml（生产环境使用支付宝）
payment:
  type: alipay

// 问题1：何时创建？
class UserService {
    // 饿汉式：类加载时创建（占用内存）
    private static UserService instance = new UserService();

    // 懒汉式：首次使用时创建（线程安全问题）
    private static UserService instance;
    public static UserService getInstance() {
        if (instance == null) {  // 多线程下可能创建多个实例
            instance = new UserService();
        }
        return instance;
    }
}

// 问题2：单例 vs 多例？
// 单例：线程安全问题、状态管理问题
// 多例：每次创建新对象，性能开销

// 问题3：初始化顺序？
// A依赖B，B依赖C
// 必须先创建C，再创建B，最后创建A
// 手动管理容易出错

// 问题4：循环依赖？
// A依赖B，B依赖A
// 如何处理？

// 问题5：何时销毁？
// 资源释放（数据库连接、文件句柄）
// 忘记关闭导致内存泄漏

@Service
public class UserService {
    // Spring容器负责：
    // 1. 自动创建：容器启动时扫描@Service，创建实例
    // 2. 自动装配：根据@Autowired自动注入依赖
    // 3. 生命周期回调：@PostConstruct / @PreDestroy
    // 4. 循环依赖解决：三级缓存机制
    // 5. 自动销毁：容器关闭时销毁所有Bean

    @PostConstruct
    public void init() {
        // 初始化逻辑：Bean创建后自动调用
    }

    @PreDestroy
    public void destroy() {
        // 销毁逻辑：容器关闭前自动调用
    }
}

public class OrderService {

    public void createOrder() {
        // 日志（重复代码1）
        log.info("开始创建订单");

        try {
            // 权限（重复代码2）
            checkPermission("CREATE_ORDER");

            // 事务开始（重复代码3）
            beginTransaction();

            try {
                // ===== 核心业务逻辑（只占20%） =====
                Order order = new Order();
                saveOrder(order);
                // =====================================

                // 事务提交（重复代码4）
                commit();
            } catch (Exception e) {
                // 事务回滚（重复代码5）
                rollback();
            }

        } finally {
            // 日志（重复代码6）
            log.info("订单创建完成");
        }
    }

    // updateOrder()、cancelOrder() 也有同样的重复代码...
}

// 问题：
// 1. 代码重复：每个方法都有相同的事务、日志、权限代码
// 2. 难以维护：修改事务逻辑需要改所有方法
// 3. 业务代码混杂：核心业务逻辑被框架代码淹没

@Service
@Transactional  // 声明式事务
public class OrderService {

    @RequirePermission("CREATE_ORDER")  // 声明式权限
    @Loggable  // 声明式日志
    public void createOrder() {
        // 100%纯粹的业务逻辑
        Order order = new Order();
        orderRepository.save(order);
    }
}

// 切面代码：横切关注点抽取为切面（可复用）
@Aspect
@Component
public class LoggingAspect {

    @Around("@annotation(Loggable)")
    public Object log(ProceedingJoinPoint pjp) throws Throwable {
        log.info("方法开始: {}", pjp.getSignature());
        Object result = pjp.proceed();
        log.info("方法结束");
        return result;
    }
}

// 依赖树：
OrderService
├── UserService
│   └── UserRepository
│       └── DataSource
│           └── HikariConfig
├── ProductService
│   └── ProductRepository
│       └── DataSource（同一个）
├── InventoryService
│   ├── InventoryRepository
│   │   └── DataSource（同一个）
│   └── RedisClient
│       └── JedisPool
│           └── JedisPoolConfig
├── PaymentService（接口）
│   ├── AlipayPaymentService（实现1）
│   │   └── AlipayConfig
│   └── WechatPaymentService（实现2）
│       └── WechatConfig
└── NotificationService（接口）
    ├── EmailNotificationService（实现1）
    │   └── EmailConfig
    └── SmsNotificationService（实现2）
        └── SmsConfig

public class OrderService {

    public OrderService() {
        // 第1层：创建配置对象
        HikariConfig hikariConfig = new HikariConfig();
        hikariConfig.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
        hikariConfig.setUsername("root");
        hikariConfig.setPassword("123456");

        JedisPoolConfig jedisConfig = new JedisPoolConfig();
        jedisConfig.setMaxTotal(100);

        AlipayConfig alipayConfig = new AlipayConfig();
        alipayConfig.setAppId("xxx");
        alipayConfig.setPrivateKey("yyy");

        // 第2层：创建基础设施
        DataSource dataSource = new HikariDataSource(hikariConfig);
        JedisPool jedisPool = new JedisPool(jedisConfig, "localhost", 6379);

        // 第3层：创建Repository
        UserRepository userRepo = new UserRepository(dataSource);
        ProductRepository productRepo = new ProductRepository(dataSource);
        InventoryRepository inventoryRepo = new InventoryRepository(dataSource);

        // 第4层：创建基础服务
        RedisClient redisClient = new RedisClient(jedisPool);

        // 第5层：创建业务服务
        this.userService = new UserService(userRepo);
        this.productService = new ProductService(productRepo);
        this.inventoryService = new InventoryService(inventoryRepo, redisClient);
        this.paymentService = new AlipayPaymentService(alipayConfig);

        // 问题：
        // 1. 代码量巨大（50+行）
        // 2. 配置硬编码
        // 3. 难以切换实现（如切换支付方式）
        // 4. 单例管理困难（DataSource需要单例，如何保证？）
        // 5. 循环依赖无法处理
    }
}

@Service
public class OrderService {

    // 仅需声明依赖，容器自动注入
    @Autowired
    private UserService userService;

    @Autowired
    private ProductService productService;

    @Autowired
    private InventoryService inventoryService;

    @Autowired
    private PaymentService paymentService;  // 接口

    // Spring容器自动：
    // 1. 扫描所有@Component/@Service/@Repository
    // 2. 创建Bean实例（默认单例）
    // 3. 解析依赖关系
    // 4. 按顺序初始化（拓扑排序）
    // 5. 自动注入依赖
    // 6. 处理循环依赖（三级缓存）
}

# application.yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: ${DB_PASSWORD}  # 环境变量
    hikari:
      maximum-pool-size: 20

  redis:
    host: localhost
    port: 6379
    pool:
      max-active: 100

payment:
  type: alipay  # 切换为wechat无需修改代码
  alipay:
    app-id: ${ALIPAY_APP_ID}
    private-key: ${ALIPAY_PRIVATE_KEY}

// 问题：OrderService强依赖PaymentService
public class OrderService {
    private PaymentService paymentService = new AlipayPaymentService();

    public Order createOrder(OrderRequest request) {
        // ...
        boolean success = paymentService.pay(order.getAmount());
        // ...
    }
}

// 单元测试的困境
public class OrderServiceTest {

    @Test
    public void testCreateOrder() {
        OrderService service = new OrderService();

        // 问题：无法mock PaymentService
        // 测试时会真实调用支付宝接口（不可接受）
        // 1. 需要网络连接
        // 2. 需要支付宝账号
        // 3. 可能产生真实扣款
        // 4. 无法模拟支付失败的场景

        service.createOrder(request);  // 不敢运行
    }
}

// OrderService：依赖注入
@Service
public class OrderService {

    @Autowired
    private PaymentService paymentService;  // 接口，可替换

    public Order createOrder(OrderRequest request) {
        // ...
        boolean success = paymentService.pay(order.getAmount());
        // ...
    }
}

// 单元测试：注入Mock对象
@SpringBootTest
public class OrderServiceTest {

    @Autowired
    private OrderService orderService;

    @MockBean  // Spring Boot提供的mock注解
    private PaymentService paymentService;

    @Test
    public void testCreateOrder_PaymentSuccess() {
        // 模拟支付成功
        when(paymentService.pay(anyDouble())).thenReturn(true);

        Order order = orderService.createOrder(request);

        // 验证
        assertNotNull(order);
        assertEquals(OrderStatus.PAID, order.getStatus());
        verify(paymentService).pay(anyDouble());
    }

    @Test
    public void testCreateOrder_PaymentFailed() {
        // 模拟支付失败
        when(paymentService.pay(anyDouble())).thenReturn(false);

        // 验证抛出异常
        assertThrows(PaymentException.class, () -> {
            orderService.createOrder(request);
        });
    }

    @Test
    public void testCreateOrder_NetworkTimeout() {
        // 模拟网络超时
        when(paymentService.pay(anyDouble()))
            .thenThrow(new TimeoutException("网络超时"));

        assertThrows(TimeoutException.class, () -> {
            orderService.createOrder(request);
        });
    }
}

<!-- 传统Spring（XML配置地狱） -->
<beans>
    <bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource">
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mydb"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <bean id="userRepository" class="com.example.UserRepository">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <bean id="userService" class="com.example.UserService">
        <property name="userRepository" ref="userRepository"/>
    </bean>

    <!-- ...数百个Bean配置 -->
</beans>

// Spring Boot（约定优于配置）
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// 配置文件
# application.yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: ${DB_PASSWORD}

// 自动完成：
// 1. 自动扫描@Component/@Service/@Repository
// 2. 自动配置DataSource
// 3. 自动配置JPA/MyBatis
// 4. 自动配置Web容器（Tomcat）
// 5. 自动装配所有依赖