// 使用注解配置
@Component
@Scope("singleton")  // 或省略，默認(rèn)就是singleton
public class UserService {
    // 業(yè)務(wù)邏輯
}
// 使用XML配置
<bean id="userService" class="com.example.UserService" scope="singleton"/>

@Service
public class CacheManager {
    private final Map<String, Object> cache = new ConcurrentHashMap<>();
    // 這個場景適合singleton，因?yàn)榫彺嫘枰止蚕?
}

@Component
@Scope("prototype")
public class ShoppingCart {
    private List<Item> items = new ArrayList<>();
    public void addItem(Item item) {
        items.add(item);
    }
}
// XML配置
<bean id="shoppingCart" class="com.example.ShoppingCart" scope="prototype"/>

@Component
@Scope("prototype")
public class ReportGenerator {
    private ReportData data;
    private ReportFormat format;
    // 每個報表生成都需要獨(dú)立的實(shí)例
    public Report generate() {
        // 生成報表邏輯
    }
}

@Component
@Scope("prototype")
public class ResourceHolder implements DisposableBean {
    private ExpensiveResource resource;
    public ResourceHolder() {
        this.resource = new ExpensiveResource();
    }
    @Override
    public void destroy() {
        // 需要客戶端手動調(diào)用，Spring不會自動調(diào)用
        resource.close();
    }
}

@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestContext {
    private String requestId;
    private Long userId;
    public RequestContext() {
        this.requestId = UUID.randomUUID().toString();
    }
}
// XML配置
<bean id="requestContext" class="com.example.RequestContext" scope="request"/>

<!-- web.xml配置 -->
<web-app>
    <!-- 方式1：使用監(jiān)聽器 -->
    <listener>
        <listener-class>
            org.springframework.web.context.request.RequestContextListener
        </listener-class>
    </listener>
    <!-- 方式2：使用過濾器 -->
    <filter>
        <filter-name>requestContextFilter</filter-name>
        <filter-class>
            org.springframework.web.filter.RequestContextFilter
        </filter-class>
    </filter>
    <filter-mapping>
        <filter-name>requestContextFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class UserSession {
    private String sessionId;
    private UserInfo userInfo;
    private LocalDateTime loginTime;
    private List<String> permissions;
    // 會話管理方法
    public boolean isValid() {
        return userInfo != null;
    }
}

@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ShoppingCart implements HttpSessionBindingListener {
    private List<Product> products = new ArrayList<>();
    @Override
    public void valueBound(HttpSessionBindingEvent event) {
        log.info("購物車已綁定到會話: {}", event.getSession().getId());
    }
    @Override
    public void valueUnbound(HttpSessionBindingEvent event) {
        log.info("會話過期，清理購物車數(shù)據(jù)");
        products.clear();
    }
}

@Component
@Scope(WebApplicationContext.SCOPE_APPLICATION)
public class ApplicationConfig {
    private Properties appProperties;
    private Map<String, String> systemConfig;
    @PostConstruct
    public void init() {
        // 加載應(yīng)用級配置
        loadConfiguration();
    }
}

@Component
@Scope(scopeName = "websocket")
public class WebSocketSessionHandler {
    private String sessionId;
    private WebSocketSession session;
    private Queue<Message> messageQueue = new ConcurrentLinkedQueue<>();
    // WebSocket消息處理
    public void handleMessage(Message message) {
        messageQueue.offer(message);
    }
}

// 正確配置：使用CGLIB代理
@Component
@Scope(value = "session", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class UserPreferences {
    private String theme;
    private String language;
}
// 在單例Bean中安全注入
@Service
public class UserService {
    // Spring會注入一個代理對象，每次調(diào)用時獲取當(dāng)前會話的真實(shí)實(shí)例
    @Autowired
    private UserPreferences userPreferences;
}

@Service  // 單例
public class OrderService {
    @Autowired
    private ShoppingCart cart;  // 原型，但實(shí)際只會初始化一次！
    public void processOrder() {
        // 問題：所有訂單共享同一個購物車
    }
}

@Service
public class OrderService {
    @Autowired
    private ObjectProvider<ShoppingCart> cartProvider;
    public void processOrder() {
        ShoppingCart cart = cartProvider.getObject();  // 每次獲取新實(shí)例
        // 處理訂單邏輯
    }
}

@Service
public abstract class OrderService {
    public void processOrder() {
        ShoppingCart cart = createShoppingCart();
        // 處理訂單邏輯
    }
    @Lookup
    protected abstract ShoppingCart createShoppingCart();
}

@Service
public class OrderService implements ApplicationContextAware {
    private ApplicationContext context;
    @Override
    public void setApplicationContext(ApplicationContext context) {
        this.context = context;
    }
    public void processOrder() {
        ShoppingCart cart = context.getBean(ShoppingCart.class);
        // 處理訂單邏輯
    }
}

@Component
@Scope("singleton")
public class StatelessService {
    // 無狀態(tài)服務(wù)，天然線程安全
    public Result calculate(Input input) {
        return new Result(input.value * 2);
    }
}
@Component
@Scope("prototype")
public class StatefulProcessor {
    private ThreadLocal<State> threadState = new ThreadLocal<>();
    public void process() {
        State state = threadState.get();
        if (state == null) {
            state = new State();
            threadState.set(state);
        }
        // 使用線程局部狀態(tài)
    }
}

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();
        Object object = scope.get(name);
        if (object == null) {
            object = objectFactory.getObject();
            scope.put(name, object);
        }
        return object;
    }
    @Override
    public Object remove(String name) {
        Map<String, Object> scope = threadLocal.get();
        return scope.remove(name);
    }
    @Override
    public void registerDestructionCallback(String name, Runnable callback) {
        // 線程結(jié)束時清理
    }
    @Override
    public Object resolveContextualObject(String key) {
        return null;
    }
    @Override
    public String getConversationId() {
        return String.valueOf(Thread.currentThread().getId());
    }
}

@Configuration
public class ScopeConfig implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 注冊自定義作用域
        beanFactory.registerScope("thread", new ThreadScope());
    }
}
// 使用自定義作用域
@Component
@Scope("thread")
public class ThreadLocalCache {
    private Map<String, Object> cache = new HashMap<>();
    public void put(String key, Object value) {
        cache.put(key, value);
    }
}

// 案例1：用戶認(rèn)證服務(wù) - 無狀態(tài)，適合singleton
@Service  // 默認(rèn)singleton
public class AuthService {
    public boolean authenticate(String username, String password) {
        // 認(rèn)證邏輯，無狀態(tài)
    }
}
// 案例2：報表生成器 - 每次生成需要獨(dú)立狀態(tài)，適合prototype
@Component
@Scope("prototype")
public class ReportGenerator {
    private ReportData data;
    private ReportFormat format;
    public Report generate() {
        // 生成報表
    }
}
// 案例3：購物車 - 用戶會話級別，適合session
@Component
@Scope(value = "session", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ShoppingCart {
    private List<Item> items = new ArrayList<>();
    public void addItem(Item item) {
        items.add(item);
    }
}

@Component
@Scope(
    value = WebApplicationContext.SCOPE_REQUEST, 
    proxyMode = ScopedProxyMode.TARGET_CLASS
)
@ConditionalOnWebApplication
public class RequestScopedBean {
    // 僅在Web環(huán)境生效
}

public interface UserPreferences {
    String getTheme();
    void setTheme(String theme);
}
@Component
@Scope(
    value = "session", 
    proxyMode = ScopedProxyMode.INTERFACES  // 使用接口代理
)
public class UserPreferencesImpl implements UserPreferences, Serializable {
    private String theme;
    @Override
    public String getTheme() {
        return theme;
    }
    @Override
    public void setTheme(String theme) {
        this.theme = theme;
    }
}

@Configuration
public class ScopeMonitoringConfig {
    @Bean
    public static BeanFactoryPostProcessor scopeMonitor() {
        return beanFactory -> {
            if (beanFactory instanceof ConfigurableListableBeanFactory) {
                ConfigurableListableBeanFactory configurableFactory = 
                    (ConfigurableListableBeanFactory) beanFactory;
                // 監(jiān)控Bean創(chuàng)建
                configurableFactory.addBeanPostProcessor(new BeanPostProcessor() {
                    @Override
                    public Object postProcessAfterInitialization(Object bean, String beanName) {
                        Scope scope = configurableFactory.getRegisteredScope(
                            configurableFactory.getBeanDefinition(beanName).getScope()
                        );
                        if (scope != null) {
                            log.info("Bean '{}' created with scope: {}", 
                                     beanName, scope.getClass().getSimpleName());
                        }
                        return bean;
                    }
                });
            }
        };
    }
}