Spring Bean 管理完整指南

概述

Spring Bean 是Spring IoC容器管理的对象，是Spring框架的核心概念之一。Bean的生命周期、作用域、依赖关系都由Spring容器负责管理，这种管理方式实现了对象的松耦合和高可维护性。

核心概念

• Bean：由Spring IoC容器实例化、组装和管理的对象
• Bean定义：描述如何创建Bean实例的配置元数据
• Bean容器：Spring IoC容器，负责Bean的完整生命周期管理
• Bean工厂：创建和管理Bean实例的工厂模式实现

Bean管理的优势

💡 提示: 理解Bean管理是掌握Spring框架的基础，也是构建企业级应用的关键。

Bean基础概念

Bean与普通Java对象的区别

1. 普通Java对象

// 传统的Java对象创建和管理
public class UserService {
    private UserRepository userRepository;
    
    public UserService() {
        // 硬编码依赖创建
        this.userRepository = new UserRepositoryImpl();
    }
    
    public User getUser(Long id) {
        return userRepository.findById(id);
    }
}

// 客户端代码需要手动管理对象
public class Application {
    public static void main(String[] args) {
        UserService userService = new UserService();
        User user = userService.getUser(1L);
    }
}

2. Spring管理的Bean

// Spring Bean：由容器管理的对象
@Service
public class UserService {
    
    private final UserRepository userRepository;
    
    // 依赖由Spring容器注入
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public User getUser(Long id) {
        return userRepository.findById(id);
    }
}

@Repository
public class UserRepositoryImpl implements UserRepository {
    
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Override
    public User findById(Long id) {
        String sql = "SELECT * FROM users WHERE id = ?";
        return jdbcTemplate.queryForObject(sql, new UserRowMapper(), id);
    }
}

// 客户端代码通过容器获取Bean
@Component
public class Application {
    
    @Autowired
    private UserService userService;
    
    public void run() {
        User user = userService.getUser(1L);
        System.out.println("User: " + user.getName());
    }
}

Bean定义的组成要素

1. Bean标识信息

@Configuration
public class BeanIdentityConfig {
    
    // 使用方法名作为Bean名称
    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }
    
    // 指定Bean名称
    @Bean(name = "primaryUserService")
    public UserService primaryUserService() {
        return new UserServiceImpl();
    }
    
    // 指定多个别名
    @Bean(name = {"userSvc", "userManager", "userHandler"})
    public UserService aliasedUserService() {
        return new UserServiceImpl();
    }
}

2. Bean类型信息

public interface UserService {
    User getUser(Long id);
    User saveUser(User user);
}

@Service
public class UserServiceImpl implements UserService {
    // 实现接口的具体类
    
    @Override
    public User getUser(Long id) {
        // 实现逻辑
        return new User();
    }
    
    @Override
    public User saveUser(User user) {
        // 实现逻辑
        return user;
    }
}

// Bean类型可以是接口、抽象类或具体类
@Configuration
public class BeanTypeConfig {
    
    @Bean
    public UserService userService() {
        return new UserServiceImpl();  // 返回接口类型
    }
    
    @Bean
    public UserServiceImpl userServiceImpl() {
        return new UserServiceImpl();  // 返回具体类型
    }
}

Bean定义与配置

XML配置方式

1. 基础Bean定义

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!-- 基本Bean定义 -->
    <bean id="userRepository" class="com.example.repository.UserRepositoryImpl"/>
    
    <!-- 带属性的Bean定义 -->
    <bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource">
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/testdb"/>
        <property name="username" value="root"/>
        <property name="password" value="password"/>
        <property name="maximumPoolSize" value="20"/>
        <property name="minimumIdle" value="5"/>
    </bean>
    
    <!-- 构造器参数注入 -->
    <bean id="userService" class="com.example.service.UserServiceImpl">
        <constructor-arg ref="userRepository"/>
        <constructor-arg value="defaultUserService"/>
    </bean>
    
    <!-- 属性注入 -->
    <bean id="emailService" class="com.example.service.EmailServiceImpl">
        <property name="smtpHost" value="smtp.example.com"/>
        <property name="smtpPort" value="587"/>
        <property name="username" value="user@example.com"/>
        <property name="password" value="emailPassword"/>
    </bean>
    
    <!-- 集合属性注入 -->
    <bean id="configService" class="com.example.service.ConfigServiceImpl">
        <property name="supportedLanguages">
            <list>
                <value>zh-CN</value>
                <value>en-US</value>
                <value>ja-JP</value>
            </list>
        </property>
        <property name="configProperties">
            <map>
                <entry key="timeout" value="30"/>
                <entry key="retryCount" value="3"/>
                <entry key="enableCache" value="true"/>
            </map>
        </property>
        <property name="adminEmails">
            <set>
                <value>admin1@example.com</value>
                <value>admin2@example.com</value>
                <value>admin3@example.com</value>
            </set>
        </property>
    </bean>
</beans>

2. 高级XML配置

<!-- 命名空间和高级特性 -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/util
           http://www.springframework.org/schema/util/spring-util.xsd">
    
    <!-- 使用p命名空间简化属性注入 -->
    <bean id="emailService" 
          class="com.example.service.EmailServiceImpl"
          p:smtpHost="smtp.example.com"
          p:smtpPort="587"
          p:username="user@example.com"
          p:password="password"/>
    
    <!-- 使用c命名空间简化构造器注入 -->
    <bean id="userService"
          class="com.example.service.UserServiceImpl"
          c:userRepository-ref="userRepository"
          c:serviceName="userService"/>
    
    <!-- 使用util命名空间定义集合Bean -->
    <util:list id="supportedLanguages">
        <value>zh-CN</value>
        <value>en-US</value>
        <value>ja-JP</value>
    </util:list>
    
    <util:map id="systemProperties">
        <entry key="app.name" value="MyApplication"/>
        <entry key="app.version" value="1.0.0"/>
        <entry key="app.environment" value="production"/>
    </util:map>
    
    <!-- 引用util集合 -->
    <bean id="applicationConfig" class="com.example.config.ApplicationConfig">
        <property name="supportedLanguages" ref="supportedLanguages"/>
        <property name="systemProperties" ref="systemProperties"/>
    </bean>
    
    <!-- Bean别名定义 -->
    <alias name="userService" alias="userManager"/>
    <alias name="userService" alias="userHandler"/>
    
    <!-- 抽象Bean定义 -->
    <bean id="abstractDataSource" abstract="true">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="validationQuery" value="SELECT 1"/>
    </bean>
    
    <!-- 继承抽象Bean -->
    <bean id="primaryDataSource" 
          class="com.zaxxer.hikari.HikariDataSource"
          parent="abstractDataSource">
        <property name="jdbcUrl" value="jdbc:mysql://primary:3306/app"/>
        <property name="username" value="app_user"/>
        <property name="password" value="app_password"/>
    </bean>
    
    <bean id="secondaryDataSource"
          class="com.zaxxer.hikari.HikariDataSource" 
          parent="abstractDataSource">
        <property name="jdbcUrl" value="jdbc:mysql://secondary:3306/app"/>
        <property name="username" value="app_user"/>
        <property name="password" value="app_password"/>
    </bean>
</beans>

Java配置方式

1. 基础Java配置

@Configuration
public class AppConfig {
    
    /**
     * 基础Bean定义
     */
    @Bean
    public UserRepository userRepository() {
        return new UserRepositoryImpl();
    }
    
    /**
     * 带依赖的Bean定义
     */
    @Bean
    public UserService userService(UserRepository userRepository) {
        return new UserServiceImpl(userRepository);
    }
    
    /**
     * 复杂Bean配置
     */
    @Bean
    public DataSource dataSource() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/testdb");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        dataSource.setMaximumPoolSize(20);
        dataSource.setMinimumIdle(5);
        dataSource.setConnectionTimeout(30000);
        dataSource.setIdleTimeout(600000);
        dataSource.setMaxLifetime(1800000);
        return dataSource;
    }
    
    /**
     * 使用@Value注入属性值
     */
    @Bean
    public EmailService emailService(@Value("${email.smtp.host}") String smtpHost,
                                    @Value("${email.smtp.port}") int smtpPort,
                                    @Value("${email.username}") String username,
                                    @Value("${email.password}") String password) {
        EmailServiceImpl emailService = new EmailServiceImpl();
        emailService.setSmtpHost(smtpHost);
        emailService.setSmtpPort(smtpPort);
        emailService.setUsername(username);
        emailService.setPassword(password);
        return emailService;
    }
    
    /**
     * 集合类型Bean
     */
    @Bean
    public List<String> supportedLanguages() {
        return Arrays.asList("zh-CN", "en-US", "ja-JP", "ko-KR");
    }
    
    @Bean
    public Map<String, String> systemProperties() {
        Map<String, String> properties = new HashMap<>();
        properties.put("app.name", "MyApplication");
        properties.put("app.version", "1.0.0");
        properties.put("app.environment", "production");
        return properties;
    }
}

2. 高级Java配置

@Configuration
@PropertySource("classpath:application.properties")
public class AdvancedConfig {
    
    @Autowired
    private Environment environment;
    
    /**
     * 条件化Bean创建
     */
    @Bean
    @Profile("development")
    public DataSource developmentDataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .addScript("classpath:schema.sql")
            .addScript("classpath:test-data.sql")
            .build();
    }
    
    @Bean
    @Profile("production")
    public DataSource productionDataSource() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(environment.getProperty("db.url"));
        dataSource.setUsername(environment.getProperty("db.username"));
        dataSource.setPassword(environment.getProperty("db.password"));
        return dataSource;
    }
    
    /**
     * Bean初始化和销毁方法
     */
    @Bean(initMethod = "initialize", destroyMethod = "cleanup")
    public CustomService customService() {
        return new CustomServiceImpl();
    }
    
    /**
     * 作用域配置
     */
    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public TaskProcessor taskProcessor() {
        return new TaskProcessorImpl();
    }
    
    /**
     * 延迟初始化
     */
    @Bean
    @Lazy
    public ExpensiveService expensiveService() {
        return new ExpensiveServiceImpl();
    }
    
    /**
     * Primary Bean
     */
    @Bean
    @Primary
    public MessageService primaryMessageService() {
        return new EmailMessageService();
    }
    
    @Bean
    public MessageService smsMessageService() {
        return new SmsMessageService();
    }
    
    /**
     * 工厂Bean
     */
    @Bean
    public FactoryBean<Connection> connectionFactory() {
        return new ConnectionFactoryBean();
    }
}

public class CustomServiceImpl implements CustomService {
    
    public void initialize() {
        System.out.println("CustomService 初始化完成");
        // 初始化逻辑
    }
    
    public void cleanup() {
        System.out.println("CustomService 清理资源");
        // 清理逻辑
    }
}

Bean实例化方式

构造器实例化

1. 默认构造器

// Bean类定义
public class UserService {
    
    public UserService() {
        System.out.println("UserService 通过默认构造器创建");
    }
    
    public void processUser(User user) {
        System.out.println("处理用户: " + user.getName());
    }
}

// XML配置
<bean id="userService" class="com.example.service.UserService"/>

// Java配置
@Configuration
public class Config {
    @Bean
    public UserService userService() {
        return new UserService();
    }
}

// 注解配置
@Service
public class UserService {
    // Spring会使用默认构造器创建实例
}

2. 参数化构造器

// 带参数的构造器
public class UserService {
    
    private final UserRepository userRepository;
    private final EmailService emailService;
    private final String serviceName;
    
    public UserService(UserRepository userRepository, 
                      EmailService emailService, 
                      String serviceName) {
        this.userRepository = userRepository;
        this.emailService = emailService;
        this.serviceName = serviceName;
        System.out.println("UserService 通过参数化构造器创建: " + serviceName);
    }
    
    public User createUser(String name, String email) {
        User user = new User(name, email);
        User savedUser = userRepository.save(user);
        emailService.sendWelcomeEmail(savedUser.getEmail());
        return savedUser;
    }
}

// XML配置
<bean id="userService" class="com.example.service.UserService">
    <constructor-arg ref="userRepository"/>
    <constructor-arg ref="emailService"/>
    <constructor-arg value="primaryUserService"/>
</bean>

// 按类型匹配构造器参数
<bean id="userService" class="com.example.service.UserService">
    <constructor-arg type="com.example.repository.UserRepository" ref="userRepository"/>
    <constructor-arg type="com.example.service.EmailService" ref="emailService"/>
    <constructor-arg type="java.lang.String" value="primaryUserService"/>
</bean>

// 按索引匹配构造器参数
<bean id="userService" class="com.example.service.UserService">
    <constructor-arg index="0" ref="userRepository"/>
    <constructor-arg index="1" ref="emailService"/>
    <constructor-arg index="2" value="primaryUserService"/>
</bean>

// Java配置
@Configuration
public class Config {
    
    @Bean
    public UserService userService(UserRepository userRepository, 
                                  EmailService emailService) {
        return new UserService(userRepository, emailService, "primaryUserService");
    }
}

静态工厂方法实例化

1. 静态工厂类

// 静态工厂类
public class UserServiceFactory {
    
    private static final Map<String, UserService> serviceCache = new ConcurrentHashMap<>();
    
    /**
     * 静态工厂方法创建UserService实例
     */
    public static UserService createUserService(UserRepository userRepository, 
                                               String serviceType) {
        String cacheKey = serviceType + "_" + userRepository.getClass().getSimpleName();
        
        return serviceCache.computeIfAbsent(cacheKey, key -> {
            System.out.println("通过静态工厂方法创建 UserService: " + serviceType);
            
            switch (serviceType) {
                case "standard":
                    return new StandardUserService(userRepository);
                case "premium":
                    return new PremiumUserService(userRepository);
                case "enterprise":
                    return new EnterpriseUserService(userRepository);
                default:
                    throw new IllegalArgumentException("不支持的服务类型: " + serviceType);
            }
        });
    }
    
    /**
     * 创建带缓存的UserService
     */
    public static UserService createCachedUserService(UserRepository userRepository) {
        System.out.println("创建带缓存的 UserService");
        UserService userService = new StandardUserService(userRepository);
        return new CachedUserServiceWrapper(userService);
    }
    
    /**
     * 清理工厂缓存
     */
    public static void clearCache() {
        serviceCache.clear();
        System.out.println("UserService 工厂缓存已清理");
    }
}

// 不同类型的UserService实现
public class StandardUserService implements UserService {
    private final UserRepository userRepository;
    
    public StandardUserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    @Override
    public User createUser(String name, String email) {
        return userRepository.save(new User(name, email));
    }
}

public class PremiumUserService implements UserService {
    private final UserRepository userRepository;
    
    public PremiumUserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    @Override
    public User createUser(String name, String email) {
        User user = new User(name, email);
        user.setPremium(true);
        return userRepository.save(user);
    }
}

// XML配置静态工厂方法
<bean id="userRepository" class="com.example.repository.UserRepositoryImpl"/>

<bean id="standardUserService" 
      class="com.example.factory.UserServiceFactory"
      factory-method="createUserService">
    <constructor-arg ref="userRepository"/>
    <constructor-arg value="standard"/>
</bean>

<bean id="premiumUserService"
      class="com.example.factory.UserServiceFactory"
      factory-method="createUserService">
    <constructor-arg ref="userRepository"/>
    <constructor-arg value="premium"/>
</bean>

<bean id="cachedUserService"
      class="com.example.factory.UserServiceFactory"
      factory-method="createCachedUserService">
    <constructor-arg ref="userRepository"/>
</bean>

// Java配置静态工厂方法
@Configuration
public class Config {
    
    @Bean
    public UserService standardUserService(UserRepository userRepository) {
        return UserServiceFactory.createUserService(userRepository, "standard");
    }
    
    @Bean
    public UserService premiumUserService(UserRepository userRepository) {
        return UserServiceFactory.createUserService(userRepository, "premium");
    }
    
    @Bean
    public UserService cachedUserService(UserRepository userRepository) {
        return UserServiceFactory.createCachedUserService(userRepository);
    }
}

实例工厂方法实例化

1. 实例工厂类

// 实例工厂类
@Component
public class UserServiceFactory {
    
    private final UserRepository userRepository;
    private final EmailService emailService;
    private final MetricsService metricsService;
    
    public UserServiceFactory(UserRepository userRepository,
                             EmailService emailService,
                             MetricsService metricsService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
        this.metricsService = metricsService;
        System.out.println("UserServiceFactory 实例创建完成");
    }
    
    /**
     * 实例工厂方法创建UserService
     */
    public UserService createUserService(String serviceLevel) {
        System.out.println("通过实例工厂方法创建 UserService: " + serviceLevel);
        
        UserService userService;
        switch (serviceLevel.toLowerCase()) {
            case "basic":
                userService = new BasicUserService(userRepository);
                break;
            case "standard":
                userService = new StandardUserService(userRepository, emailService);
                break;
            case "premium":
                userService = new PremiumUserService(userRepository, emailService, metricsService);
                break;
            default:
                throw new IllegalArgumentException("不支持的服务级别: " + serviceLevel);
        }
        
        // 工厂可以对创建的实例进行后处理
        configureUserService(userService, serviceLevel);
        return userService;
    }
    
    /**
     * 创建带监控的UserService
     */
    public UserService createMonitoredUserService() {
        UserService userService = new StandardUserService(userRepository, emailService);
        return new MonitoringUserServiceProxy(userService, metricsService);
    }
    
    /**
     * 创建集群环境下的UserService
     */
    public UserService createClusteredUserService(String nodeId) {
        UserService userService = new StandardUserService(userRepository, emailService);
        return new ClusteredUserServiceWrapper(userService, nodeId);
    }
    
    private void configureUserService(UserService userService, String serviceLevel) {
        // 根据服务级别进行配置
        if (userService instanceof ConfigurableUserService) {
            ConfigurableUserService configurable = (ConfigurableUserService) userService;
            configurable.setServiceLevel(serviceLevel);
            configurable.setMaxConcurrentUsers(getMaxConcurrentUsers(serviceLevel));
        }
    }
    
    private int getMaxConcurrentUsers(String serviceLevel) {
        switch (serviceLevel.toLowerCase()) {
            case "basic": return 100;
            case "standard": return 500;
            case "premium": return 1000;
            default: return 100;
        }
    }
}

// 可配置的UserService接口
public interface ConfigurableUserService extends UserService {
    void setServiceLevel(String serviceLevel);
    void setMaxConcurrentUsers(int maxUsers);
}

// XML配置实例工厂方法
<bean id="userServiceFactory" class="com.example.factory.UserServiceFactory">
    <constructor-arg ref="userRepository"/>
    <constructor-arg ref="emailService"/>
    <constructor-arg ref="metricsService"/>
</bean>

<bean id="basicUserService"
      factory-bean="userServiceFactory"
      factory-method="createUserService">
    <constructor-arg value="basic"/>
</bean>

<bean id="standardUserService"
      factory-bean="userServiceFactory"
      factory-method="createUserService">
    <constructor-arg value="standard"/>
</bean>

<bean id="monitoredUserService"
      factory-bean="userServiceFactory"
      factory-method="createMonitoredUserService"/>

// Java配置实例工厂方法
@Configuration
public class Config {
    
    @Bean
    public UserService basicUserService(UserServiceFactory factory) {
        return factory.createUserService("basic");
    }
    
    @Bean
    public UserService standardUserService(UserServiceFactory factory) {
        return factory.createUserService("standard");
    }
    
    @Bean
    public UserService monitoredUserService(UserServiceFactory factory) {
        return factory.createMonitoredUserService();
    }
    
    @Bean
    public UserService clusteredUserService(UserServiceFactory factory) {
        return factory.createClusteredUserService("node-1");
    }
}

FactoryBean实例化

1. 自定义FactoryBean

// 自定义FactoryBean实现
@Component
public class UserServiceFactoryBean implements FactoryBean<UserService> {
    
    private UserRepository userRepository;
    private EmailService emailService;
    private String serviceType = "standard";
    private boolean singleton = true;
    
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    @Autowired
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }
    
    public void setServiceType(String serviceType) {
        this.serviceType = serviceType;
    }
    
    public void setSingleton(boolean singleton) {
        this.singleton = singleton;
    }
    
    @Override
    public UserService getObject() throws Exception {
        System.out.println("FactoryBean 创建 UserService 实例: " + serviceType);
        
        // 根据配置创建不同类型的UserService
        UserService userService;
        switch (serviceType.toLowerCase()) {
            case "basic":
                userService = createBasicUserService();
                break;
            case "standard":
                userService = createStandardUserService();
                break;
            case "premium":
                userService = createPremiumUserService();
                break;
            case "enterprise":
                userService = createEnterpriseUserService();
                break;
            default:
                throw new IllegalArgumentException("不支持的服务类型: " + serviceType);
        }
        
        // FactoryBean可以对创建的对象进行后处理
        postProcessUserService(userService);
        
        return userService;
    }
    
    @Override
    public Class<?> getObjectType() {
        return UserService.class;
    }
    
    @Override
    public boolean isSingleton() {
        return singleton;
    }
    
    private UserService createBasicUserService() {
        return new BasicUserService(userRepository);
    }
    
    private UserService createStandardUserService() {
        StandardUserService service = new StandardUserService(userRepository);
        service.setEmailService(emailService);
        return service;
    }
    
    private UserService createPremiumUserService() {
        PremiumUserService service = new PremiumUserService(userRepository);
        service.setEmailService(emailService);
        service.enablePremiumFeatures();
        return service;
    }
    
    private UserService createEnterpriseUserService() {
        EnterpriseUserService service = new EnterpriseUserService(userRepository);
        service.setEmailService(emailService);
        service.enableEnterpriseFeatures();
        service.setupAuditLogging();
        return service;
    }
    
    private void postProcessUserService(UserService userService) {
        // 对创建的UserService进行后处理
        if (userService instanceof InitializingBean) {
            try {
                ((InitializingBean) userService).afterPropertiesSet();
            } catch (Exception e) {
                throw new RuntimeException("UserService 初始化失败", e);
            }
        }
        
        // 注册JMX监控
        registerJmxMonitoring(userService);
    }
    
    private void registerJmxMonitoring(UserService userService) {
        // JMX监控注册逻辑
        System.out.println("为 UserService 注册 JMX 监控");
    }
}

// XML配置FactoryBean
<bean id="userServiceFactory" class="com.example.factory.UserServiceFactoryBean">
    <property name="serviceType" value="premium"/>
    <property name="singleton" value="true"/>
</bean>

<!-- 获取FactoryBean创建的对象 -->
<bean id="userService" factory-bean="userServiceFactory"/>

<!-- 获取FactoryBean本身 -->
<bean id="userServiceFactoryBean" class="com.example.factory.UserServiceFactoryBean"/>

// Java配置FactoryBean
@Configuration
public class Config {
    
    @Bean
    public UserServiceFactoryBean userServiceFactory() {
        UserServiceFactoryBean factory = new UserServiceFactoryBean();
        factory.setServiceType("premium");
        factory.setSingleton(true);
        return factory;
    }
    
    // Spring会自动调用FactoryBean.getObject()
    @Bean
    public UserService userService(UserServiceFactoryBean factory) throws Exception {
        return factory.getObject();
    }
}

Bean作用域详解

Singleton作用域（默认）

1. Singleton特性

@Service
public class SingletonUserService {
    
    private int counter = 0;
    private final String instanceId = UUID.randomUUID().toString();
    
    public int incrementCounter() {
        return ++counter;
    }
    
    public String getInstanceId() {
        return instanceId;
    }
    
    public int getCounter() {
        return counter;
    }
}

// 测试Singleton行为
@Component
public class SingletonDemo {
    
    @Autowired
    private ApplicationContext applicationContext;
    
    @PostConstruct
    public void demonstrateSingleton() {
        // 多次获取Bean，都是同一个实例
        SingletonUserService service1 = applicationContext.getBean(SingletonUserService.class);
        SingletonUserService service2 = applicationContext.getBean(SingletonUserService.class);
        
        System.out.println("service1 == service2: " + (service1 == service2)); // true
        System.out.println("service1 实例ID: " + service1.getInstanceId());
        System.out.println("service2 实例ID: " + service2.getInstanceId()); // 相同ID
        
        // 状态共享
        System.out.println("service1 计数器: " + service1.incrementCounter()); // 1
        System.out.println("service2 计数器: " + service2.incrementCounter()); // 2
        System.out.println("service1 计数器: " + service1.getCounter());       // 2
    }
}

// XML配置Singleton（默认）
<bean id="userService" class="com.example.service.SingletonUserService"/>
<!-- 或显式指定 -->
<bean id="userService" class="com.example.service.SingletonUserService" scope="singleton"/>

// Java配置Singleton
@Configuration
public class Config {
    
    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON) // 默认可省略
    public SingletonUserService userService() {
        return new SingletonUserService();
    }
}

Prototype作用域

1. Prototype特性

@Service
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class PrototypeUserService {
    
    private int counter = 0;
    private final String instanceId = UUID.randomUUID().toString();
    private final long creationTime = System.currentTimeMillis();
    
    public PrototypeUserService() {
        System.out.println("创建 PrototypeUserService 实例: " + instanceId);
    }
    
    public int incrementCounter() {
        return ++counter;
    }
    
    public String getInstanceId() {
        return instanceId;
    }
    
    public long getCreationTime() {
        return creationTime;
    }
    
    public int getCounter() {
        return counter;
    }
}

// 测试Prototype行为
@Component
public class PrototypeDemo {
    
    @Autowired
    private ApplicationContext applicationContext;
    
    @PostConstruct
    public void demonstratePrototype() {
        // 每次获取Bean都是新实例
        PrototypeUserService service1 = applicationContext.getBean(PrototypeUserService.class);
        PrototypeUserService service2 = applicationContext.getBean(PrototypeUserService.class);
        
        System.out.println("service1 == service2: " + (service1 == service2)); // false
        System.out.println("service1 实例ID: " + service1.getInstanceId());
        System.out.println("service2 实例ID: " + service2.getInstanceId()); // 不同ID
        
        // 状态独立
        System.out.println("service1 计数器: " + service1.incrementCounter()); // 1
        System.out.println("service2 计数器: " + service2.incrementCounter()); // 1
        System.out.println("service1 计数器: " + service1.getCounter());       // 1
        
        // 创建时间不同
        System.out.println("创建时间差: " + (service2.getCreationTime() - service1.getCreationTime()) + "ms");
    }
}

// XML配置Prototype
<bean id="userService" class="com.example.service.PrototypeUserService" scope="prototype"/>

// Java配置Prototype
@Configuration
public class Config {
    
    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public PrototypeUserService userService() {
        return new PrototypeUserService();
    }
}

2. Prototype注入到Singleton的问题

// 问题：Prototype Bean注入到Singleton Bean中
@Service
public class SingletonService {
    
    @Autowired
    private PrototypeUserService prototypeService; // 只会注入一次！
    
    public void usePrototypeService() {
        System.out.println("使用 PrototypeService: " + prototypeService.getInstanceId());
        prototypeService.incrementCounter();
    }
}

// 解决方案1：使用ApplicationContext查找
@Service
public class SingletonService {
    
    @Autowired
    private ApplicationContext applicationContext;
    
    public void usePrototypeService() {
        // 每次都获取新的Prototype实例
        PrototypeUserService prototypeService = applicationContext.getBean(PrototypeUserService.class);
        System.out.println("使用 PrototypeService: " + prototypeService.getInstanceId());
        prototypeService.incrementCounter();
    }
}

// 解决方案2：使用@Lookup方法注入
@Service
public abstract class SingletonService {
    
    public void usePrototypeService() {
        PrototypeUserService prototypeService = getPrototypeService();
        System.out.println("使用 PrototypeService: " + prototypeService.getInstanceId());
        prototypeService.incrementCounter();
    }
    
    @Lookup
    protected abstract PrototypeUserService getPrototypeService();
}

// 解决方案3：使用Provider接口
@Service
public class SingletonService {
    
    @Autowired
    private Provider<PrototypeUserService> prototypeServiceProvider;
    
    public void usePrototypeService() {
        // 每次调用get()都获取新实例
        PrototypeUserService prototypeService = prototypeServiceProvider.get();
        System.out.println("使用 PrototypeService: " + prototypeService.getInstanceId());
        prototypeService.incrementCounter();
    }
}

Web作用域

1. Request作用域

// Request作用域Bean：每个HTTP请求一个实例
@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestScopedBean {
    
    private final String requestId = UUID.randomUUID().toString();
    private final long requestStartTime = System.currentTimeMillis();
    private final Map<String, Object> requestData = new HashMap<>();
    
    public RequestScopedBean() {
        System.out.println("创建 RequestScopedBean: " + requestId);
    }
    
    public void addData(String key, Object value) {
        requestData.put(key, value);
    }
    
    public Object getData(String key) {
        return requestData.get(key);
    }
    
    public String getRequestId() {
        return requestId;
    }
    
    public long getRequestDuration() {
        return System.currentTimeMillis() - requestStartTime;
    }
    
    public Map<String, Object> getAllData() {
        return new HashMap<>(requestData);
    }
}

// 使用Request作用域Bean
@RestController
@RequestMapping("/api/request-demo")
public class RequestScopeController {
    
    @Autowired
    private RequestScopedBean requestBean;
    
    @GetMapping("/info")
    public Map<String, Object> getRequestInfo() {
        requestBean.addData("endpoint", "/api/request-demo/info");
        requestBean.addData("timestamp", System.currentTimeMillis());
        
        Map<String, Object> response = new HashMap<>();
        response.put("requestId", requestBean.getRequestId());
        response.put("duration", requestBean.getRequestDuration());
        response.put("data", requestBean.getAllData());
        
        return response;
    }
    
    @PostMapping("/data")
    public Map<String, Object> addData(@RequestBody Map<String, Object> data) {
        data.forEach(requestBean::addData);
        
        Map<String, Object> response = new HashMap<>();
        response.put("requestId", requestBean.getRequestId());
        response.put("allData", requestBean.getAllData());
        
        return response;
    }
}

// XML配置Request作用域
<bean id="requestBean" class="com.example.RequestScopedBean" scope="request">
    <aop:scoped-proxy/>
</bean>

2. Session作用域

// Session作用域Bean：每个HTTP会话一个实例
@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class SessionScopedBean {
    
    private final String sessionId = UUID.randomUUID().toString();
    private final long sessionStartTime = System.currentTimeMillis();
    private final Map<String, Object> sessionData = new ConcurrentHashMap<>();
    private int requestCount = 0;
    
    public SessionScopedBean() {
        System.out.println("创建 SessionScopedBean: " + sessionId);
    }
    
    public synchronized void incrementRequestCount() {
        requestCount++;
    }
    
    public void putData(String key, Object value) {
        sessionData.put(key, value);
    }
    
    public Object getData(String key) {
        return sessionData.get(key);
    }
    
    public String getSessionId() {
        return sessionId;
    }
    
    public long getSessionDuration() {
        return System.currentTimeMillis() - sessionStartTime;
    }
    
    public int getRequestCount() {
        return requestCount;
    }
    
    public Map<String, Object> getAllData() {
        return new HashMap<>(sessionData);
    }
}

// 使用Session作用域Bean
@RestController
@RequestMapping("/api/session-demo")
public class SessionScopeController {
    
    @Autowired
    private SessionScopedBean sessionBean;
    
    @GetMapping("/info")
    public Map<String, Object> getSessionInfo() {
        sessionBean.incrementRequestCount();
        
        Map<String, Object> response = new HashMap<>();
        response.put("sessionId", sessionBean.getSessionId());
        response.put("duration", sessionBean.getSessionDuration());
        response.put("requestCount", sessionBean.getRequestCount());
        response.put("data", sessionBean.getAllData());
        
        return response;
    }
    
    @PostMapping("/preferences")
    public Map<String, Object> setPreferences(@RequestBody Map<String, Object> preferences) {
        sessionBean.incrementRequestCount();
        preferences.forEach(sessionBean::putData);
        
        Map<String, Object> response = new HashMap<>();
        response.put("sessionId", sessionBean.getSessionId());
        response.put("preferences", sessionBean.getAllData());
        
        return response;
    }
}

3. Application作用域

// Application作用域Bean：整个Web应用一个实例
@Component
@Scope(value = WebApplicationContext.SCOPE_APPLICATION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ApplicationScopedBean {
    
    private final String applicationId = UUID.randomUUID().toString();
    private final long applicationStartTime = System.currentTimeMillis();
    private final AtomicLong totalRequests = new AtomicLong(0);
    private final AtomicLong totalSessions = new AtomicLong(0);
    private final Map<String, Object> applicationData = new ConcurrentHashMap<>();
    
    public ApplicationScopedBean() {
        System.out.println("创建 ApplicationScopedBean: " + applicationId);
        initializeApplicationData();
    }
    
    private void initializeApplicationData() {
        applicationData.put("version", "1.0.0");
        applicationData.put("startTime", applicationStartTime);
        applicationData.put("environment", System.getProperty("spring.profiles.active", "default"));
    }
    
    public void incrementRequestCount() {
        totalRequests.incrementAndGet();
    }
    
    public void incrementSessionCount() {
        totalSessions.incrementAndGet();
    }
    
    public void putData(String key, Object value) {
        applicationData.put(key, value);
    }
    
    public Object getData(String key) {
        return applicationData.get(key);
    }
    
    public String getApplicationId() {
        return applicationId;
    }
    
    public long getUptime() {
        return System.currentTimeMillis() - applicationStartTime;
    }
    
    public long getTotalRequests() {
        return totalRequests.get();
    }
    
    public long getTotalSessions() {
        return totalSessions.get();
    }
    
    public Map<String, Object> getAllData() {
        Map<String, Object> data = new HashMap<>(applicationData);
        data.put("totalRequests", getTotalRequests());
        data.put("totalSessions", getTotalSessions());
        data.put("uptime", getUptime());
        return data;
    }
}

// 使用Application作用域Bean
@RestController
@RequestMapping("/api/app-stats")
public class ApplicationStatsController {
    
    @Autowired
    private ApplicationScopedBean appBean;
    
    @Autowired
    private SessionScopedBean sessionBean;
    
    @GetMapping("/info")
    public Map<String, Object> getApplicationInfo() {
        appBean.incrementRequestCount();
        
        return appBean.getAllData();
    }
    
    @PostMapping("/config")
    public Map<String, Object> updateConfig(@RequestBody Map<String, Object> config) {
        appBean.incrementRequestCount();
        config.forEach(appBean::putData);
        
        return appBean.getAllData();
    }
}

自定义作用域

1. 实现自定义作用域

// 自定义线程作用域
public class ThreadScope implements Scope {
    
    private static final String THREAD_SCOPE_NAME = "thread";
    private final ThreadLocal<Map<String, Object>> threadLocal = new ThreadLocal<Map<String, Object>>() {
        @Override
        protected Map<String, Object> initialValue() {
            return new HashMap<>();
        }
    };
    
    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Map<String, Object> scope = threadLocal.get();
        Object obj = scope.get(name);
        
        if (obj == null) {
            obj = objectFactory.getObject();
            scope.put(name, obj);
            System.out.println("创建线程作用域Bean: " + name + " in thread: " + Thread.currentThread().getName());
        }
        
        return obj;
    }
    
    @Override
    public Object remove(String name) {
        Map<String, Object> scope = threadLocal.get();
        return scope.remove(name);
    }
    
    @Override
    public void registerDestructionCallback(String name, Runnable callback) {
        // 线程结束时的清理回调
        // 这里可以注册线程结束时的清理逻辑
    }
    
    @Override
    public Object resolveContextualObject(String key) {
        return null;
    }
    
    @Override
    public String getConversationId() {
        return Thread.currentThread().getName();
    }
    
    public void clearScope() {
        threadLocal.remove();
    }
}

// 注册自定义作用域
@Configuration
public class CustomScopeConfig implements BeanFactoryPostProcessor {
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        beanFactory.registerScope("thread", new ThreadScope());
        System.out.println("注册自定义线程作用域");
    }
}

// 使用自定义作用域
@Component
@Scope("thread")
public class ThreadScopedService {
    
    private final String threadId = Thread.currentThread().getName();
    private final long creationTime = System.currentTimeMillis();
    private int operationCount = 0;
    
    public ThreadScopedService() {
        System.out.println("创建 ThreadScopedService in thread: " + threadId);
    }
    
    public void performOperation() {
        operationCount++;
        System.out.println("线程 " + threadId + " 执行操作 " + operationCount);
    }
    
    public String getThreadId() {
        return threadId;
    }
    
    public int getOperationCount() {
        return operationCount;
    }
    
    public long getCreationTime() {
        return creationTime;
    }
}

// 测试自定义作用域
@Component
public class ThreadScopeDemo {
    
    @Autowired
    private ApplicationContext applicationContext;
    
    @PostConstruct
    public void demonstrateThreadScope() throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executor.submit(() -> {
                ThreadScopedService service = applicationContext.getBean(ThreadScopedService.class);
                service.performOperation();
                service.performOperation();
                
                System.out.println("Task " + taskId + " - Service thread: " + service.getThreadId() + 
                                 ", operations: " + service.getOperationCount());
            });
        }
        
        executor.shutdown();
        executor.awaitTermination(10, TimeUnit.SECONDS);
    }
}

Bean生命周期

完整生命周期流程

1. 生命周期演示Bean

@Component
public class LifecycleDemoBean implements BeanNameAware, BeanFactoryAware, 
                                        ApplicationContextAware, EnvironmentAware,
                                        InitializingBean, DisposableBean {
    
    private String beanName;
    private BeanFactory beanFactory;
    private ApplicationContext applicationContext;
    private Environment environment;
    
    // 1. 构造器
    public LifecycleDemoBean() {
        System.out.println("1. 构造器：创建Bean实例");
    }
    
    // 2. 属性注入
    @Autowired
    public void setUserService(UserService userService) {
        System.out.println("2. 属性注入：注入依赖对象");
    }
    
    @Value("${app.name:DefaultApp}")
    public void setAppName(String appName) {
        System.out.println("2. 属性注入：注入配置值 - " + appName);
    }
    
    // 3. Aware接口回调
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("3. BeanNameAware：设置Bean名称 - " + name);
    }
    
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        System.out.println("4. BeanFactoryAware：设置BeanFactory");
    }
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
        System.out.println("5. ApplicationContextAware：设置ApplicationContext");
    }
    
    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
        System.out.println("6. EnvironmentAware：设置Environment");
    }
    
    // 4. BeanPostProcessor前置处理（在自定义BeanPostProcessor中实现）
    
    // 5. 初始化方法
    @PostConstruct
    public void postConstruct() {
        System.out.println("7. @PostConstruct：初始化注解方法");
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("8. InitializingBean：afterPropertiesSet方法");
    }
    
    // 6. 自定义初始化方法
    public void customInit() {
        System.out.println("9. 自定义初始化方法：customInit");
    }
    
    // 7. BeanPostProcessor后置处理（在自定义BeanPostProcessor中实现）
    
    // Bean就绪，可以使用
    public void doWork() {
        System.out.println("10. Bean工作中：执行业务逻辑");
    }
    
    // 8. 销毁前方法
    @PreDestroy
    public void preDestroy() {
        System.out.println("11. @PreDestroy：销毁前注解方法");
    }
    
    @Override
    public void destroy() throws Exception {
        System.out.println("12. DisposableBean：destroy方法");
    }
    
    // 9. 自定义销毁方法
    public void customDestroy() {
        System.out.println("13. 自定义销毁方法：customDestroy");
    }
    
    // Getter方法
    public String getBeanName() { return beanName; }
    public BeanFactory getBeanFactory() { return beanFactory; }
    public ApplicationContext getApplicationContext() { return applicationContext; }
    public Environment getEnvironment() { return environment; }
}