hyperf/hyperf

Features

• High-Performance HTTP Servers - Provides a high-performance coroutine-based server optimized for low-latency, high-throughput microservice delivery.
• PHP Coroutine Runtimes - Provides a high-performance PHP runtime that leverages coroutines to handle high concurrency and low-latency request processing.
• PHP Implementations - Implements a high-performance PHP framework utilizing non-blocking coroutines to handle high concurrency and low-latency requests.
• Web API Frameworks - Provides a comprehensive framework for building structured HTTP-based interfaces for web services.
• Microservices - Implements microservice governance patterns including circuit breakers, service discovery, and distributed tracing.
• Database ORMs - Provides a comprehensive ORM supporting UUIDs, ULIDs, soft deletes, and dynamic relation resolution.
• Object-Relational Mappers - Hyperf binds database tables to objects with support for soft deletes and attribute casting.
• Object-Relational Mapping Models - Maps database tables to objects with support for custom casting, morph relations, and macroable behaviors.
• Distributed Task Schedulers - Provides a distributed task scheduler for managing recurring jobs across multiple servers with precision timing.
• Coroutine-Compatible Clients - Connects to databases and message brokers using non-blocking coroutine clients for MySQL, Redis, and AMQP.
• Distributed Service Connectivity - Provides coroutine-compatible connectivity to databases, caches, service discovery tools, and RPC protocols.
• WebSocket Servers - Implements a WebSocket server managing bidirectional communication using connection-level contexts and direct file descriptors.
• Coroutine Channels - Implements coroutine channels to enable safe and efficient data exchange between concurrent execution flows.
• gRPC Interfaces - Integrates gRPC communication using clients that support lazy initialization and automatic reconnection.
• JSON-RPC Implementations - Provides full server and client implementations for JSON-RPC communication with custom data normalizers.
• Message Brokers - Facilitates asynchronous communication via a variety of message brokers including AMQP, NSQ, and NATS.
• RPC Servers - Provides high-performance servers for gRPC and JSON-RPC communication with built-in load balancing and health monitoring.
• Service Discovery Integrations - Provides deep integration with Nacos for service discovery, configuration management, and heartbeat monitoring.
• Circuit Breakers - Implements circuit breaker patterns to isolate failing services and prevent cascading failures in microservices.
• Execution Synchronization - Provides synchronization primitives to pause execution until a group of concurrent tasks completes.
• Aspect-Oriented Programming Frameworks - Employs aspect-oriented programming to create pluggable components and meta-programming without altering core logic.
• Asynchronous Task Queues - Processes background jobs via asynchronous queues with automatic channel reloading for failed tasks.
• Concurrent Task Execution - Executes multiple tasks concurrently using non-blocking coroutines to increase system throughput.
• Coroutine Servers - Executes applications via a high-performance coroutine server to achieve massive concurrency and low latency.
• Distributed Task Queues - Implements a distributed background job system for managing asynchronous queues and recurring tasks with mutex support.
• Dependency Injection - Features a robust dependency injection system supporting lazy loading and optional requirements for decoupling components.
• Resiliency & Observability Patterns - Provides a comprehensive toolkit for microservice governance including circuit breakers, service discovery, and distributed tracing.
• Microservices Orchestration Frameworks - Includes an orchestration toolkit for managing service discovery, circuit breakers, and distributed tracing in microservice architectures.
• Pluggable Components - Provides an AOP-based dependency injector that enables the creation of pluggable and meta-programmable components.
• Automatic Service Registrations - Implements automatic registration and deregistration of service instances with discovery providers, including health checks.
• gRPC Service Implementations - Implements gRPC clients with built-in load balancing and health monitoring across multiple endpoints.
• HTTP Request Handling - Provides built-in HTTP request routing via controllers and middleware supporting all standard methods.
• HTTP Request Handlers - Directs incoming HTTP traffic to specific controllers with support for parameter injection and multiple formats.
• Custom Middleware Development - Implements a modular request interceptor system for handling cross-cutting concerns and shared logic.
• Request Mappings - Maps incoming requests to controllers, annotations, or anonymous functions for HTTP and gRPC servers.
• Coroutine Frameworks - Implements a high-throughput web framework using non-blocking coroutines and automated OpenAPI documentation.
• Concurrency Primitives - Ships barriers and mutexes to synchronize asynchronous operations and ensure predictable execution flows.
• Connection Pooling - Implements connection pooling to reuse database and cache connections, reducing handshake overhead and improving performance.
• ORM Model Caching - Implements a coroutine-optimized ORM with integrated model caching to improve data retrieval performance.
• Request Data Integrity - Enforces data integrity using unique model checks, list validation, and scene-based rule rewriting for requests.
• Kafka Connectors - Provides Kafka connectors to subscribe to multiple topics for real-time processing and analysis of streaming data.
• Database Caching Middleware - Implements a coroutine-optimized ORM with integrated model caching to avoid repetitive database lookups.
• Table Schemas - Includes a fluent API for creating, modifying, and dropping database tables and indexes.
• Database Record Querying - Includes a fluent query builder for retrieving and manipulating database records using raw SQL and JSON operations.
• Schema Definitions - Provides a blueprint API for programmatically defining database table structures, columns, and constraints.
• Database Transaction Management - Controls database transactions automatically using annotations to ensure atomic operations.
• In-Memory Caches - Provides general data caching using in-memory or external backends to reduce data retrieval time.
• Kafka Client Integrations - Integrates Kafka client libraries to produce messages with support for sticky assignors and retry configurations.
• Schema Migration Tools - Automatically generates versioned database schema migration scripts by analyzing existing database structures.
• Schema Migration Utilities - Supports defining table structures and adding descriptive column comments during the schema migration process.
• Background Task Schedulers - Provides a crontab system for executing background tasks on a fixed timetable with lifecycle event support.
• Remote Configuration Retrieval - Retrieves application settings from external configuration centers such as Apollo, Consul, Etcd, and Aliyun ACM.
• Job Schedulers - Automates recurring operations on a fixed timetable with support for singleton tasks.
• High-Precision Scheduling - Ships a crontab system capable of executing background jobs with second-level precision.
• Concurrency Control - Manages queue concurrency with configurable retry attempts and concurrency limits.
• Distributed Task Schedulers - Orchestrates recurring tasks across distributed environments using semantic cron rules and distributed mutexes.
• Service Governance Platforms - Employs ACL tokens to manage service discovery and governance policies within microservice architectures.
• HTTP/2 Support - Implements HTTP/2 protocol capabilities for incremental data streaming and multiplexing.
• Input Validation - Provides mechanisms to verify and sanitize incoming request data against predefined validation rules.
• Global Application Settings - Implements centralized configuration parameters that govern application-wide runtime behavior.
• Background Job Dispatchers - Dispatches background jobs with built-in support for retry limits, result handling, and failure callbacks.
• Background Processing - Executes compute-intensive tasks and custom processes asynchronously in the background to maintain request responsiveness.
• Parallel Task Spawning - Enables running multiple callbacks concurrently to execute independent operations in parallel and merge their results.
• Distributed Tracing Instrumentation - Instruments JSON-RPC and other internal components to track execution flow and monitor performance spans.
• Metric Collection - Tracks performance data via Prometheus and provides pre-made Grafana dashboards for quantitative system visualization.
• Distributed Tracing - Tracks requests across distributed microservices using span tags through OpenTracing and Jaeger integration.
• Web Server Performance Monitoring - Collects and exports performance statistics for coroutine-based servers to monitor request execution and health.
• Input Validation Rules - Implements declarative validation rules for user input, including file type checks and conditional prohibitions.
• API Schema Generation - Scans application paths and annotations to automatically generate interactive Swagger API documentation.
• HTTP Response Handling - Sends standardized PSR-7 response objects to clients using a high-performance server engine.
• Response Streaming - Delivers data using HTTP chunking to improve the speed of response delivery.
• Exception Handling - Captures and processes application errors using prioritized exception handlers to map them to structured API responses.
• HTML Templating Engines - Generates HTML content using a variety of supported template engines like Blade, Twig, and Smarty.
• Middleware Configuration - Provides an interface to configure the execution order of middleware in the request-response pipeline.
• Real-Time Communication - Ships a coroutine-based WebSocket server for real-time bidirectional communication and live data streaming.
• Request Context Management - Applies different validation rules to requests based on the current execution context scene.
• Response Formatting - Transforms database models into standardized formats for consistent output across HTTP and gRPC.
• OpenAPI Specification Generators - Automatically produces OpenAPI specifications by extracting attributes and validation rules from code.
• Language Toolkits - Performant PHP CLI framework based on Swoole.

Star history