awesome-repositories.com
博客
MCP
awesome-repositories.com

通过 AI 驱动的搜索，发现最优秀的开源仓库。

探索精选搜索开源替代品自托管软件博客网站地图
项目关于排名机制媒体报道MCP 服务器
法律隐私政策服务条款
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
quarkusio avatar

quarkusio/quarkus

0
View on GitHub↗
15,479 星标·3,076 分支·Java·apache-2.0·10 次浏览quarkus.io↗

Quarkus

Quarkus is a Kubernetes-native Java framework designed for building high-performance, memory-efficient applications. It utilizes ahead-of-time native compilation to transform Java code into standalone, optimized binaries that eliminate the need for a virtual machine, enabling rapid startup and reduced memory consumption. By performing code augmentation during the build phase, it shifts heavy processing tasks away from runtime, ensuring that applications are optimized for cloud-native environments.

The framework distinguishes itself through a unified approach to reactive and imperative programming, allowing developers to mix non-blocking, event-driven logic with traditional blocking code. It features a specialized dependency injection container optimized for build-time resolution and supports virtual thread concurrency to improve throughput in high-concurrency environments. Its container-native lifecycle management ensures seamless integration with cloud infrastructure, providing automated health monitoring and service orchestration.

Quarkus covers a broad capability surface, including comprehensive support for RESTful web services, event-driven messaging, and secure identity management. It integrates with standard enterprise specifications and provides extensive tooling for automated infrastructure provisioning, distributed tracing, and observability. The platform also includes a developer-focused dashboard and live-coding capabilities to streamline the development lifecycle.

The project provides extensive documentation and a modular extension system that allows developers to add features while maintaining native compatibility. It is designed to be installed and managed through standard build automation tools, supporting a wide range of deployment targets including serverless functions and managed Kubernetes clusters.

Features

  • Live Reloading Environments - Start the application in a live-reload mode that monitors code changes and updates the running process automatically without requiring a manual restart.
  • Native AOT Compilation - Provides ahead-of-time native compilation to transform Java code into optimized, standalone binaries for rapid startup and reduced memory usage.
  • Cloud-Native Backend Frameworks - Ships a high-performance, Kubernetes-optimized framework for building Java applications with fast startup times and low memory consumption.
  • Cloud-Native Frameworks - Builds high-performance, memory-efficient Java applications specifically optimized for containerized and serverless cloud-native environments.

AI 搜索

探索更多 awesome 仓库

用简单的语言描述您的需求 —— AI 将根据相关性为您从数千个精选开源项目中进行排序。

Start searching with AI
  • Event-Driven Frameworks - Provides a framework for building non-blocking, event-driven applications that handle high concurrency with minimal resource usage.
  • Dependency Injection Containers - Manages component lifecycles and provides dependency injection across the application using a specialized container.
  • RESTful APIs - Exposes HTTP resources using standard annotations to handle incoming requests and return data to clients.
  • Native Build Orchestrators - Compiles applications into optimized, standalone native binaries to minimize resource consumption.
  • Kubernetes Application Deployments - Automates the deployment, configuration, and lifecycle management of Java applications directly within Kubernetes and OpenShift clusters.
  • Kubernetes Integrations - Provides native support for container orchestration platforms to enable seamless deployment and management.
  • Imperative-Reactive Bridges - Provides a unified programming model that allows developers to mix blocking and non-blocking code seamlessly.
  • OIDC Authentication Plugins - Automates the acquisition, refresh, and propagation of access tokens for OpenID Connect identity providers.
  • Compile-Time Code Generation - Executes custom logic during the build phase to scan bytecode and generate optimized metadata for runtime efficiency.
  • Dependency Injection - Wires components together by automatically providing required instances to constructors or fields within a managed bean.
  • RESTful Services - Implements standard RESTful web services using a high-performance, non-blocking input-output model optimized for cloud environments.
  • Automated Data Repositories - Generates repository implementations automatically from interface definitions for database access.
  • Build-Time Optimizers - Performs bytecode scanning and metadata generation during the build phase to optimize application runtime performance.
  • gRPC - Automatically compiles protocol definitions into source code during the build process to facilitate service communication.
  • Bean Resolution Strategies - Discovers and registers application beans with support for custom scopes and injection point configuration.
  • Development Dashboards - Offers a web-based interface for inspecting, debugging, and interacting with a running application without requiring code changes or restarts.
  • Hot Reloading - Supports hot-reloading capabilities for automatic application updates during development.
  • Cloud Function Deployers - Packages and exports application functions for execution within the AWS Lambda environment using standard or native runtimes.
  • Virtual Thread Support - Ensures library compatibility with lightweight concurrency models by managing thread dispatching and avoiding carrier thread pinning.
  • gRPC Service Generators - Provides automated generation of gRPC service code from protocol definitions during the build process.
  • Cloud Native Orchestration - Orchestrates service lifecycles and health monitoring for seamless integration with cloud-native infrastructure.
  • Application Behavior Configurations - Provides a unified system for managing application settings and behavior configurations across different deployment environments.
  • Containerized Native Build Systems - Leverages container runtimes to generate native Linux executables without requiring local native compilation tools.
  • Deployment Automation - Orchestrates the building and deployment of applications from source to target environments using automated scripts.
  • Ingress Controllers - Configures network routing rules to expose internal cluster services to external traffic via ingress.
  • Kubernetes Configurations - Automates the generation of Kubernetes manifests, including deployments and cluster-specific configurations.
  • Java Toolkits - Provides a suite of tools for automating the deployment, configuration, and observability of Java applications within container orchestration clusters.
  • Native Image Configurations - Registers classes for reflection and manages initialization phases to ensure compatibility with ahead-of-time native image compilation.
  • Serverless Function Management - Executes portable function code within cloud-native environments by mapping HTTP requests to function endpoints on serverless platforms.
  • Remote Service Clients - Injects and invokes remote services into application components using declarative client configuration and reactive patterns.
  • Virtual Thread Executors - Implements virtual thread execution models to improve throughput and resource efficiency in high-concurrency environments.
  • Reactive Programming - Supports non-blocking, event-driven programming models and virtual threads for high-concurrency workloads.
  • Reactive gRPC Services - Exposes service interfaces as injectable beans using a reactive programming model.
  • Access Tokens - Manages the acquisition, refresh, and revocation of access tokens for authorized service communication.
  • Bearer Token Authentication - Validates incoming bearer tokens against OpenID Connect or OAuth 2.0 servers to secure REST endpoints.
  • Hardware Authentication - Replaces password-based login with hardware-backed authentication methods using cryptographic challenges.
  • Multi-Tenant Identity Management - Supports multi-tenant authentication by resolving tenant-specific security settings at runtime.
  • Identity and Access Management - Integrates OpenID Connect, OAuth 2.0, and role-based access control to secure service-to-service communication and user authentication.
  • OAuth2 Providers - Integrates with OIDC and OAuth2 providers to handle token verification and user session management.
  • OpenID Connect Providers - Connects applications to OIDC providers by configuring discovery endpoints, connection retries, and tenant resolution strategies to secure service access.
  • Web Application Security - Implements comprehensive web security mechanisms including OpenID Connect, OAuth2, and Basic authentication to protect application resources.
  • Application Configuration - Injects external configuration properties into components using annotations for structured data access.
  • Reactive Event Dispatchers - Processes event streams using non-blocking primitives to trigger actions upon completion or failure.
  • Build-Time Configuration - Fixes application settings during the compilation phase to optimize performance and reduce runtime overhead.
  • Dependency Injection Providers - Exposes extension-provided services as injectable beans for seamless integration with the dependency injection container.
  • Reactive Execution Engines - Utilize a high-performance reactive engine to handle input and output interactions asynchronously, enabling high concurrency and efficient resource utilization across the entire system.
  • Reactive Programming - Implements non-blocking, event-driven services that handle high concurrency and asynchronous communication using reactive programming models.
  • Reactive & Event-Driven Systems - Processes requests asynchronously using non-blocking event loops to handle high concurrency with minimal resource consumption.
  • Application Observability - Captures and exports application metrics, traces, and logs to centralized observability platforms.
  • Health Checks - Provides liveness and readiness checks to monitor application status and ensure traffic is routed to healthy instances.
  • Development Dashboards - Provides a web-based interface for monitoring and interacting with application internals during development.
  • Development Dashboards - Displays real-time application metrics, logs, and management tools within a browser-based interface during development.
  • gRPC Service Implementations - Builds and consumes services using integrated server and client implementations.
  • Asynchronous Request Processing - Enables building reactive applications that process requests asynchronously using non-blocking messaging to handle high concurrency.
  • Reactive API Endpoints - Exposes HTTP resources that return reactive types to handle requests without blocking execution threads.
  • CRUD Generators - Automatically generates standard CRUD API resources from data entity definitions.
  • Serverless Functions - Builds serverless functions with dependency injection support for both standard and native runtimes.
  • Java 项目 - Listed in the “Java 项目” section of the Great Open Source Project awesome list.
  • Application Metrics Collection - Gathers performance and operational data from applications using standardized instrumentation libraries.
  • Reactive Databases - Maps database entities to support non-blocking, asynchronous data operations for high-concurrency environments.
  • API Documentation Generators - Automatically generates and serves interactive API documentation schemas from REST endpoints.
  • Application Deployment Platforms - Automates container image builds and platform-specific resource application for deployment to cloud environments.
  • Build Automation Tools - Compiles and packages projects using underlying build tool configurations.
  • Executable Packaging - Bundles applications and dependencies into executable formats ready for containerized deployment.
  • Cloud Deployment Automation - Packages and pushes applications to cloud providers using integrated CLI tools and automated configuration management.
  • Cloud Deployment Platforms - Automates the build and deployment of containerized applications to cloud orchestration platforms.
  • Environment Configuration Profiles - Applies environment-specific configuration profiles to manage distinct settings for development, testing, and production.
  • Container Image Management - Builds and pushes container images, integrating with the build lifecycle for automated deployment.
  • Container Image Packaging - Automates the creation of container images for applications using various industry-standard tools.
  • Kubernetes API Providers - Reads ConfigMaps and Secrets directly from the Kubernetes API server to populate application settings.
  • Managed Cloud Deployments - Packages applications as container images for automated scaling in managed serverless environments.
  • Ephemeral Database Provisioning - Provides automated lifecycle management for ephemeral database and service instances during development and testing cycles.
  • Serverless Deployment - Builds and executes cloud-native functions that support dependency injection and standard cloud event triggers within managed environments.
  • Publish-Subscribe Messaging - Facilitates real-time event-driven interactions between application components through publish-subscribe messaging channels.
  • Message Broker Consumers - Receives and processes messages from queues, supporting direct payload consumption or full message object retrieval with acknowledgement.
  • Message Brokers - Establishes connections to message brokers using configurable host, port, and authentication credentials.
  • Service Traffic Routing - Automatically creates network routes to make application endpoints accessible from outside the cluster.
  • Reactive - Supports building and consuming services using non-blocking interfaces and event stream handling.
  • Blocking Operation Handlers - Executes blocking tasks on dedicated worker or virtual threads to safely integrate with non-blocking workflows.
  • Endpoint Controls - Supports controller-based request handling to define web endpoints using standard framework conventions.
  • Authentication Flows - Protects web applications by delegating authentication to OIDC providers using the authorization code flow.
  • Bearer Token Authentication - Forwards active bearer tokens to downstream services to maintain user identity across distributed system boundaries.
  • Request Authentication - Extracts credentials from incoming requests and challenges unauthenticated clients to provide valid identity information.
  • Role-Based Access Control - Generates necessary service accounts, roles, and role bindings to grant applications appropriate access to cluster resources.
  • Annotation-Based Authorization - Secures endpoints and beans using standard security annotations to enforce role-based access and custom authorization policies.
  • Secret Management Systems - Integrates with external engines or environment properties to securely store, generate, and encrypt sensitive application credentials.
  • Identity Mapping - Maps verified credentials to security identities containing roles and attributes for access control.
  • Externalized Configuration Bindings - Binds external application properties to structured classes using annotations for organized configuration management.
  • Configuration Registries - Aggregates settings from multiple sources into a single, prioritized registry supporting build-time and runtime overrides.
  • Default Configuration Values - Retrieves individual settings directly into components using annotations with support for default values.
  • Enterprise Application Platforms - Provides a modern, modular platform for building enterprise-grade Java applications using standard specifications and dependency injection.
  • Error Handling Strategies - Defines failure strategies for message processing, including retries and dead-letter queues.
  • Event Driven Messaging - Enables the creation of reactive applications that consume and produce messages through standard protocols like Kafka and AMQP.
  • Dependency Qualifiers - Distinguishes between multiple implementations of the same type using custom annotations for precise dependency resolution.
  • Monitoring and Observability - Captures and exports distributed traces, metrics, and logs to provide end-to-end visibility into system performance.
  • Distributed Tracing - Integrates cloud-native tracing services into native-compiled functions to monitor performance and request flows.
  • Repository-Based Generators - Generates standard REST endpoints automatically from repository interfaces to simplify data access.
  • Build-Time Bytecode Transformers - Modifies compiled class files during the build process to inject logic and adapt third-party dependencies.
  • REST API Services - Builds web services using standard annotations and controllers within a native-optimized environment.
  • HTTP-to-Function Adapters - Runs Java HTTP frameworks as AWS Lambda functions using API Gateway, supporting both standard JARs and native executables.
  • Dynamic Bean Lookups - Retrieves bean instances dynamically at runtime with support for caching and filtering.
  • Synthetic Bean Factories - Allows dynamic bean definitions based on runtime or build-time logic without requiring corresponding Java classes.
  • Active Record Entities - Provides an active record pattern for database interactions, allowing developers to define entities with built-in data methods.
  • Message Queue Integrations - Maps messaging channels to specific broker exchanges or queues with options to declare new infrastructure or connect to existing resources.
  • Reactive Datasource Configurators - Connects applications to various database platforms using either traditional JDBC drivers or non-blocking reactive clients.
  • Tenant Configurations - Supports dynamic management of multiple OIDC tenant configurations to facilitate complex multi-tenant application environments.
  • Build-Time Augmentors - Processes annotations at build time to generate bytecode, reducing runtime overhead and memory usage.
  • Command Line Interfaces - Provides annotations to map command-line arguments to class fields and methods for building CLI applications.
  • Command Line Applications - Offers a structured framework for developing and executing standalone command-line interface applications.
  • Template Bean Injections - Exposes beans directly within templates to access application services and data without manual passing.
  • Ephemeral Database Provisioning - Starts and configures databases automatically in development mode using container runtimes to simplify local testing.
  • SBOM Generators - Generates comprehensive bills of materials for application dependencies during the build process for auditing and compliance.
  • Project Scaffolding - Generates new project structures with pre-configured build files and dependencies to accelerate initialization.
  • Software Licenses - Produces standard-compliant software bills of materials to track dependencies and licensing information.
  • Startup Optimization Tools - Pre-compiles classes and caches resources to reduce application initialization time.
  • Context Propagation - Captures and transfers execution context, such as security principals or transaction state, across asynchronous boundaries in reactive pipelines.
  • Multi-Platform Build Orchestrators - Automates the generation of container images for multiple architectures using native build tools.
  • Azure Deployment Automators - Handles authentication and resource deployment to cloud providers using local CLI tools and project configuration.
  • Cloud Service Deployers - Maps Jakarta REST, Servlet, or Reactive endpoints to Azure Functions HTTP triggers for cloud-native deployment.
  • Container Deployment - Packages and deploys applications as native executables to container platforms using automated build strategies and custom configurations.
  • Dependency Management - Coordinates project dependencies through a centralized bill of materials to ensure version alignment.
  • Dependency Protocol Compilers - Compiles protocol files found within project dependencies into source code alongside local definitions.
  • Source Builds - Builds and deploys containerized applications directly from source code repositories into cloud environments using automated pipelines.
  • Kubernetes Service Discovery - Retrieves individual pod addresses for services to enable custom load balancing beyond standard cluster routing.
  • Kubernetes Deployments - Pushes generated application manifests and container images directly to a target cluster API server to automate the deployment lifecycle.
  • Volume Mounts - Attaches storage volumes to application containers by defining mount paths in deployment manifests.
  • Message Brokers - Connects applications to message brokers to send and receive messages asynchronously using reactive messaging channels.
  • Websocket Connection Managers - Manages WebSocket endpoints with support for lifecycle events and path mapping.
  • Distributed Trace Propagation - Integrates with tracing systems to automatically propagate spans across message boundaries for end-to-end request visibility.
  • Message Broker Producers - Pushes data into specific topics using messaging emitters with automatic serialization.
  • Broker Provisioning - Starts and configures local message broker instances automatically during development to simplify testing.
  • Message Routing - Directs messages to specific broker addresses or queues using static configuration or dynamic destination selection via message metadata.
  • Authentication Clients - Automatically attaches managed access tokens to outgoing client requests to secure service-to-service communication.
  • Tracing Context Propagation - Ensures distributed tracing spans and identifiers are correctly maintained across asynchronous or reactive execution boundaries.
  • WebSocket Message Interception - Implements callback methods to process WebSocket messages with support for custom serialization codecs.
  • Build Optimizations - Compiles applications into optimized formats supporting advanced features like PGO and AOT enhancement.
  • API Access Security - Restricts access to API endpoints using standard security annotations and role-based configuration.
  • Token Claim Injectors - Injects JWT claims or UserInfo objects into application components to retrieve user identity and metadata.
  • Encryption Key Management - Loads signing and encryption keys from local files, classpaths, or remote secret managers for token operations.
  • Identity and Access Management - Authenticates credentials and maps them to security identities containing roles and permissions.
  • OIDC Identity Integrations - Enables programmatic configuration of OIDC tenants and application settings at runtime.
  • Role-Based Access Controls - Extracts roles and permissions from JWT claims, UserInfo, or introspection responses to authorize access to specific application resources.
  • Session Termination Services - Supports standard OIDC logout mechanisms and custom provider-specific logout flows to terminate user sessions.
  • Social Authentication Providers - Enables user authentication via external social identity providers using standard OpenID Connect flows.
  • Runtime Context Injections - Provides access to runtime context and event data directly into application resources using dependency injection.
  • Distributed Transaction Coordinators - Coordinates operations across multiple JDBC datasources using XA transactions to ensure data consistency.
  • Web Bridges - Exposes event bus communication to web clients using a protocol-agnostic bridge that automatically negotiates between WebSockets, server-sent events, or long polling.
  • Fault Tolerance Patterns - Implements resilience patterns like retries, fallbacks, and circuit breakers to maintain system stability during service interruptions.
  • Binary Footprint Optimizers - Prunes unused beans and classes during the build process to minimize memory usage.
  • Runtime Configuration Overrides - Loads external configuration files at runtime to modify application behavior without rebuilding.
  • Metrics Exporters - Integrates with external monitoring backends to push or expose collected telemetry data.
  • Integration Testing Suites - Runs automated test suites against the final application artifact to verify behavior in a production-ready state.
  • Context Scoping - Controls bean lifecycles and sharing by binding components to specific application, request, or session contexts.
  • Exception Handling - Maps application-specific exceptions to standard HTTP status codes for consistent error reporting.
  • Method Interceptors - Applies cross-cutting logic to method invocations using interceptor bindings and repeatable annotations.
  • Web Deployment Services - Hosts containerized web applications on platforms providing automatic load balancing and horizontal scaling.
  • Data Access & Abstraction - Provides asynchronous, non-blocking clients for relational and NoSQL databases to perform data operations.
  • Database APIs - Provides type-safe and low-level APIs for database operations using reactive or imperative models.
  • Method Result Caches - Stores method results in memory using standard annotations to improve response times by avoiding redundant calculations.
  • Data Source Connections - Registers JDBC drivers and manages database connection pools, including support for XA transactions and schema migration.
  • Atomic Transaction Execution - Performs atomic writes across multiple topics and partitions to ensure data consistency during production.
  • Exactly-Once Processing Semantics - Ensures exactly-once message processing by coupling consumer offset management with transactional production.
  • Reactive Stream Interceptors - Allows custom logic injection into reactive streams for cross-cutting concerns.
  • Relational Database Connectors - Integrates managed relational database services like MySQL and PostgreSQL for persistent data storage.
  • Atomic Transactions - Groups multiple commands into atomic units to ensure data consistency during batch execution.
  • Connection Pool Managers - Maintains a pool of database connections with configurable sizing and validation to ensure efficient data access.
  • Database Transaction Management - Defines transaction boundaries using declarative annotations or programmatic interfaces to ensure consistent data operations.
  • In-Memory Caches - Stores application data in a remote database by automatically serializing values to JSON and managing key prefixes.
  • Identity Data Caches - Caches remote token validation and user profile information to minimize network latency.
  • Multi-datasource Configurators - Defines and switches between multiple named database connections within a single application to support complex persistence requirements or runtime selection.
  • Redis Provisioners - Automatically starts and configures Redis containers during development and testing to simplify local environment setup.
  • Service Discovery and Selection - Locates service instances from a registry and applies load-balancing strategies for incoming requests.
  • Schema Enforcement Tools - Ensures structured data serialization and deserialization adheres to predefined schemas for consistent message formats.
  • Search Index Synchronizers - Automatically synchronizes database entities to search indexes to enable full-text search capabilities.
  • Search Integrations - Integrates with search clusters using client libraries to perform search and data operations.
  • Session State Management - Maintains user authentication state using encrypted cookies or offloads session storage to external databases or Redis caches.
  • Build-Time Validation - Inspects beans and injection points during the build to enforce custom rules and fail the build if requirements are not met.
  • Extensible Configuration Interfaces - Maps extension settings to a centralized configuration system for consistent property management across the application.
  • Extension Managers - Enforces dependency constraints and class loading rules to resolve conflicts between extension artifacts.
  • Remote Debugging Environments - Connects local development environments to remote instances for live coding and debugging in containerized environments.
  • Blocking Task Offloaders - Offloads synchronous or long-running message processing tasks to dedicated threads to prevent blocking the main reactive event loop.
  • Build-Time Execution - Executes initialization logic during the build phase to accelerate application startup.
  • Configuration Resolution - Hooks into the configuration lookup process to modify values and implement dynamic expressions.
  • Container Base Images - Supplies optimized, minimal container base images tailored for native executable runtimes.
  • Backpressure Controllers - Regulates data flow between producers and subscribers to prevent system overload during high-volume processing.
  • Annotation Registrars - Programmatically registers annotations to extend the dependency injection system's capabilities.
  • Multi-Container Orchestration - Launches complex database environments defined in compose files to support integration testing.
  • Native Compilation Metadata - Generates metadata required to preserve code reachability for ahead-of-time native binary compilation.
  • Private Cloud Hosting - Stores containerized application images in secure, private registries to manage deployment artifacts.
  • Reactive Resilience Strategies - Defines fallback values and retry strategies to ensure application resilience within reactive workflows.
  • Version Upgrades - Applies automated migration recipes to update project dependencies and configuration files to newer versions.
  • Workload Orchestration - Allows customization of deployment specifications like volume mounts and resource limits via simple property settings.
  • Message Stream Consumer Groups - Distributes topic partitions across consumer threads to increase throughput and manage load.
  • Messaging Channel Management - Configures reactive messaging channels and connectors for asynchronous event-driven communication.
  • Messaging Integrations - Connects applications to message brokers to support asynchronous communication and event-driven architectures.
  • Build-Time Transformations - Performs bytecode transformations at build time to enhance application classes before execution.
  • Preloading - Loads specified classes during the snapshotting process to reduce execution time and minimize classloading overhead.
  • Access Token Management - Forwards security tokens to downstream services to maintain identity context across distributed components.
  • Token Binding Mechanisms - Prevents token replay attacks by cryptographically binding access tokens to specific clients using DPoP or Mutual TLS.
  • Proof Key for Code Exchange - Hardens authentication flows by implementing security extensions like PKCE, PAR, and RAR.
  • Cross-Origin Resource Sharing Policies - Controls browser access to application resources by defining allowed origins, methods, and headers for cross-origin requests.
  • Cross-Site Request Forgery Protections - Validates unique tokens on state-changing requests to protect against unauthorized actions.
  • Dependency Vulnerability Scanners - Identifies security flaws in project dependencies during the build process.
  • Gateway Security Controls - Parses security information from incoming API Gateway events to automatically populate standard security principals and roles for application authorization.
  • Mutual TLS Authentication - Encrypts gRPC traffic using TLS and enforces mutual authentication for peer connections.
  • Client Registration Protocols - Facilitates dynamic registration and management of client metadata for secure integration with identity providers.
  • Identity Augmentors - Enriches authenticated user profiles with additional roles or attributes during the final stage of the authentication process.
  • Identity Provider Role Mapping - Transforms identity roles into deployment-specific roles to simplify access management and align external identity providers with internal requirements.
  • Message Decryption - Integrates handlers to automatically decrypt sensitive configuration data at runtime for secure credential management.
  • Mutual TLS Configurations - Verifies user identity by requiring X.509 client certificates during the SSL/TLS handshake.
  • Policy-Based Access Control - Delegates access control decisions to external identity providers to maintain consistent security policies across multiple applications.
  • YAML Configuration Files - Supports structured application configuration using YAML files as a readable alternative to standard property formats.
  • Service Bindings - Automates the creation of service binding resources to connect applications with databases and operators running within the cluster.
  • Asynchronous Task Execution - Provides mechanisms for chaining dependent asynchronous tasks without blocking the underlying execution threads.
  • Custom CDI Scopes - Extends the application with custom scopes to manage bean lifecycles beyond standard built-in options.
  • Environment Setup Scripts - Provisions temporary databases and executes import scripts automatically to simplify environment configuration for testing.
  • Injection Point Transformers - Dynamically alters dependency resolution by modifying qualifiers or metadata on specific injection points.
  • Lifecycle Callbacks - Executes custom logic during bean initialization or destruction phases to handle setup and cleanup.
  • Lifecycle Event Hooks - Executes custom logic before or after data modification operations via listener interfaces.
  • Load Shedding - Implements load shedding to reject incoming requests during overload conditions and maintain system stability.
  • Automatic Service Registrations - Registers application instances with service discovery providers upon startup and removes them during shutdown.
  • Infrastructure Provisioners - Start and stop containerized infrastructure dependencies like databases automatically during development and testing cycles to simplify local environment setup.
  • Dynamic Service Registrations - Publishes application service locations to a discovery registry during startup.
  • Centralized Logging Systems - Streams application logs to external management platforms using standard protocols for centralized analysis.
  • Application Logging - Routes application and framework logs to console, file, or centralized logging systems using standard logging backends.
  • Identity Server Administration - Automates administrative tasks for identity servers using dedicated client interfaces.
  • Metric Collection - Exports detailed operational performance data including execution times and failure rates to observability systems.
  • Metric and Performance Monitors - Exposes application and system performance data through standardized interfaces for runtime monitoring.
  • Performance Visualization - Provides integrated dashboards to display logs, metrics, and traces in a unified interface for monitoring application health.
  • Health Monitoring Endpoints - Provides built-in endpoints for monitoring application health, metrics, and system information.
  • OpenTelemetry Exporters - Transmits application logs to OpenTelemetry-compatible collectors for integration into distributed observability pipelines.
  • Service Metrics Monitoring - Automatically exports performance and usage metrics for gRPC services to integrated monitoring systems.
  • Telemetry Exporters - Routes captured telemetry to external systems or local consoles, supporting custom exporters and in-memory storage.
  • API Documentation - Renders interactive documentation interfaces for endpoints to allow developers to explore and test service contracts.
  • Multipart Upload Utilities - Processes multipart HTTP form data with configurable size limits for secure file uploads.

    • Star 历史

    quarkusio/quarkus 的 Star 历史图表quarkusio/quarkus 的 Star 历史图表

    常见问题解答

    quarkusio/quarkus 是做什么的？

    Quarkus is a Kubernetes-native Java framework designed for building high-performance, memory-efficient applications. It utilizes ahead-of-time native compilation to transform Java code into standalone, optimized binaries that eliminate the need for a virtual machine, enabling rapid startup and reduced memory consumption. By performing code augmentation during the build phase, it shifts heavy processing tasks away from runtime, ensuring that applications are optimized for…

    quarkusio/quarkus 的主要功能有哪些？

    quarkusio/quarkus 的主要功能包括：Live Reloading Environments, Native AOT Compilation, Cloud-Native Backend Frameworks, Cloud-Native Frameworks, Event-Driven Frameworks, Dependency Injection Containers, RESTful APIs, Native Build Orchestrators。

    quarkusio/quarkus 有哪些开源替代品？

    quarkusio/quarkus 的开源替代品包括： dodyg/practical-aspnetcore — This project is a comprehensive sample library and implementation guide for ASP.NET Core. It provides a collection of… dotnet/core — This project is a cross-platform development framework and managed runtime environment designed for building… shekhargulati/52-technologies-in-2016 — This project serves as a comprehensive educational repository and technical reference collection, documenting a wide… prefecthq/fastmcp — FastMCP is a Python framework designed for building servers that expose functions, resources, and prompts to AI models… liangxiegame/qframework — QFramework is a Unity game architecture framework designed to separate presentation, system, and data logic. It… codeigniter4/codeigniter4 — CodeIgniter is a PHP web framework built on the Model-View-Controller pattern, designed for building full-stack web…

    Quarkus 的开源替代方案

    相似的开源项目，按与 Quarkus 的功能重合度排序。
    • dodyg/practical-aspnetcoredodyg 的头像

      dodyg/practical-aspnetcore

      10,382在 GitHub 上查看↗

      This project is a comprehensive sample library and implementation guide for ASP.NET Core. It provides a collection of practical examples and projects that demonstrate how to build web applications, RESTful APIs, and high-performance services. The repository focuses on a variety of architectural patterns, including the development of Minimal APIs, contract-first gRPC services, and real-time communication using WebSockets and Server-Sent Events. It includes detailed implementations for user identity and security, such as token-based authentication and CSRF protection. The codebase covers a bro

      C#asp-net-coreaspnet-coreaspnetcore
      在 GitHub 上查看↗10,382
    • dotnet/coredotnet 的头像

      dotnet/core

      21,897在 GitHub 上查看↗

      This project is a cross-platform development framework and managed runtime environment designed for building high-performance applications. It provides a comprehensive toolkit for constructing web services, cloud-native microservices, and desktop applications, utilizing a unified runtime that handles memory management and execution across diverse operating systems. The framework distinguishes itself through a native ahead-of-time compilation toolchain that transforms source code into optimized, self-contained machine code binaries. This capability enables fast startup times and reduced memory

      PowerShelldotnetdotnet-core
      在 GitHub 上查看↗21,897
    • shekhargulati/52-technologies-in-2016shekhargulati 的头像

      shekhargulati/52-technologies-in-2016

      7,311在 GitHub 上查看↗

      This project serves as a comprehensive educational repository and technical reference collection, documenting a wide range of software engineering practices and modern development technologies. It provides a structured learning path for developers, curating tutorials and practical examples that cover the full lifecycle of application development, from initial project scaffolding to deployment and maintenance. The repository distinguishes itself by offering deep technical insights into complex architectural patterns, including actor-based concurrency models for managing parallel tasks and cont

      JavaScriptawesomeawesome-listblog
      在 GitHub 上查看↗7,311
    • prefecthq/fastmcpPrefectHQ 的头像

      PrefectHQ/fastmcp

      22,994在 GitHub 上查看↗

      FastMCP is a Python framework designed for building servers that expose functions, resources, and prompts to AI models using the Model Context Protocol. It simplifies the development process by automatically deriving tool metadata, input schemas, and documentation directly from Python function signatures and type hints. The framework provides a unified container for managing these components, allowing developers to build modular applications that integrate seamlessly with AI assistants. The project distinguishes itself through its support for interactive, server-defined user interface compone

      Pythonagentsfastmcpllms
      在 GitHub 上查看↗22,994
    查看 Quarkus 的所有 30 个替代方案→