// 傳統(tǒng)方式：主動創(chuàng)建依賴
UserService service = new UserServiceImpl();


// IoC方式：容器注入依賴
public class UserController {
    @Autowired // DI發(fā)生在這里
    private UserService userService;
}

// 三級緩存定義
public class DefaultSingletonBeanRegistry {
    // 一級緩存：完整Bean
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);


    // 二級緩存：早期暴露對象（未填充屬性）
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);


    // 三級緩存：對象工廠（可生成代理）
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
}

@Configuration
public class DataSourceConfig {


    @Bean
    @Conditional(ProdEnvCondition.class)
    public DataSource prodDataSource() {
        return new HikariDataSource(); // 生產(chǎn)環(huán)境數(shù)據(jù)源
    }


    @Bean
    @Conditional(DevEnvCondition.class)
    public DataSource devDataSource() {
        return new EmbeddedDatabaseBuilder().build(); // 開發(fā)環(huán)境數(shù)據(jù)源
    }
}


// 自定義條件
public class ProdEnvCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return "prod".equals(context.getEnvironment().getProperty("env"));
    }
}

public class ThreadScope implements Scope {
    private final ThreadLocal<Map<String, Object>> threadLocal = 
        ThreadLocal.withInitial(HashMap::new);


    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Map<String, Object> scope = threadLocal.get();
        return scope.computeIfAbsent(name, k -> objectFactory.getObject());
    }


    // 其他方法：remove、registerDestructionCallback等
}


// 注冊自定義作用域
context.getBeanFactory().registerScope("thread", new ThreadScope());

@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }
}

public interface BeanDefinition {
    // Bean類名
    void setBeanClassName(String beanClassName);


    // 作用域
    void setScope(String scope);


    // 是否懶加載
    void setLazyInit(boolean lazyInit);


    // 依賴的Bean
    void setDependsOn(String... dependsOn);


    // 初始化方法
    void setInitMethodName(String initMethodName);


    // 是否單例
    boolean isSingleton();


    // 是否原型
    boolean isPrototype();


    // 是否抽象
    boolean isAbstract();
}

@Service
public class OrderService {
    private final PaymentService paymentService;


    @Autowired // 構(gòu)造器注入（Spring4.3+可省略）
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

@Service
public class UserService {
    private UserDao userDao;


    @Autowired
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

@Service
public class ProductService {
    @Autowired // 字段注入（不推薦）
    private ProductDao productDao;
}

public class DefaultSingletonBeanRegistry {
    // 單例對象鎖
    private final Map<String, Object> singletonMutexes = new ConcurrentHashMap<>(16);


    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // 第一重檢查：一級緩存
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            synchronized (this.singletonObjects) {
                // 第二重檢查：二級緩存
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    // 第三重檢查：三級緩存
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }
}

@Configuration
public class ParallelConfig {
    @Bean
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(Runtime.getRuntime().availableProcessors());
        return executor;
    }


    @Bean
    public ApplicationRunner parallelInitRunner(ConfigurableApplicationContext context) {
        return args -> {
            // 并行初始化Bean
            context.getBeanFactory().getBeanNamesIterator()
                .forEachRemaining(beanName -> {
                    if (!context.getBeanFactory().containsSingleton(beanName)) {
                        CompletableFuture.runAsync(() -> 
                            context.getBean(beanName), taskExecutor());
                    }
                });
        };
    }
}