feat: Enhance component management in ApplicationContext

[NFUChen]

Add Support for Qualifiers and Component Registration Validation

Changes Overview

This PR introduces two major features to enhance component management in PySpring:

1. Qualifier Support

   • Added support for qualifiers in dependency injection
   • Implemented handling of Annotated types for qualifier-based injection
   • Enhanced error messages to include qualifier information

2. Component Registration Validation

   • Added validation to prevent duplicate component registration
   • Enhanced error handling with clear feedback for developers
   • Improved component registration robustness

Key Changes

Component Class Enhancements

• Added name configuration option to Component.Config
• Enhanced get_name() to support custom component names

Application Context Improvements

• Simplified component registration process
• Added _determine_target_cls_name() to handle component resolution logic
• Enhanced dependency injection to support qualifiers
• Improved error handling for component initialization
• Added duplicate component registration prevention

Dependency Injection Updates

• Modified get_component() and get_bean() to accept qualifier parameter
• Enhanced type hints for entity getters
• Improved error messages with qualifier information

Other Changes

• Removed type checking service as it's no longer needed
• Added better error handling for component initialization

Example Usage

1. Using Qualifiers for Dependency Injection

from typing import Annotated
from py_spring_core import Component

class ServiceConsumer(Component):
    # Will inject the specifically qualified implementation
    service_a: Annotated[AbstractService, "ServiceA"]
    service_b: Annotated[AbstractService, "ServiceB"]

    def post_construct(self) -> None:
        print(self.service_a.process())  # Uses ServiceA
        print(self.service_b.process())  # Uses ServiceB

2. Complete Working Example

from abc import ABC, abstractmethod
from typing import Annotated
from py_spring_core import Component
from py_spring_core.core.entities.component import ComponentScope

# Abstract base class
class AbstractExample(Component, ABC):
    class Config:
        scope = ComponentScope.Singleton

    @abstractmethod
    def say_hello(self) -> str: ...

# First implementation
class ExampleA(AbstractExample):
    class Config:
        name = "ExampleA"
        scope = ComponentScope.Singleton

    def say_hello(self) -> str:
        return "Hello from Example A!"

# Second implementation
class ExampleB(AbstractExample):
    class Config:
        name = "ExampleB"
        scope = ComponentScope.Singleton

    def say_hello(self) -> str:
        return "Hello from Example B!"

# Service using both implementations
class TestService(Component):
    # Will inject the specifically qualified implementations
    example_a: Annotated[AbstractExample, "ExampleA"]
    example_b: Annotated[AbstractExample, "ExampleB"]

    def post_construct(self) -> None:
        print(self.example_a.say_hello())  # Output: "Hello from Example A!"
        print(self.example_b.say_hello())  # Output: "Hello from Example B!"

3. Duplicate Registration Prevention Example

from py_spring_core import Component
from py_spring_core.core.entities.component import ComponentScope

# First registration of MyService
class MyService(Component):
    class Config:
        name = "MyService"
        scope = ComponentScope.Singleton

    def do_something(self) -> str:
        return "Service is working!"

# Attempting to register the same component again will raise ValueError
try:
    class MyService(Component):  # This will raise ValueError
        class Config:
            name = "MyService"
            scope = ComponentScope.Singleton

        def do_something(self) -> str:
            return "This will never be registered!"
except ValueError as e:
    print(f"Error: {e}")  # Output: "Error: [COMPONENT REGISTRATION ERROR] Component: MyService already registered"

Key Points to Remember:

1. Use Annotated[Type, "QualifierName"] to inject specific implementations
2. The name in Config can be used to override the default class name
3. All components must have a valid implementation of the abstract methods
4. Components can only be registered once with the same name

Testing

Please test the following scenarios:

1. Dependency injection with qualifiers
2. Error cases for duplicate component registration
3. Abstract class initialization handling

Breaking Changes

• get_component() and get_bean() now require a qualifier parameter (can be None)
• Type checking service has been removed
• Primary component validation has been removed