Spring 核心注解 @Autowired 详解：告别 new，拥抱依赖注入！

引言

Spring框架的依赖注入（DI）是其核心特性之一，而@Autowired注解是实现依赖注入的主要方式。掌握@Autowired的使用方法和原理，对于Spring开发者来说至关重要。本文将从基础概念到高级应用，全面解析@Autowired注解的使用技巧。

@Autowired基础概念

注解简介

@Autowired是Spring框架提供的依赖注入注解，可以标注在字段、构造器、方法参数上，用于自动装配Bean。

自动装配原理

Spring容器在启动时会扫描所有标记了@Component、@Service、@Repository、@Controller等注解的类，并将它们注册为Bean。当遇到@Autowired注解时，容器会根据类型或名称自动注入相应的Bean。

@Autowired基本用法

字段注入

public class UserService {
   
    @Autowired
    private UserRepository userRepository;

    @Autowired
    private EmailService emailService;

    public void processUser(Long userId) {
   
        User user = userRepository.findById(userId);
        // 业务逻辑处理
        emailService.sendWelcomeEmail(user.getEmail());
    }
}

构造器注入

public class OrderService {
   
    private final PaymentService paymentService;
    private final InventoryService inventoryService;

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

    public OrderResult processOrder(OrderRequest request) {
   
        // 检查库存
        boolean available = inventoryService.checkAvailability(request.getProductId());
        if (!available) {
   
            throw new InsufficientStockException("商品库存不足");
        }

        // 处理支付
        PaymentResult paymentResult = paymentService.processPayment(request.getPaymentInfo());
        return new OrderResult(paymentResult.isSuccess());
    }
}

Setter方法注入

public class NotificationService {
   
    private MessageService messageService;
    private EmailService emailService;

    @Autowired
    public void setMessageService(MessageService messageService) {
   
        this.messageService = messageService;
    }

    @Autowired
    public void setEmailService(EmailService emailService) {
   
        this.emailService = emailService;
    }

    public void sendNotification(String message, String recipient) {
   
        messageService.sendMessage(message, recipient);
        emailService.sendEmail(message, recipient);
    }
}

@Autowired高级特性

@Qualifier注解精确匹配

当存在多个相同类型的Bean时，使用@Qualifier指定具体的Bean。

public interface PaymentProcessor {
   
    boolean process(double amount);
}

@Service("alipayProcessor")
public class AlipayPaymentProcessor implements PaymentProcessor {
   
    @Override
    public boolean process(double amount) {
   
        // 支付宝支付逻辑
        return true;
    }
}

@Service("wechatProcessor")
public class WechatPaymentProcessor implements PaymentProcessor {
   
    @Override
    public boolean process(double amount) {
   
        // 微信支付逻辑
        return true;
    }
}

@Service
public class PaymentService {
   
    @Autowired
    @Qualifier("alipayProcessor")
    private PaymentProcessor alipayProcessor;

    @Autowired
    @Qualifier("wechatProcessor")
    private PaymentProcessor wechatProcessor;

    public boolean processPayment(String type, double amount) {
   
        if ("alipay".equals(type)) {
   
            return alipayProcessor.process(amount);
        } else if ("wechat".equals(type)) {
   
            return wechatProcessor.process(amount);
        }
        return false;
    }
}

@Primary注解设置首选Bean

当存在多个相同类型的Bean时，@Primary标记的Bean会被优先注入。

@Component
@Primary
public class DefaultUserService implements UserService {
   
    @Override
    public User findUser(Long id) {
   
        // 默认实现
        return new User(id, "default user");
    }
}

@Component
public class PremiumUserService implements UserService {
   
    @Override
    public User findUser(Long id) {
   
        // 高级实现
        return new User(id, "premium user");
    }
}

@Service
public class UserController {
   
    @Autowired
    private UserService userService; // 注入@Primary标记的Bean

    public User getUser(Long id) {
   
        return userService.findUser(id);
    }
}

required属性控制注入行为

@Autowired注解的required属性控制是否必须注入依赖。

@Service
public class OptionalService {
   
    @Autowired(required = false)
    private OptionalFeature optionalFeature;

    public void execute() {
   
        if (optionalFeature != null) {
   
            optionalFeature.doSomething();
        } else {
   
            // 提供默认行为
            System.out.println("Optional feature not available");
        }
    }
}

@Autowired与@Value结合使用

注入配置属性

@ConfigurationProperties(prefix = "app")
@Component
public class AppProperties {
   
    private String name;
    private int timeout;

    // getter和setter方法
}

@Service
public class ConfigurableService {
   
    @Value("${app.name}")
    private String appName;

    @Value("${app.timeout:30}")
    private int defaultTimeout;

    @Autowired
    private AppProperties appProperties;

    public void displayConfig() {
   
        System.out.println("App Name: " + appName);
        System.out.println("Timeout: " + defaultTimeout);
        System.out.println("Properties Name: " + appProperties.getName());
    }
}

集合类型注入

注入多个相同类型的Bean

@Service
public class ProcessingService {
   
    @Autowired
    private List<Validator> validators;

    @Autowired
    private Map<String, Handler> handlers;

    public ValidationResult validate(Object object) {
   
        for (Validator validator : validators) {
   
            ValidationResult result = validator.validate(object);
            if (!result.isValid()) {
   
                return result;
            }
        }
        return ValidationResult.success();
    }

    public void handle(String type, Object data) {
   
        Handler handler = handlers.get(type);
        if (handler != null) {
   
            handler.process(data);
        }
    }
}

@Component("userValidator")
public class UserValidator implements Validator {
   
    @Override
    public ValidationResult validate(Object object) {
   
        // 用户验证逻辑
        return ValidationResult.success();
    }
}

@Component("orderValidator")
public class OrderValidator implements Validator {
   
    @Override
    public ValidationResult validate(Object object) {
   
        // 订单验证逻辑
        return ValidationResult.success();
    }
}

@Component("userHandler")
public class UserHandler implements Handler {
   
    @Override
    public void process(Object data) {
   
        // 用户处理逻辑
    }
}

@Autowired在不同场景的应用

Controller层注入

@RestController
@RequestMapping("/api/users")
public class UserController {
   
    @Autowired
    private UserService userService;

    @Autowired
    private ValidationService validationService;

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
   
        User user = userService.findById(id);
        return ResponseEntity.ok(user);
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
   
        validationService.validate(user);
        User savedUser = userService.save(user);
        return ResponseEntity.status(HttpStatus.CREATED).body(savedUser);
    }
}

Service层注入

@Service
@Transactional
public class TransactionService {
   
    @Autowired
    private AccountRepository accountRepository;

    @Autowired
    private TransactionRepository transactionRepository;

    public TransactionResult transfer(Long fromId, Long toId, BigDecimal amount) {
   
        Account fromAccount = accountRepository.findById(fromId)
            .orElseThrow(() -> new AccountNotFoundException("源账户不存在"));

        Account toAccount = accountRepository.findById(toId)
            .orElseThrow(() -> new AccountNotFoundException("目标账户不存在"));

        if (fromAccount.getBalance().compareTo(amount) < 0) {
   
            throw new InsufficientFundsException("余额不足");
        }

        // 执行转账
        fromAccount.setBalance(fromAccount.getBalance().subtract(amount));
        toAccount.setBalance(toAccount.getBalance().add(amount));

        accountRepository.save(fromAccount);
        accountRepository.save(toAccount);

        Transaction transaction = new Transaction(fromId, toId, amount);
        transactionRepository.save(transaction);

        return new TransactionResult(true, "转账成功", transaction.getId());
    }
}

Repository层注入

@Repository
public class CustomUserRepository {
   
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

    public List<User> findUsersByAge(int minAge, int maxAge) {
   
        String sql = "SELECT * FROM users WHERE age BETWEEN :minAge AND :maxAge";
        Map<String, Object> params = Map.of(
            "minAge", minAge,
            "maxAge", maxAge
        );

        return namedParameterJdbcTemplate.query(sql, params, (rs, rowNum) -> {
   
            User user = new User();
            user.setId(rs.getLong("id"));
            user.setName(rs.getString("name"));
            user.setAge(rs.getInt("age"));
            return user;
        });
    }
}

@Autowired与泛型

泛型Bean注入

public interface Repository<T, ID> {
   
    T findById(ID id);
    T save(T entity);
}

@Repository
public class UserRepository implements Repository<User, Long> {
   
    @Override
    public User findById(Long id) {
   
        // 实现逻辑
        return new User();
    }

    @Override
    public User save(User entity) {
   
        // 实现逻辑
        return entity;
    }
}

@Service
public class GenericService {
   
    @Autowired
    private Repository<User, Long> userRepository;

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

@Autowired与条件注解

@ConditionalOnProperty条件注入

@Configuration
public class ConditionalConfig {
   
    @Bean
    @ConditionalOnProperty(name = "feature.enabled", havingValue = "true")
    public FeatureService featureService() {
   
        return new FeatureServiceImpl();
    }

    @Bean
    @ConditionalOnProperty(name = "feature.enabled", havingValue = "false", matchIfMissing = true)
    public FeatureService defaultFeatureService() {
   
        return new DefaultFeatureService();
    }
}

@Service
public class ConditionalService {
   
    @Autowired
    private FeatureService featureService; // 根据配置自动注入
}

最佳实践与注意事项

构造器注入优先原则

推荐使用构造器注入，因为它确保了依赖的不可变性和完整性。

@Service
public class RecommendedService {
   
    private final DependencyA dependencyA;
    private final DependencyB dependencyB;

    // 推荐：构造器注入
    public RecommendedService(DependencyA dependencyA, DependencyB dependencyB) {
   
        this.dependencyA = dependencyA;
        this.dependencyB = dependencyB;
    }
}

循环依赖处理

@Component
public class ServiceA {
   
    @Autowired
    private ServiceB serviceB; // 循环依赖
}

@Component
public class ServiceB {
   
    @Autowired
    private ServiceA serviceA; // 循环依赖
}

// 解决方案：使用@Lazy注解
@Component
public class ServiceA {
   
    @Autowired
    @Lazy
    private ServiceB serviceB;
}

测试友好性

使用构造器注入使单元测试更容易。

public class UserServiceTest {
   
    @Test
    public void testUserCreation() {
   
        // 模拟依赖
        UserRepository mockRepo = Mockito.mock(UserRepository.class);
        EmailService mockEmail = Mockito.mock(EmailService.class);

        // 创建被测试对象
        UserService userService = new UserService(mockRepo, mockEmail);

        // 执行测试
        userService.createUser(new User());

        // 验证行为
        verify(mockRepo).save(any(User.class));
    }
}

性能考虑

注入时机优化

@Component
public class LazyService {
   
    @Autowired
    @Lazy
    private HeavyService heavyService; // 延迟初始化

    public void doSomething() {
   
        // heavyService只有在使用时才初始化
        heavyService.performAction();
    }
}

总结

@Autowired注解是Spring框架依赖注入的核心，正确使用它能够显著提升代码的可维护性和可测试性。通过理解其工作原理和高级特性，开发者可以构建更加灵活和健壮的Spring应用。记住优先使用构造器注入，合理处理循环依赖，并结合Spring的其他特性来构建高质量的应用程序。