Skip to main content

Boson Framework Features

Boson provides a comprehensive set of features designed to make web development in C++ both powerful and enjoyable. This page details the key capabilities that make Boson an excellent choice for high-performance web applications.

Core Features​

HTTP Server​

  • High-performance HTTP/1.1 support: Handle thousands of concurrent connections efficiently
  • Asynchronous request handling: Process requests in parallel without blocking
  • TLS/SSL support: Secure communication with proper certificate management
  • Graceful shutdown: Clean termination of connections during server shutdown
  • Connection pooling: Efficient reuse of connections for optimal performance
  • Keep-alive management: Handle persistent connections properly
  • Custom socket options: Fine-tune network parameters for specific use cases

Routing System​

  • Expressive route definitions: Define routes with clear, readable syntax
  • Path parameters: Extract variables from URL paths (e.g., /users/:id)
  • Regular expression constraints: Apply validation rules to path parameters
  • Route groups: Organize related routes with shared prefixes
  • HTTP method constraints: Specific handlers for GET, POST, PUT, DELETE, etc.
  • Named routes: Reference routes by name for URL generation
  • Router mounting: Compose routers hierarchically for modular applications
  • Automatic OPTIONS handling: Proper handling of CORS preflight requests

Middleware Framework​

  • Global middleware: Apply processing to all requests
  • Route-specific middleware: Apply processing to specific routes only
  • Middleware chaining: Build complex processing pipelines
  • Next function: Control flow between middleware components
  • Early termination: Stop processing and send immediate responses when needed
  • Error middleware: Special handling for error conditions
  • Built-in middleware: Common functionality like logging, request parsing, etc.
  • Custom middleware creation: Easily extend the framework with application-specific processing

Request and Response Abstraction​

  • Clean object-oriented models: Type-safe access to HTTP elements
  • Headers management: Easy access and manipulation of HTTP headers
  • Query parameters: Parse and access URL query strings
  • Route parameters: Access variables extracted from the URL path
  • Request body parsing: Handle different content types (JSON, form data, etc.)
  • File uploads: Process multipart form data with file attachments
  • Content negotiation: Respond with the appropriate format based on Accept headers
  • Cookies: Read and set HTTP cookies with security options
  • Streaming responses: Efficiently handle large response bodies
  • Status code helpers: Set appropriate HTTP status codes with semantic methods
  • Redirect helpers: Easily create HTTP redirects

Static File Serving​

  • Efficient file serving: Stream files directly to clients
  • Directory serving: Make entire directories available
  • MIME type detection: Proper Content-Type headers based on file extensions
  • Conditional requests: Support for If-Modified-Since and ETag headers
  • Cache control: Configure browser caching behavior
  • Custom options: Fine-tune static file serving for specific needs
  • Security: Prevent directory traversal and other common vulnerabilities

JSON Support​

  • Integrated JSON library: Built-in support for JSON parsing and serialization
  • Type conversion: Automatic conversion between C++ types and JSON
  • JSON response helpers: Easily send JSON responses
  • JSON request parsing: Automatically parse JSON request bodies
  • JSON validation: Validate incoming JSON against schemas or structures
  • Pretty printing: Readable JSON output for debugging

Error Handling​

  • Global error handlers: Process uncaught exceptions
  • Route-specific error handlers: Custom error handling for specific routes
  • Structured error responses: Consistent error format for APIs
  • Development-friendly errors: Detailed error information during development
  • Production error handling: Safe error responses in production
  • Custom exception types: Handle application-specific error conditions
  • HTTP status mapping: Map exceptions to appropriate HTTP status codes

Controllers​

  • Class-based organization: Group related routes logically
  • Method binding: Use class methods as route handlers
  • Resource controllers: Easily implement RESTful resources
  • Shared state: Maintain state across related route handlers
  • Dependency injection: Access services and dependencies in controllers
  • Controller middleware: Apply middleware to all routes in a controller

Advanced Features​

CLI Tooling​

  • Project scaffolding: Generate new projects with proper structure
  • Component generation: Create controllers, middleware, and other components
  • Build management: Simplify the build process
  • Development server: Hot-reload capability for faster development
  • Project templates: Different starting points for various application types

Developer Experience​

Error Handling​

  • Comprehensive exception handling: Catch and process errors appropriately
  • Development-friendly error pages: Detailed error information during development
  • Production error logging: Safe error handling with proper logging
  • Custom error handlers: Process errors in application-specific ways
  • Input validation: Validate and sanitize user input

Logging and Debugging​

  • Structured logging: Organized log output with levels and categories
  • Multiple outputs: Log to console, file, or other destinations
  • Request logging: Track incoming requests and their processing
  • Performance metrics: Monitor application performance
  • Debug helpers: Tools to inspect application state

Performance Optimization​

  • Runtime monitoring: Track resource usage and performance metrics
  • Memory usage optimization: Efficient memory management
  • Request/response caching: Store and reuse responses for identical requests
  • Lazy loading: Load resources only when needed
  • Connection management: Efficient handling of client connections

By leveraging these features, developers can build robust, high-performance web applications in C++ with less effort and greater reliability.