alibaba/BeeHiveArchived
4,339 نجوم·780 تفرعات·Objective-C·GPL-2.0·2 مشاهداتgithub.com/alibaba/BeeHive/blob/master/README.md↗
BeeHive
BeeHive is a modular architecture framework for iOS applications. It provides a dependency injection container, an event bus middleware, a module lifecycle manager, and a service locator to organize an application into independent functional modules.
The framework distinguishes itself by utilizing asynchronous module loading to reduce application startup time and prevent main thread blocking. It employs macro-driven automatic module registration to decouple instantiation from application logic and uses protocol-based service mapping to resolve dependencies without requiring direct imports.
The project covers high-level capabilities for inter-module communication and event orchestration, allowing for the broadcasting of custom business triggers across isolated units. It also includes infrastructure for global application state distribution and the coordination of initialization and teardown sequences across the module lifecycle.
Features
- iOS Application Architectures - Organizes large iOS applications into independent functional modules to improve maintainability and reduce coupling.
- Typed Event Broadcasts - Defines and broadcasts application-specific typed events to notify registered modules of business triggers.
- System Event Routing - Broadcasts system and custom events to multiple isolated modules to prevent tight coupling.
- Concrete Type Mappings - Maps abstract protocols to concrete class implementations to resolve dependencies without direct module imports.
- Component Lifecycle Coordination - Coordinates standardized startup and teardown sequences across decoupled modules to synchronize application state.
- Dependency Injection Containers - Provides a centralized container for registering and resolving service protocols to decouple components.
- Event Bus Systems - Implements a communication layer for broadcasting events across isolated modules using a decoupled bus.
- Interface-Based Isolation - Organizes functionality into independent units that communicate through defined interfaces to separate implementation from service calls.
- Dependency Injection - Manages the registration and invocation of service interfaces to eliminate direct dependencies between components.
- Module Lifecycle Management - Provides a coordinator for managing the initialization and teardown of independent functional modules.
- Inter-Module Communication - Provides a central event bus to route system and custom events between isolated functional modules.
- Interface-Based Service Swapping - Maps protocols to concrete implementations to enable dynamic service resolution and component swapping.
- Service Instance Managers - Retrieves service instances by protocol using singleton patterns or multiple instance creation.
- Service Locators - Implements a service locator pattern to map protocols to concrete implementations for dynamic service resolution.
- Service-to-Application Mappings - Maps protocols to specific class implementations to allow dynamic service resolution.
- Global Application State - Stores and distributes environment variables and application-wide configuration data across all registered modules.
- Module Lifecycle Events - Broadcasts system-wide events that notify modules of state changes throughout their operational lifecycle.
- App Launch Optimizations - Loads app modules asynchronously to reduce launch time and prevent main thread blocking.
- Asynchronous Module Loading - Loads app modules asynchronously in the background to reduce launch time and prevent the main thread from blocking.
- Automatic Module Registrations - Uses compiler macros to automatically discover and register functional units during the build process.
- Singleton Instance Sharing - Ensures shared service instances are retrieved via a central registry to maintain consistent state.
- Module Initialization Coordination - Coordinates specific actions during application and module initialization phases to decouple setup logic.
- Macro-Based Registrations - Uses compiler macros to automatically discover and register functional modules during the build process.
