IoC 容器

// 传统方式：硬编码依赖，紧耦合
public class OrderService {
    private OrderRepository repo = new OrderRepositoryImpl();  // 直接 new
    private PaymentService payment = new AlipayService();       // 换支付方式要改代码
}

// IoC 方式：依赖由容器注入，松耦合
@Service
public class OrderService {
    private final OrderRepository repo;
    private final PaymentService payment;

    public OrderService(OrderRepository repo, PaymentService payment) {
        this.repo = repo;        // 容器注入，可随时替换实现
        this.payment = payment;  // 切换支付方式只需改配置
    }
}

// 侵入式：直接依赖 Spring API
public class BookService implements ApplicationContextAware {
    private ApplicationContext context;
    @Override
    public void setApplicationContext(ApplicationContext ctx) { this.context = ctx; }
    public Book getBook(long id) {
        DataSource ds = context.getBean(DataSource.class); // 主动从容器获取
    }
}

// 无侵入：不依赖任何 Spring API
public class BookService {
    private DataSource dataSource;
    public void setDataSource(DataSource dataSource) { this.dataSource = dataSource; }
    public Book getBook(long id) { /* 直接使用 dataSource */ }
}

public interface BeanFactory {
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType);
    <T> T getBean(Class<T> requiredType);
    boolean containsBean(String name);
    boolean isSingleton(String name);
    boolean isPrototype(String name);
    // ... 其他方法
}

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    this();           // 1. 调用父类构造方法，创建 DefaultListableBeanFactory
    register(componentClasses);  // 2. 注册配置类
    refresh();        // 3. 刷新容器（核心方法）
}

@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        prepareRefresh();
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        prepareBeanFactory(beanFactory);
        try {
            postProcessBeanFactory(beanFactory);
            invokeBeanFactoryPostProcessors(beanFactory);
            registerBeanPostProcessors(beanFactory);
            initMessageSource();
            initApplicationEventMulticaster();
            onRefresh();
            registerListeners();
            finishBeanFactoryInitialization(beanFactory);
            finishRefresh();
        }
        catch (BeansException ex) {
            destroyBeans();
            cancelRefresh(ex);
            throw ex;
        }
    }
}

@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;

    // Spring 4.3+ 单构造器可省略 @Autowired
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
}

@Service
public class UserService {
    private UserRepository userRepository;
    private EmailService emailService;

    @Autowired(required = false)  // 可选依赖，找不到时不报错
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }

    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

@Service
public class UserService {
    @Autowired  // 不推荐
    private UserRepository userRepository;

    @Autowired  // 不推荐
    private EmailService emailService;
}

@Service
public class UserService {
    private final UserRepository userRepository;  // 必需依赖
    private EmailService emailService;              // 可选依赖

    // 构造器注入：必需依赖
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // Setter 注入：可选依赖
    @Autowired(required = false)
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }
}

@Service
public class UserService {
    // 1. 构造器注入（Spring 4.3+ 单构造器可省略 @Autowired）
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // 2. Setter 方法注入
    @Autowired
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }

    // 3. 任意方法注入（不常用）
    @Autowired
    public void configure(UserRepository repo, EmailService email) {
        this.userRepository = repo;
        this.emailService = email;
    }
}

@Autowired(required = false)  // 可选依赖，找不到时不报错
private OptionalService optionalService;

// 更推荐用 Optional 表达可选性
@Autowired
public UserService(Optional<EmailService> emailService) {
    this.emailService = emailService;  // 调用方需处理空值
}

// Spring 5.0+ 也可使用 @Nullable
@Autowired
public void setService(@Nullable SomeService service) {
    this.service = service;
}

// Optional 注入
@Autowired
private Optional<NotificationService> notificationService;

public void notifyUser(User user, String message) {
    notificationService.ifPresent(service -> service.send(user, message));
}

// @Nullable 注入
public UserService(@Nullable NotificationService notificationService) {
    this.notificationService = notificationService;
}

public interface UserRepository { }

@Repository("jpaUserRepo")
public class JpaUserRepository implements UserRepository { }

@Repository("mybatisUserRepo")
public class MybatisUserRepository implements UserRepository { }

@Service
public class UserService {
    @Autowired
    @Qualifier("jpaUserRepo")  // 指定注入名为 "jpaUserRepo" 的 Bean
    private UserRepository userRepository;
}

@Bean
@Primary
@Qualifier("primaryUserRepository")
public UserRepository primaryUserRepository() {
    return new JpaUserRepository();
}

@Bean
@Qualifier("secondaryUserRepository")
public UserRepository secondaryUserRepository() {
    return new JdbcUserRepository();
}

@Repository
@Primary  // 同类型多个 Bean 时，优先注入此 Bean
public class JpaUserRepository implements UserRepository { }

@Repository
public class MybatisUserRepository implements UserRepository { }

@Service
public class UserService {
    @Autowired  // 自动注入 JpaUserRepository（@Primary 生效）
    private UserRepository userRepository;
}

// 默认按字段名查找 Bean
@Resource
private UserRepository userRepository;  // 查找名为 "userRepository" 的 Bean

// 指定 Bean 名称
@Resource(name = "jpaUserRepo")
private UserRepository userRepository;

// 也可按类型注入
@Resource(type = EmailService.class)
private NotificationService notificationService;

@Inject  // 按类型注入
private UserRepository userRepository;

@Inject
@Named("jpaUserRepo")  // 配合 @Named 指定名称
private UserRepository userRepository;

@Component
@Scope("singleton")  // 默认值，可省略
public class SingletonService { }

@Component
@Scope("prototype")
public class PrototypeService { }

// Web 作用域需要代理模式
@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST,
        proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestScopedBean { }

@Component  // 默认 singleton
public class SingletonBean {
    @Autowired
    private PrototypeBean prototypeBean;  //  问题：始终是同一个实例

    public void doSomething() {
        prototypeBean.process();  // 每次调用用的都是同一个 prototypeBean
    }
}

// 方案1：使用 ObjectProvider（推荐）
@Component
public class SingletonBean {
    @Autowired
    private ObjectProvider<PrototypeBean> prototypeBeanProvider;

    public void doSomething() {
        PrototypeBean bean = prototypeBeanProvider.getObject();  // 每次获取新实例
        bean.process();
    }
}

// 方案2：使用 Provider（JSR-330 标准）
@Component
public class SingletonBean {
    @Autowired
    private Provider<PrototypeBean> prototypeBeanProvider;

    public void doSomething() {
        PrototypeBean bean = prototypeBeanProvider.get();  // 每次获取新实例
    }
}

// 方案3：使用 @Lookup 方法注入
@Component
public abstract class SingletonBean {
    public void doSomething() {
        PrototypeBean bean = getPrototypeBean();  // 每次获取新实例
        bean.process();
    }

    @Lookup  // Spring 通过 CGLIB 生成子类覆盖此方法
    protected abstract PrototypeBean getPrototypeBean();
}

@Service
public class SingletonService {
    @Autowired
    private RequestBean requestBean;  // Request 作用域注入到 Singleton

    public void processRequest() {
        String requestId = requestBean.getRequestId();  // 通过代理访问
    }
}

// RequestBean 必须配置代理模式
@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST,
       proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestBean {
    // ...
}

// 在 @Bean 方法上使用
@Bean
@Lazy
public ExpensiveService expensiveService() {
    return new ExpensiveService();
}

// 在组件上使用
@Service
@Lazy
public class HeavyService { /* 耗时初始化 */ }

// 在注入点使用（首次调用才创建）
@Autowired
@Lazy
private HeavyService heavyService;

@Configuration
@ComponentScan(basePackages = "com.example")
@PropertySource("classpath:application.properties")
public class AppConfig {

    @Bean
    @Primary
    public DataSource dataSource(
            @Value("${spring.datasource.url}") String url,
            @Value("${spring.datasource.username}") String username,
            @Value("${spring.datasource.password}") String password) {
        return DataSourceBuilder.create()
                .url(url)
                .username(username)
                .password(password)
                .build();
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);  // 参数自动注入
    }
}

@Configuration
public class AppConfig {

    @Bean
    public UserService userService() {
        // 直接调用 userRepository() 返回的是容器中的单例，而非新实例
        return new UserService(userRepository());
    }

    @Bean
    public UserRepository userRepository() {
        return new UserRepositoryImpl();
    }
}

@Configuration
@ComponentScan(
  basePackages = "com.example",   // 指定扫描包
  basePackageClasses = {UserService.class, MailService.class}, // 指定扫描类所在包
  includeFilters = {              // 包含过滤器
    @Filter(type = FilterType.ANNOTATION, classes = Component.class)
  },
  excludeFilters = {              // 排除过滤器
    @Filter(type = FilterType.ASSIGNABLE_TYPE, classes = ExcludeService.class)
  }
)
public class AppConfig { }

@Configuration
public class AppConfig {

    @Bean
    public UserService userService() {
        return new UserService();
    }

    @Bean(name = "myDataSource")  // 指定 Bean 名称
    public DataSource dataSource() {
        return new HikariDataSource();
    }

    @Bean({"bean1", "bean2"})  // 多个别名
    public MailService mailService() {
        return new MailService();
    }

    // 方法参数注入（推荐）
    @Bean
    public UserService userService(DataSource dataSource) {
        UserService service = new UserService();
        service.setDataSource(dataSource);
        return service;
    }

    // 初始化和销毁
    @Bean(initMethod = "init", destroyMethod = "cleanup")
    public DataSource dataSource() {
        return new HikariDataSource();
    }
}

// 1. 导入配置类
@Configuration
@Import({DatabaseConfig.class, SecurityConfig.class})
public class AppConfig { }

// 2. 导入 XML 配置
@Configuration
@ImportResource("classpath:legacy-context.xml")
public class AppConfig { }

// 3. 导入普通类（注册为 Bean）
@Configuration
@Import({UserService.class, MailService.class})
public class AppConfig { }

// ImportSelector：根据条件选择导入的配置类（Spring Boot 自动配置大量使用）
public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata metadata) {
        return new String[]{"com.example.UserService", "com.example.MailService"};
    }
}

// ImportBeanDefinitionRegistrar：手动注册 BeanDefinition（框架级扩展）
public class MyRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        RootBeanDefinition bd = new RootBeanDefinition(UserService.class);
        registry.registerBeanDefinition("userService", bd);
    }
}

@Configuration
@Import({MyImportSelector.class, MyRegistrar.class})
public class AppConfig { }

// 注入 List（按 @Order 排序）
@Component
public class Validators {
    @Autowired
    List<Validator> validators;

    public void validate(String email, String password, String name) {
        for (var validator : this.validators) {
            validator.validate(email, password, name);
        }
    }
}

@Component
@Order(1)
public class EmailValidator implements Validator { /* ... */ }

@Component
@Order(2)
public class PasswordValidator implements Validator { /* ... */ }

@Component
@Order(3)
public class NameValidator implements Validator { /* ... */ }

// 注入 Map（Key 为 Bean 名称，Value 为 Bean 实例）
@Service
public class PaymentService {
    private final Map<String, PaymentStrategy> strategies;

    @Autowired
    public PaymentService(Map<String, PaymentStrategy> strategies) {
        this.strategies = strategies;
    }

    public void pay(String type, BigDecimal amount) {
        PaymentStrategy strategy = strategies.get(type + "PaymentStrategy");
        if (strategy != null) {
            strategy.pay(amount);
        }
    }
}

// 注入数组
@Autowired
private Validator[] validators;

@Configuration
public class DataSourceConfig {

    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        return new EmbeddedDatabaseBuilder()
                .setType(EmbeddedDatabaseType.H2)
                .build();
    }

    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        return DataSourceBuilder.create()
                .url("jdbc:mysql://prod-db:3306/myapp")
                .username("produser")
                .password("prodpass")
                .build();
    }
}

// 否定条件：非 test 环境
@Bean
@Profile("!test")
ZoneId createZoneId() { return ZoneId.systemDefault(); }

// 多 Profile：满足 test 或 master（"或"关系）
@Bean
@Profile({"test", "master"})
ZoneId createZoneId() { /* ... */ }

// 标注在 @Configuration 类上，整组 Bean 条件加载
@Configuration
@Profile("dev")
public class DevConfig { /* ... */ }

# 命令行参数（最高优先级）
java -jar app.jar --spring.profiles.active=dev

# JVM 参数
-Dspring.profiles.active=dev

# 环境变量
SPRING_PROFILES_ACTIVE=dev

# application.properties
spring.profiles.active=dev

// 代码方式
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.getEnvironment().setActiveProfiles("dev");
context.register(AppConfig.class);
context.refresh();

@Component
@Conditional(OnSmtpEnvCondition.class)
public class SmtpMailService implements MailService { /* ... */ }

public class OnSmtpEnvCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // ConditionContext：提供对容器环境的访问（BeanFactory、Environment 等）
        // AnnotatedTypeMetadata：提供标注 @Conditional 的类/方法的注解信息
        return "true".equalsIgnoreCase(System.getenv("smtp"));
    }
}

// 更复杂的自定义条件
public class OnDebugModeCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String debug = context.getEnvironment().getProperty("app.debug", "false");
        return "true".equalsIgnoreCase(debug);
    }
}

// 功能开关
@Component
@ConditionalOnProperty(name = "app.smtp", havingValue = "true")
public class MailService { /* ... */ }

// matchIfMissing：配置项不存在时也视为匹配（提供默认实现）
@Component
@ConditionalOnProperty(name = "app.storage", havingValue = "file", matchIfMissing = true)
public class FileUploader implements Uploader { /* ... */ }

@Component
@ConditionalOnProperty(name = "app.storage", havingValue = "s3")
public class S3Uploader implements Uploader { /* ... */ }

@Configuration
@ConditionalOnClass(DataSource.class)
public class DataSourceAutoConfiguration { /* ... */ }

@Configuration
@ConditionalOnMissingClass("com.example.CustomDataSource")
public class DefaultDataSourceConfiguration { /* ... */ }

@Bean
@ConditionalOnBean(DataSource.class)
public UserService userService() { return new UserService(); }

@Bean
@ConditionalOnMissingBean
public UserService defaultUserService() { return new DefaultUserService(); }

// SpEL 表达式
@Bean
@ConditionalOnExpression("${app.feature.enabled} and ${app.feature.premium}")
public PremiumFeatureService premiumFeatureService() { /* ... */ }

// Web 应用
@Configuration
@ConditionalOnWebApplication(type = Type.SERVLET)
public class WebConfiguration { /* ... */ }

// Java 版本
@Configuration
@ConditionalOnJava(value = JavaVersion.SEVENTEEN, range = Range.EQUAL_OR_NEWER)
public class Java17Configuration { /* ... */ }

@Configuration
public class CacheConfig {

    @Bean
    @ConditionalOnProperty(name = "cache.type", havingValue = "redis")
    @ConditionalOnClass(RedisTemplate.class)
    public CacheService redisCacheService(RedisTemplate<String, Object> redisTemplate) {
        return new RedisCacheService(redisTemplate);
    }

    @Bean
    @ConditionalOnProperty(name = "cache.type", havingValue = "local", matchIfMissing = true)
    public CacheService localCacheService() {
        return new LocalCacheService();
    }
}

@Configuration
@ComponentScan
@PropertySource("app.properties")  // 读取 classpath 的 app.properties
public class AppConfig {
    @Value("${app.zone:Z}")  // ${key:defaultValue}
    String zoneId;

    @Bean
    ZoneId createZoneId() {
        return ZoneId.of(zoneId);
    }
}

@Bean
ZoneId createZoneId(@Value("${app.zone:Z}") String zoneId) {
    return ZoneId.of(zoneId);
}

@PropertySource({"app.properties", "smtp.properties"})

// 先定义一个持有配置的 Bean
@Component
public class SmtpConfig {
    @Value("${smtp.host:localhost}")
    private String host;

    @Value("${smtp.port:25}")
    private int port;

    public String getHost() { return host; }
    public int getPort() { return port; }
}

// 在其他 Bean 中通过 SpEL 引用
@Component
public class MailService {
    @Value("#{smtpConfig.host}")  // 调用 smtpConfig.getHost()
    private String smtpHost;

    @Value("#{smtpConfig.port}")  // 调用 smtpConfig.getPort()
    private int smtpPort;
}

@ConfigurationProperties(prefix = "app.datasource")
public class DataSourceProperties {
    private String url;
    private String username;
    private String password;
    private int maximumPoolSize = 10;
    private long connectionTimeout = 30000;

    // getters and setters（必须提供，Spring 通过 Setter 方法注入）
}

# application.yml
app:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret
    maximum-pool-size: 20    # 松散绑定：自动映射到 maximumPoolSize
    connection-timeout: 60000

@Configuration
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceConfig {

    @Bean
    public DataSource dataSource(DataSourceProperties properties) {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl(properties.getUrl());
        ds.setUsername(properties.getUsername());
        ds.setPassword(properties.getPassword());
        ds.setMaximumPoolSize(properties.getMaximumPoolSize());
        return ds;
    }
}

@ConfigurationProperties(prefix = "app.datasource")
@Validated
public class DataSourceProperties {
    @NotBlank
    private String url;

    @NotBlank
    private String username;

    @Min(1)
    @Max(100)
    private int maximumPoolSize = 10;

    // getters and setters
}

@Component
public class AppService {
    @Value("classpath:/logo.txt")  // 从 classpath 注入
    private Resource resource;

    private String logo;

    @PostConstruct
    public void init() throws IOException {
        try (var reader = new BufferedReader(
          new InputStreamReader(resource.getInputStream(), StandardCharsets.UTF_8))) {
            this.logo = reader.lines().collect(Collectors.joining("\n"));
        }
    }
}

@Value("file:/path/to/logo.txt")
private Resource resource;

public interface Resource extends InputStreamSource {
    InputStream getInputStream() throws IOException;  // 获取输入流
    boolean exists();       // 判断资源是否存在
    boolean isReadable();   // 判断资源是否可读
    URL getURL() throws IOException;   // 获取资源 URL
    File getFile() throws IOException; // 获取 File 对象
    long contentLength() throws IOException;   // 内容长度
    String getFilename();   // 文件名
    String getDescription(); // 描述
}

@Service
public class ResourceService {
    @Autowired
    private ResourceLoader resourceLoader;

    public String loadResource(String location) throws IOException {
        Resource resource = resourceLoader.getResource(location);
        try (InputStream is = resource.getInputStream()) {
            return new String(is.readAllBytes(), StandardCharsets.UTF_8);
        }
    }
}

public class LifecycleBean implements InitializingBean {

    @PostConstruct  // 1. 注解方式（推荐）
    public void postConstruct() {
        System.out.println("@PostConstruct");
    }

    @Override
    public void afterPropertiesSet() throws Exception {  // 2. 接口方式
        System.out.println("InitializingBean.afterPropertiesSet()");
    }

    public void customInit() {  // 3. 自定义方法
        System.out.println("customInit()");
    }
}

// Java Config
@Bean(initMethod = "customInit")
public LifecycleBean lifecycleBean() {
    return new LifecycleBean();
}

public class LifecycleBean implements DisposableBean {

    @PreDestroy  // 1. 注解方式（推荐）
    public void preDestroy() {
        System.out.println("@PreDestroy");
    }

    @Override
    public void destroy() throws Exception {  // 2. 接口方式
        System.out.println("DisposableBean.destroy()");
    }

    public void customDestroy() {  // 3. 自定义方法
        System.out.println("customDestroy()");
    }
}

@Component
public class MyBean implements ApplicationContextAware, BeanNameAware {
    private ApplicationContext context;
    private String beanName;

    @Override
    public void setBeanName(String name) {
        this.beanName = name;  // 容器注入 Bean 名称
    }

    @Override
    public void setApplicationContext(ApplicationContext context) {
        this.context = context;  // 容器注入 ApplicationContext
    }
}

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        if (bean instanceof LifecycleBean) {
            System.out.println("BeanPostProcessor - 初始化前处理: " + beanName);
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof LifecycleBean) {
            System.out.println("BeanPostProcessor - 初始化后处理: " + beanName);
        }
        return bean;
    }
}

// 方案1：使用 @Lazy（推荐）
@Service
public class ServiceA {
    @Autowired
    @Lazy  // 延迟创建代理对象，打破循环
    private ServiceB serviceB;
}

// 方案2：使用 Setter 注入（配合三级缓存）
@Service
public class ServiceA {
    private ServiceB serviceB;

    @Autowired
    public void setServiceB(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

// 方案3：重构设计，提取公共逻辑（最佳）
@Service
public class CommonService {
    // 公共逻辑
}

@Service
public class ServiceA {
    @Autowired
    private CommonService commonService;  // 不再循环依赖
}

@Configuration
public class MultiDataSourceConfig {

    @Bean
    @Primary  // 默认数据源
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @Primary
    public JdbcTemplate primaryJdbcTemplate(DataSource primaryDataSource) {
        return new JdbcTemplate(primaryDataSource);
    }

    @Bean
    public JdbcTemplate secondaryJdbcTemplate(DataSource secondaryDataSource) {
        return new JdbcTemplate(secondaryDataSource);
    }
}

@Service
public class UserService {

    @Autowired
    @Qualifier("primaryJdbcTemplate")
    private JdbcTemplate primaryJdbcTemplate;

    @Autowired
    @Qualifier("secondaryJdbcTemplate")
    private JdbcTemplate secondaryJdbcTemplate;
}

@Configuration
public class DynamicBeanConfig implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
            throws BeansException {
        // 动态注册 Bean
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .rootBeanDefinition(DynamicService.class)
                .addPropertyValue("name", "dynamic")
                .setScope("singleton");

        registry.registerBeanDefinition("dynamicService", builder.getBeanDefinition());
    }
}

public class MyFactoryBean implements FactoryBean<MyService> {

    private String serviceName;

    public void setServiceName(String serviceName) {
        this.serviceName = serviceName;
    }

    @Override
    public MyService getObject() throws Exception {
        return new MyService(serviceName);
    }

    @Override
    public Class<?> getObjectType() {
        return MyService.class;
    }

    @Override
    public boolean isSingleton() {
        return true;  // 默认单例
    }
}

// 注册 FactoryBean
@Bean
public MyFactoryBean myService() {
    MyFactoryBean factoryBean = new MyFactoryBean();
    factoryBean.setServiceName("myService");
    return factoryBean;  // 容器会调用 getObject() 获取真正的 MyService 实例
}

// 获取 FactoryBean 产生的 Bean
context.getBean("myService");        // 返回 MyService 实例
context.getBean("&myService");       // 返回 MyFactoryBean 实例（& 前缀）

// × 错误：单例 Bean 持有可变状态，线程不安全
@Service
public class UserService {
    private User currentUser;  // 多线程共享，危险！

    public void setCurrentUser(User user) {
        this.currentUser = user;
    }
}

// √ 正确：无状态 Bean，通过参数传递
@Service
public class UserService {
    public void doSomething(User currentUser) {
        // 通过参数传递，不持有状态
    }
}

// √ 正确：使用 ThreadLocal（需注意清理）
@Service
public class UserService {
    private final ThreadLocal<User> currentUserHolder = new ThreadLocal<>();

    public void setCurrentUser(User user) {
        currentUserHolder.set(user);
    }

    public User getCurrentUser() {
        return currentUserHolder.get();
    }
}

// × 字段注入：依赖关系不透明，容易违反单一职责
@Service
public class UserService {
    @Autowired private UserRepository userRepository;
    @Autowired private EmailService emailService;
    @Autowired private SmsService smsService;
    @Autowired private LogService logService;
    @Autowired private CacheService cacheService;
    // ... 更多依赖，你不会意识到这个类已经过于臃肿
}

// √ 构造器注入：依赖一目了然，参数过多时提醒你拆分
@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;

    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
}

// × 隐藏必需依赖，运行时可能 NPE
@Service
public class UserService {
    @Autowired(required = false)
    private UserRepository userRepository;

    public User findById(Long id) {
        return userRepository.findById(id);  // userRepository 可能为 null！
    }
}

// √ 必需依赖用构造器注入，可选依赖用 Optional
@Service
public class UserService {
    private final UserRepository userRepository;
    private final Optional<EmailService> emailService;

    public UserService(UserRepository userRepository,
                       Optional<EmailService> emailService) {
        this.userRepository = Objects.requireNonNull(userRepository,
                "UserRepository must not be null");
        this.emailService = emailService;
    }

    public void sendNotification(String message) {
        emailService.ifPresent(service -> service.send(message));
    }
}

// × 参数过多，违反单一职责
@Service
public class UserService {
    public UserService(UserRepository repo, EmailService email,
                       SmsService sms, LogService log,
                       CacheService cache, AuditService audit,
                       ConfigService config) {
        // 7 个参数！这个类做了太多事
    }
}

// √ 拆分服务，每个类职责单一
@Service
public class UserService {
    private final UserRepository repo;
    public UserService(UserRepository repo) { this.repo = repo; }
}

@Service
public class NotificationService {
    private final EmailService email;
    private final SmsService sms;
    public NotificationService(EmailService email, SmsService sms) { ... }
}

// × 误以为 @Bean 方法间调用会创建新实例
@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserService(userRepository());  // 担心这里会 new 两次？
    }

    @Bean
    public UserRepository userRepository() {
        return new UserRepositoryImpl();
    }
}

// 实际上：@Configuration 默认被 CGLIB 代理
// userRepository() 调用会被拦截，返回容器中的单例
// 所以不会创建新实例

//  但如果用 @Configuration(proxyBeanMethods = false) 或 @Component
// 则 userRepository() 调用会创建新实例！