RESTEasy
A Jakarta REST implementation written in Java. It provides server and client runtimes, content negotiation, JSON, XML and multipart providers, and security, signing and caching support. Maintained by the RESTEasy project.
Business rules, traced to source lines.
These 12 rules are a sample of the 17,487 CoreStory V3 extracted from RESTEasy. Each one links to the exact lines on GitHub at commit 4847d10. The statement is CoreStory V3’s wording; the code excerpt is the source it cites.
If denyAll and permitAll are false and rolesAllowed is non-null, the filter obtains the SecurityContext from ResteasyContext; if the SecurityContext is non-null, the request is permitted only when the user is in at least one of the rolesAllowed roles, otherwise it is rejected with a ForbiddenException carrying HTTP 403, entity "Access forbidden: role not allowed", and media type "text/plain;charset=UTF-8".
- 403 — HTTP status code of the rejection response
- Access forbidden: role not allowed — response entity message
- text/plain;charset=UTF-8 — response media type
If the request origin is not permitted, i.e. allowed origins does not contain "*" and does not contain the request origin, the request property "cors.failure" is set to true and a ForbiddenException with an origin-not-allowed message is thrown.
- * — wildcard origin indicator allowed as an alternative to matching the request origin
- cors.failure — request property name set to true to signal CORS failure
- true — value assigned to the cors.failure property
In cacheIfPossible, a Cache-Control response header with no-cache set causes the method to return without caching; otherwise its max-age value becomes the expiration. If there is no Cache-Control but there is an Expires header, expiration is computed as (parsed expiry time - current time) / 1000 cast to int. If neither header is present, expiration remains -1.
- -1 seconds — default expiration value when neither Cache-Control nor Expires is present
- 1000 milliseconds per second — divisor converting millisecond difference to seconds
When a cached entry is found but is expired, the entry is removed from the cache, the entry's validation headers are copied onto the outgoing request, the request property "expired.cache.entry" is set to the entry, and the request proceeds to the server.
- expired.cache.entry — request property name used to carry the expired cache entry to the response filter
isExpired returns false when the EXPIRATION ("x") attribute is not set; otherwise it parses the attribute as a long of seconds, multiplies by 1000, and returns true when that value is less than the current time.
- 1000 — multiplier converting seconds to milliseconds
Also cited: L35
The JWE content encryption method must be EncryptionMethod.A128CBC_HS256 or EncryptionMethod.A256CBC_HS512, handled by AESCBC.decryptAuthenticated(cek, iv, cipherText, aad, authTag), or EncryptionMethod.A128GCM or EncryptionMethod.A256GCM, handled by AESGCM.decrypt(cek, iv, cipherText, aad, authTag). Any other encryption method causes a RuntimeException with the message from Messages.MESSAGES.unsupportedEncryptionMethod().
- A128CBC_HS256 — supported JWE encryption method
- A256CBC_HS512 — supported JWE encryption method
- A128GCM — supported JWE encryption method
- A256GCM — supported JWE encryption method
If a q parameter value parses to a float greater than 1.0F, a LoggableFailure is thrown with HTTP status SC_BAD_REQUEST.
- 1.0 — maximum permitted q value
Also cited: L88
Adding a context data level is rejected with a BadRequestException when the current context data level count equals maxForwards (20); equality at 20 triggers the exception, so at most 20 levels are permitted before rejection.
- 20 — maximum number of context data levels before rejection
Also cited: L22
If no file has been created and the memory threshold has not been reached by len plus the current in-memory size (memoryThreshold.reached(len + inMemory.size()) is false), writes stay in memory; otherwise a temporary file with suffix ".tmp" is created and used.
- .tmp — temporary file suffix
A provider class annotated with @ConstrainedTo whose value is not RuntimeType.SERVER is rejected during processProviderContracts (the method returns early and the provider is not registered). When @ConstrainedTo is absent, or its value equals RuntimeType.SERVER, processing proceeds normally through super.processProviderContracts and subsequent contract registration.
- SERVER — required RuntimeType value for provider to be processed
When nameBound is non-empty and both targetClass and target are non-null, postMatch returns null unless every name-binding annotation is present on targetClass, on target, or (when the Application context is non-null) on the resolved type of the Application class. If all bindings match, the interceptor is returned, and if the interceptor is null a NullPointerException is thrown.
- interceptorNullFromClass — message key used in the NullPointerException when interceptor is null
If the method has a RolesAllowed annotation, access is allowed (returns true) when the SecurityContext reports the user is in at least one of the roles listed in the annotation's value array; if no listed role matches, the check returns false.
- true — result returned when a listed role matches
- false — result returned when no listed role matches
Also cited: L43
What the application does
28 capabilities identified, grouping 242 of the 3,663 distinct features extracted. Most extracted features are not grouped under a capability, so this list is a partial view of the application. These are descriptions, not the cited rules above.
HTTP Method Invocation and CRUD
Clients and servers exercise the full range of HTTP verbs (GET, POST, PUT, DELETE, HEAD, OPTIONS, TRACE) to create, read, update, and delete resources.
- HTTP CRUD Operations: Exercising HTTP verbs (GET, POST, PUT, DELETE, HEAD, OPTIONS, TRACE) against single resources and thing lists.
- HTTP DELETE Request: Allow a client to perform an HTTP DELETE request to remove a resource.
- HTTP DELETE Request Handling: Clients can issue HTTP DELETE requests to remove resources via proxy endpoints.
- HTTP GET Request: Allow a client to perform an HTTP GET request and receive the response body or entity.
- HTTP GET Request Handling: Exposes a client capability to execute HTTP GET operations, including header-based request routing.
- HTTP HEAD Request: Allow a client to perform an HTTP HEAD request to retrieve response metadata without a body.
- HTTP HEAD Request Handling: Clients can issue HTTP HEAD requests to retrieve response headers without a body.
- HTTP Method Dispatch: Exposes standard HTTP method handlers (GET, POST, PUT, DELETE, HEAD, OPTIONS, TRACE) as entry points for request processing.
- HTTP Method Handling: Supports the standard HTTP request methods (GET, POST, PUT, DELETE, HEAD) for handling client requests.
- HTTP Method Invocation: Supports invoking requests using standard HTTP methods such as GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS, and ACCEPT.
- HTTP Method Operations: Issue requests using standard HTTP verbs (GET, POST, PUT, DELETE, HEAD, PATCH, OPTIONS, TRACE) as distinct methods.
- HTTP OPTIONS Request: Allow a client to query the HTTP OPTIONS capabilities of a resource.
- HTTP OPTIONS Request Handling: Clients can send HTTP OPTIONS requests to discover allowed methods on proxy endpoints.
- HTTP POST Request: Sends an HTTP POST request carrying a message body to a resource.
- HTTP POST Request Handling: Clients can submit HTTP POST requests with payloads to proxy endpoints.
- HTTP PUT Request: Allow a client to perform an HTTP PUT request to update a resource.
- HTTP PUT Request Handling: Clients can issue HTTP PUT requests to update resources via proxy endpoints.
- HTTP TRACE Request: Allow a client to perform an HTTP TRACE request for diagnostic echo of the request.
- HTTP TRACE Request Handling: Clients can send HTTP TRACE requests to proxy endpoints for diagnostic echo.
Exception Handling and Response Mapping
Maps thrown exceptions into structured HTTP responses and surfaces handled and unhandled errors to clients across server and client boundaries.
- Custom Exception Mapping: Maps a custom application exception to an HTTP response representation, allowing clients to observe structured error information such as a message.
- Custom Exception Response Mapping: Clients receive a structured message payload when a custom exception is raised by the provider resource, giving them a meaningful response instead of a generic error.
- Error Response Handling: Capability to surface both handled and unhandled server exceptions as observable error responses to the caller.
- Error Response Mapping: Maps runtime exceptions carrying a reason into a structured error response with an exception and reason payload.
- Exception Handling: Handled and unhandled exception paths that shape the response when errors occur during request processing.
- Exception Handling and Propagatation: Allows clients to observe handled and unhandled exceptions raised during request processing.
- Exception Handling and Response Generation: Transforms raised exceptions into structured user-facing responses through a dedicated exception-handling provider.
- Exception Mapping: Mapping thrown application exceptions to HTTP responses via the default exception mapper.
- Exception Mapping to HTTP Response: Maps a thrown exception into a concrete HTTP response for the client.
- Exception Response Mapping: Maps application runtime exceptions to structured responses for callers via a dedicated exception mapper.
- Exception Unwrapping: Unwraps nested exceptions to expose the underlying cause to the caller.
- Exception to HTTP Response Mapping: Translates exceptions raised during request processing into HTTP responses returned to the client.
- Exception to Response Mapping: Translates thrown custom exceptions into HTTP responses using a registered exception mapper.
- Request Exception Handling: Provides handling of both handled and unhandled request exceptions surfaced to callers.
- Web Application Exception Handling: Maps web application runtime exceptions into HTTP responses so callers observe a proper error status.
Entity and Message Body Serialization
Reads and writes HTTP message bodies through message body readers/writers, entity providers, and interceptors across XML, JSON, and custom media types.
- Custom Message Body Serialization: Enables writing custom Java objects to HTTP response bodies by providing a writable MessageBodyWriter that serializes values into the output stream.
- HTTP Message Body Reading: A JAX-RS message body reader that deserializes an incoming HTTP request or response entity from an input stream.
- HTTP Message Body Serialization: Reads and writes HTTP message bodies to and from streams by inspecting their readability, writability, and size, exposed as a JAX-RS provider.
- JAXB Marshalling: Marshalling of JAXB objects to XML output using a Fastinfoset Marshaller with configurable adapter, schema, and attachment marshaller settings.
- JSON Message Body Serialization: Automatic JSON reading and writing of HTTP message bodies using Jackson, with support for annotations, decorators, and a configurable object mapper.
- JSON Serialization: Provides JSON serialization and deserialization of values for users and other systems.
- Message Body Reader/Writer Resolution: Resolves which message body reader or writer handles a given type/media type for both client and server serialization.
- Message Body Reading: Reads request/response message bodies from the wire into Java objects, handling the not-found case through the reader utility.
- Message Body Writing: Serializes an entity to the response output stream by resolving a writer for the entity's type and media type.
- Reader/Writer Interception: Lets users intercept request/response entity reading and writing to customize payload handling.
- Request/Response Entity Serialization: Reading and writing HTTP message entities through registered readers and writers.
- Writer Interceptor Chain: Runs a chain of writer interceptors around the write operation, allowing each to inspect and modify the outgoing message.
- XML Marshalling: Serialize objects to XML output through a configurable base marshaller with character-set and property handling.
- XML Marshalling and Unmarshalling: Read and write XML by converting objects to and from XML using JAXB marshallers and unmarshallers.
JAX-RS Runtime and Deployment
Bootstraps, deploys, and manages the JAX-RS/RESTEasy runtime, its deployments, providers, and servlet integration.
- Application Bootstrap: Starts the application and wires its components together at runtime.
- Application Deployment: Capability to deploy the application or service to a target environment.
- Artifact Deployment: Deploys an artifact or application after preparation to a target environment.
- Contract Deployment: Deploys compiled smart contracts to a target network.
- Deploy: Deploys an application or site, observable via the deploy capability.
- Deployment: Deploys an application or service, exposed as a deployable capability.
- Deployment Lifecycle Management: Starts and stops the RESTEasy deployment and manages its executor services.
- JAX-RS Application Deployment: Deploying and registering JAX-RS applications, resources, and providers with the runtime.
- JAX-RS Provider Registration: Registration of message body readers/writers, filters, interceptors, exception mappers, and other JAX-RS providers into the runtime configuration.
- RESTEasy Deployment Configuration: Configures a RESTEasy runtime deployment by declaring resource and provider classes, JNDI resources, media type mappings, language extensions, and injector/dispatcher factories.
- RESTEasy Servlet Bootstrap: Initializes and destroys the RESTEasy server environment as a servlet lifecycle listener, running the deployment bootstrap.
- RESTEasy Servlet Deployment: Deploys a RESTEasy JAX-RS runtime inside a servlet container by bootstrapping providers, resources, and servlet mappings via web.xml.
- Server Deployment: Deploys and runs the HTTP server and its clients.
- Service Deployment: Deploying the web service artifact so that clients can reach it at a generated URL.
Request Parameter Binding
Binds HTTP request parameters from path, query, header, cookie, form, and matrix locations, including multi-valued and primitive conversions, into resource handlers.
- Cookie Parameter Binding: Binds HTTP cookie values to typed method parameters, including scalars and multivalued collections parsed via defaults, regex, or separators.
- Form Parameter Binding: Allows a user or client to bind HTTP form parameters to method arguments via the @FormParam annotation.
- HTTP Parameter Binding: Resolves and exposes HTTP request parameters (path, query, header, cookie, form, matrix, body, bean) with their name, type, and default value for injection into handlers.
- HTTP Parameter Binding and Conversion: Converts incoming request parameter values into typed Java arguments, including collection/array handling and blank/null fallbacks.
- HTTP Parameter Conversion: Converts HTTP request parameters and header values into typed Java values, including support for multi-valued parameters and separator-delimited string lists.
- Header Parameter Binding: Extract and convert HTTP header values into typed parameters.
- JAX-RS Parameter Binding: A REST resource that reads and writes request parameters from all JAX-RS parameter locations (path, query, header, cookie, matrix, and form), demonstrating both getter and setter access for each.
- Matrix Parameter Binding: Binds URI matrix parameters to Java primitive and primitive-list method parameters, with per-type default override support.
- Multi-Valued Query Parameter Binding: Binds multi-valued query parameters into collection and array types using defaults, regex, separators, or param converters.
- Parameter Conversion: Converts request parameters between representations by registering and applying parameter converter providers.
- Path Parameter Binding: Extract and convert multivalued path parameters from the request URI into typed parameters.
- Primitive Query Parameter Binding: Binds HTTP query parameters to primitive-typed resource method arguments so clients can pass typed values in requests.
- Query Parameter Binding: Adds query parameters to a client request by applying a parameter specification during proxy method invocation.
- Request Parameter Binding: Resolves method and constructor parameters from JAX-RS parameter annotations such as path, query, header, cookie, matrix, and form parameters.
Content Negotiation
Negotiates media types, languages, charsets, and encodings between client Accept headers and server representations to select the response variant.
- Accept-Language Negotiation: Exposes the client's accepted languages as a resource so callers can retrieve supported locales.
- Client Content Encoding Negotiation: Enables clients to request and honor content encodings via annotations so responses are transferred using the negotiated encoding.
- Content Language Negotiation: Client-requested language preferences are parsed into weighted language entries and resolved against supported locales to select a response language.
- Content Negotiation: Determines the acceptable media type for outgoing responses.
- HTTP Content Negotiation: Clients can request content in a specific negotiated representation and inspect the resulting headers, generic types, and response classes.
- Language Matching: Matches a requested language against available languages with configurable precision levels (exact, exact-country, or wildcard).
- Language Negotiation: Exposes the acceptable languages and the preferred request language, honoring language wildcards and caching parsed results.
- Media Type Comparison and Matching: Determines the best matching media type and ranks media types by specificity and quality, handling wildcards, composite types, and parameter compatibility.
- Media Type Negotiation: Selects the best matching media type from a request using quality factors and wildcard/specificity rules.
- Media Type Selection: Lets a user read and set the media type associated with a value.
- Server Content Encoding Negotiation: Selects a supported content encoding for responses based on the request's Accept-Encoding header and applies it to the response header.
- Variant Selection: Selects a specific content variant from the available variants for a request, taking into account character sets and media types.
Server-Sent Events
Streams server-pushed events to clients over persistent SSE connections with reconnection and event-sink lifecycle control.
- SSE Event Source: A client-side server-sent events source that delivers events to callbacks and reports completion or errors.
- SSE Field Parsing: Parsing of the individual SSE line prefixes (comment, data, id, name, retry) and line terminators.
- SSE Reconnection: Provides automatic reconnection to a Server-Sent Events (SSE) endpoint, including open-state detection and reconnect delay handling.
- SSE Subscription Lifecycle: Manages the closing of an SSE event stream and its underlying sink with registered listeners.
- Server-Sent Event Broadcast: Broadcasting server-sent events to connected sinks and delivering them asynchronously via an output queue.
- Server-Sent Event Creation: Builders and accessors allow a user to construct and configure an outbound server-sent event with optional id, name, comment, data, media type, escape flag, generic type, and reconnect delay.
- Server-Sent Event Stream Reading: Reads and parses an incoming Server-Sent Events stream into events for consumers.
- Server-Sent Event Streaming: Committing SSE headers and writing server-sent events to clients.
- Server-Sent Events: Streaming of events over SSE with event, data, id, retry, and comment fields and a dedicated media type.
- Server-Sent Events Broadcast: Server pushes live events to subscribed clients over a persistent SSE stream via a shared broadcaster.
- Server-Sent Events Source: Establishes and consumes a server-sent events stream, delivering events to registered consumers.
- Server-Sent Events Streaming: An SSE API container that streams server-pushed events to clients, using send and event-handling callables to deliver event data over a persistent connection.
URI, URL and Link Building
Builds URIs, URLs, and hypermedia links from templates and components for addressing and navigating resources.
- Endpoint URL Generation: Generates endpoint URLs used to address the deployed service and its resources.
- Hyperlink Navigation: Exposes JAX-RS link headers and link builders so clients can discover related resources.
- Hypermedia Link Generation: Builds and exposes hypermedia link resources (with rel, href/value, and parameter metadata) that clients follow to navigate the API.
- JAX-RS Link Builder: Creates hypermedia Link instances pointing to resources for HATEOAS-style responses.
- JAX-RS URI Builder: Programmatically constructs URIs relative to a base for use in resource responses.
- Link Construction: Building hypermedia links with a base URI, relative references, URI parameters, title, and type.
- Mock Server URL Generation: Capability to generate service URLs from the mock server, optionally with a default fallback, for clients to call.
- Resource URL Generation: Builds request URLs targeting the deployed REST resource endpoints.
- URI Building and Template Resolution: Build request URIs including path segments, matrix and query parameters, and resolved URI templates.
- URI Template Expansion: Build and expand URI templates, substituting path parameters into declared placeholders to produce a concrete URI.
- URL Construction: Constructs a URL endpoint that callers use to invoke the deployed test resource.
- URL Generation: Generate a URL for use by a client or caller.
CDI Integration and Dependency Injection
Discovers CDI beans and injects dependencies, context objects, and scoped resources into JAX-RS components via constructors, fields, and producers.
- CDI Bean Discovery: Discovers CDI beans in the application, including JAX-RS providers and resources, so they can participate in dependency injection.
- CDI BeanManager Discovery: Locates the CDI BeanManager through multiple fallback strategies so bean resolution can proceed in different runtime environments.
- CDI Constructor Injection: Supporting constructor-based dependency injection for beans, resolving lookup interfaces and types.
- CDI Context Injection: Allows injection of CDI-managed context types into RESTEasy components through proxied context producers and validation of context type beans.
- CDI Dependency Injection: Provides and accesses injected dependencies and their state within the reader.
- CDI Dependency Injection for JAX-RS: Provides CDI-based injection of JAX-RS resources and beans, resolving injection points and supplying property and delegate injectors.
- CDI Integration: Enables RESTEasy resources, providers, and applications to participate in CDI by discovering bean types and registering producers during CDI bootstrap.
- CDI Property Injection: Injects CDI-managed dependencies into fields or properties of a target object, enabling dependency injection for resources outside CDI's own instantiation.
- CDI Scope Resolution: Determines the CDI scope (application, request, session, dependent) declared on or applicable to a bean, including scope annotations and type closure.
- Context and Dependency Injection: The capability to inject and access application, security, resource, and servlet contexts and configuration into components.
- Dependency Injection: Supplies constructor arguments to callables via an injector so callers receive wired-up instances rather than constructing dependencies themselves.
Configuration and Properties Management
Supplies and resolves application, runtime, and deployment configuration parameters and properties.
- Application Configuration: Provides configuration and property values that drive how the greeting application behaves.
- Configuration Management: Build and apply configuration from property sources, factories, and builders.
- Configuration Options: A configurable set of named options with typed values, defaults, validation, and string conversion that users set to control service behavior.
- Configuration Parameter Access: Exposes named configuration parameters and their names to callers so they can read runtime settings by key.
- Context Parameter Configuration: Provides named context initialization parameters with values through the deployment descriptor for application-wide configuration.
- Property and Configuration Management: Exposes mutable configuration properties that users can set, query, and inject throughout the runtime.
- Runtime Configuration Properties: Reading, writing and querying configuration properties and mutable provider classes on the runtime.
- Servlet Initialization Parameters: Provides named configuration parameters to a servlet at startup via init-param name/value pairs.
- Servlet and Application Initialization Parameters: Provides per-servlet init parameters and application-wide context parameters for configuring behavior at startup.
- Servlet and Context Configuration Parameters: Provides named initialization and context parameters that configure servlets and the web application at startup.
- Servlet and Context Initialization Parameters: Supplies named initialization parameters at servlet and application-context scope for configuring deployed components.
Build and Project Model
Defines Maven-style project coordinates, dependencies, plugins, profiles, and build executions that drive the build.
- Build Configuration: Define and configure a software build project using Maven-style coordinates, packaging, dependencies, and build plugins.
- Build Configuration Definition: Define and assemble a build's container of dependencies, plugins, resources, and executions via a descriptive project model.
- Build Execution: Capability to define and run build goals bound to lifecycle phases with execution options such as skipping and forking.
- Build Lifecycle Execution: Runs the configured build lifecycle including plugin executions and reactors.
- Build Plugin Configuration: Configure build plugins, their goals, executions, and phases.
- Build Profile Activation: Defines build profiles and the conditions under which they are activated.
- Dependency Management: Declares and resolves project dependencies with scope, version, and optionality constraints.
- Maven Project Model: Capability to represent and interpret a Maven project build definition, including its coordinates, parent, configuration, dependencies, and resources.
- Profile Activation: Selects and activates configuration profiles that can alter the effective build.
- Project Model Configuration: Represents and configures a build project's coordinates, packaging, dependencies, build directory, and version via a code container and its data elements.
Cryptographic Operations
Provides symmetric and asymmetric encryption, signing, verification, and key management for securing data and messages.
- AES Decryption: Decrypt AES-CBC encrypted data back to plaintext.
- AES Encryption: Encrypt data using AES-CBC with an initialization vector.
- Asymmetric Encryption: Provides public-key cryptographic operations using RSA and ECDSA for encryption and digital signatures.
- Cryptographic Signing: Creates a signer that produces cryptographic signatures.
- Digital Signature Signing: Produces a cryptographic signature over data using an RSA algorithm provider.
- Digital Signature Verification: Verifies a cryptographic signature, including via a certificate.
- Hash Digest Construction: Builds a digest hash value by assembling input with prefix (prepend) and suffix (append) segments around a colon-delimited body.
- Key Generation: Generates cryptographic secret keys with a configurable bit length for use in encryption.
- RSA Encryption: Encrypts plaintext using RSA, producing ciphertext with associated key material, IV, and authentication data.
- Symmetric Encryption: Provides AES-based symmetric encryption of data using a generated secret key and cipher parameters.
HTTP Client Configuration
Builds and configures clients with engines, executors, timeouts, connection pooling, proxies, redirects, and cookies.
- Client Builder Configuration: Build a configured REST client, including provider factory, response buffer sizing, and applying configuration from an existing builder.
- Client Configuration: Allows users to configure and customize a client's runtime behavior through registered contracts, providers, properties, and features.
- Connection Pooling and Timeout Configuration: Controls connection pool size, per-route limits, connection TTL, checkout and established-connection timeouts, and read/socket timeouts.
- Cookie Management: Enable or disable automatic HTTP cookie handling by the client.
- Executor Service Configuration and Setup: Configure and set up a custom executor service (delegate, URL, overrides) for clients.
- HTTP Client Configuration: Configures an HTTP client's connection behavior including proxy settings, timeouts, redirects, cookies, SNI, and SSL context.
- HTTP Proxy Configuration: Allows users to configure HTTP proxy settings, including host, port, and scheme, and to override the proxy configuration.
- Proxy Configuration: Configure an HTTP proxy host, port, and scheme for the client's outbound connections.
- REST Client Configuration: Builds and configures REST client instances from builders and configuration providers.
- Redirect Following: Allows clients to be configured to automatically follow HTTP redirects.
Multipart and MIME Handling
Parses and writes multipart/mixed, form-data, and related MIME content, including file uploads and XOP attachments.
- File Upload: Writes streamed content into a target file on disk.
- MIME Message Parsing: Parses MIME entities and messages, decomposing them into headers, bodies, and multipart parts through a streaming builder.
- MIME Message Parsing Workaround: Parses MIME messages while working around known issues in the underlying MIME parsing library.
- Multipart File Upload: Builds and sends multipart/form-data requests that carry file content parts with per-part content type and encoding metadata.
- Multipart Form Data Handling: Provides a container and accessor/mutator operations for representing and retrieving multipart form-data fields and their mapped values.
- Multipart Form Data Processing: Parses incoming multipart form submissions into a structured, individually addressable map of form parts so handlers can read uploaded fields and file parts.
- Multipart Form Data Writing: Writes multipart/form-data payloads for HTTP requests by composing parts with filenames and streaming them asynchronously or synchronously.
- Multipart Request Parsing: Parses multipart/form-data requests by reading and exposing individual parts from an incoming multipart stream.
- Multipart/Related Parsing: Parse a Multipart/Related document into its root part and related parts, starting from the start or start-info headers.
- XOP/MTOM Multipart Attachment Handling: Reads and writes SOAP messages with MTOM/SWA attachments carried as XOP multipart/related content, exposing attachment parts as streams, byte arrays, or data handlers.
Reactive and Streaming Responses
Delivers responses reactively and incrementally through async streams, observables, publishers, and chunked or SSE streaming.
- Async Streaming Output: Provides asynchronous streaming output so a caller can consume results incrementally as they are produced rather than waiting for a complete response.
- Asynchronous Streaming Output: Provides a streaming output provider that lets callables write response data asynchronously to the client.
- Chunked Response Streaming: Streams publisher responses back to the client in chunks, including handling of infinite streams and slow async writers.
- Observable Response Streaming: Exposes request results as reactive observable streams of strings, bytes, things, or thing lists.
- Reactive Client Support: Provides reactive invocation capabilities so clients can make asynchronous/reactive requests.
- Reactive HTTP Client: A client API that performs HTTP requests (GET, POST, PUT, DELETE, HEAD, TRACE, OPTIONS, METHOD) via a reactive Rx invoker, with typed and generic type response handling.
- Reactive Response Invocation: Provides and resolves a reactive-style invoker that handles response processing for a given provider.
- Reactive Stream Response Support: Enables JAX-RS resources to return RxJava2 Flowables and Reactive Streams Publishers as asynchronous responses by converting them to async streams.
- Reactive Subscription: Allow consumers to subscribe to reactive HTTP operations and observe emitted results.
- Server-Sent Events Streaming: Provides a server-sent events delivery capability where clients receive a push-based event stream over an interceptor-managed sink.
Testing Harness and Lifecycle
Provides test setup/teardown lifecycle hooks, test archives, and harnesses for exercising the system under test.
- Bean Reader/Writer Test Execution: Runs the bean reader/writer test scenario to validate reading and writing of beans.
- Deployment Setup: A capability to deploy and set up resources from generated URLs.
- JUnit Test Lifecycle Hooks: Lifecycle setup and teardown hooks to configure and clean up the test environment before and after test execution.
- Test Application Harness: Provides a bootstrapped application along with helper accessors and messages used to exercise the resource under test.
- Test Archive Creation: Programmatically assembling a deployable test archive for the async servlet scenario.
- Test Archive Generation: Creates deployable test archives for exercising validation scenarios.
- Test Class Lifecycle Hooks: Setting up and tearing down shared state around the test class lifecycle.
- Test Execution: Runs the test suite covering non-proxyable provider scenarios and initialization.
- Test Lifecycle Hooks: Provides setup and teardown behavior around test execution, including locale preservation before and after tests.
- Test Lifecycle Setup and Teardown: Run per-test and per-class setup/teardown behavior around test execution.
XML Processing and Security
Parses, marshals, and validates XML with configurable security hardening against DTD and external entity attacks.
- Document Security and Processing Controls: Exposes configuration switches that control secure XML/document processing such as DTD disabling and predefined entity expansion.
- Secure XML Processing: Protect XML parsing against external entity and DTD-based attacks by configuring secure processing and disabling dangerous features.
- XML Marshalling: Serialize objects to XML output through a configurable base marshaller with character-set and property handling.
- XML Marshalling and Unmarshalling: Read and write XML by converting objects to and from XML using JAXB marshallers and unmarshallers.
- XML Parser Configuration: Configure and obtain JAXB/SAX parsers through factories and parser providers with pluggable settings.
- XML Parser Security Hardening: Controls XML parser security settings such as DTD processing, external entity resolution, and the secure processing feature.
- XML Processing Security Hardening: Configurable hardening of XML parsing/processing by toggling DTD and external entity disabling and the secure processing feature.
- XML Schema Validation: Enables and configures schema-based validation during processing.
- XML Unmarshalling: Deserializes XML input into application objects via an unmarshaller.
- XXE Security Testing: Verifies XML parsing behavior with and without external entity expansion to guard against XXE vulnerabilities.
Asynchronous Request Processing
Suspends, resumes, times out, and cancels requests for non-blocking server-side handling via async contexts and responses.
- Async Callback Handling: Invoking callbacks on asynchronous completion, both success and error paths.
- Async Request Cancellation: Cancel an in-flight asynchronous request and observe its cancellation state and canceled metadata behavior.
- Async Request Suspension & Resume: A request handler can suspend processing and later resume it, allowing long-running work to complete asynchronously.
- Async Response Delivery: Allows the application to complete a previously suspended request by supplying an asynchronous response back to the client.
- Async Response Handling: Provides an asynchronous response that callers can consume via a CompletionStage.
- Async Timeout Handling: Allows requests to suspend until an async timeout handler resumes them or the timeout elapses.
- Asynchronous Request Processing: Suspending, resuming, and asynchronously completing requests via async contexts and managed executors.
- Asynchronous Request Suspension and Resume: A request can be suspended asynchronously and later resumed, allowing blocking or async I/O to defer the response without holding the request thread.
- Completion Stage Response Handling: Asynchronously handling HTTP responses via completion stages, including success, null, and exceptional outcomes.
Compression and Decompression
Compresses and decompresses payloads and HTTP responses via gzip/deflate for compact transfer.
- Data Compression: Compresses data using deflate-style compression so payloads can be stored or transmitted more compactly.
- Data Compression & Decompression: Provides deflate-based compression and decompression of data for users or calling systems.
- Data Decompression: Decompresses previously compressed data back to its original form using the recorded compression algorithm.
- GZIP Response Compression: Compression of HTTP responses using GZIP encoding, verified by tests and exercised through an HTTP client.
- GZIP Response Decoding: Automatically decodes GZIP-compressed HTTP response bodies for consumers of the intercepted client.
- GZIP Response Encoding: Compress HTTP responses using GZIP encoding so clients receive smaller payloads for encoded content.
- Gzip Compression: Optionally gzips data during encode/decode operations.
- Gzip Compression Support: Enables servers to serve gzip-compressed responses and allows tests to verify clients handle gzip-encoded HTTP responses.
- Gzip Decompression: Decompresses GZIP-compressed data and surfaces the result or an error message to the caller.
JOSE Tokens (JWS/JWE/JWT)
Builds, signs, encrypts, and validates JWS, JWE, and JWT tokens with configurable algorithms and claims.
- JSON Web Token Issuance: Ability to create a JSON Web Token representing a principal with standard claims and timestamps.
- JWE Decryption: Decrypts a compact JWE input into its raw content using configured keys and providers.
- JWE Encryption: Build and produce JSON Web Encryption (JWE) tokens using configurable encryption algorithms and compression.
- JWE Encryption Method Selection: Supports selecting from a set of JWE content encryption algorithms (AES-CBC-HMAC and AES-GCM variants) with their associated content encryption key bit lengths.
- JWS Signature Verification: Verify a JSON Web Signature against its signing input and key material.
- JWS Signing: Produces a signed JWS using a selected signing/ hash algorithm and key identifier.
- JWT Claim Inspection: Ability to read the standard registered claims of a JSON Web Token, such as subject, issuer, audience, and timestamps.
- JWT Signing and Verification: Provides RSA-based JWT token creation and verification with configurable content type headers.
Message Signing and Verification
Signs outbound HTTP messages and verifies incoming signatures and body hashes for authenticity and integrity.
- Digital Signing: Digital signing header creation that produces signed headers for outgoing messages.
- HTTP Message Signing: Signs outgoing HTTP messages using configured private keys and certificates.
- HTTP Request Signing: Ability to cryptographically sign outgoing HTTP requests with a hash and signature for authenticated delivery.
- HTTP Signature Verification: Verifies cryptographic signatures on HTTP messages, including body hash checks, signature freshness/expiry, and algorithm/key validation.
- Message Body Signing: Digitally sign HTTP request and response message bodies using SMIME/pkcs7 signatures to guarantee authenticity and integrity.
- Signature Header Parsing: Locates and parses signature-related headers and key material from incoming HTTP requests.
- Signature Verification: A capability to verify a signature against known verifications using a configured repository.
- Signed Request Verification: Verifies incoming signed requests by validating signatures and integrity of the request body.
REST Client and Proxy Invocation
Creates and invokes typed client proxies and web targets to call remote REST endpoints as methods.
- Client Proxy Invocation: Creates and manages client invoker proxies that execute HTTP method calls against remote services.
- Dynamic Resource Proxy Creation: Creates client-side proxies for RESTEasy resources, including support for determining the currently active proxy instance.
- HTTP Client Invocation Building: Building and issuing HTTP requests against a target resource via a client invocation builder, including GET and POST methods.
- Proxied Endpoint Invocation: Client capability to invoke a remote REST endpoint through a generated proxy.
- REST Client Construction: Builds and configures a JAX-RS RESTEasy client with fluent builder options for provider registration and configuration.
- REST Client Proxy Creation: Create a typed client proxy for a JAX-RS resource interface so callers can invoke remote endpoints as Java methods.
- REST Client Proxy Invocation: Allows users to create a type-safe client proxy over a REST target and invoke remote REST endpoints via an annotated interface.
- Web Target Access: Represent and expose a client web target as a building block for requests.
Resource Method Routing and Matching
Matches incoming request URIs and HTTP methods to resource classes and methods and dispatches the invocation.
- Dynamic Dispatch: The capability to resolve and dispatch a request to a handler dynamically at runtime.
- Request Routing Match: Matches an incoming HTTP request against candidate resource method segments to find the methods that handle it.
- Resource Invocation: Invoking a resource endpoint through a ResourceInvoker, including HTTP method resolution, accepts/produces content-type negotiation, and dispatching the invocation.
- Resource Location: Resolve and locate resource methods and classes by URL path so requests can be dispatched to the correct handler.
- Resource Locator Resolution: Builds locators and resolves sub-resources to determine the correct target for a request.
- Resource Method Invocation: Matching incoming requests to resource methods and invoking the target method.
- URI Path Matching and Resource Resolution: Matches incoming request paths against registered resource templates, tracking the start position and matched path segments to identify the target resource.
- URI Template Matching: Match incoming request URIs against resource templates to route requests to the correct resource.
TLS/SSL Configuration
Configures SSL contexts, truststores, keystores, hostname verification, and SNI for secure client and server connections.
- Hostname Verification: Configure hostname verification policy and verification mode (strict or wildcard) for TLS connections.
- SNI Hostname Configuration: Configure Server Name Indication (SNI) hostnames presented during TLS handshakes.
- SSL Client Authentication: Provides SSL/TLS client authentication and SSL context configuration for secure connections.
- SSL Context Configuration: Enables configuration of SSL/TLS key managers and trust managers for secure connections.
- SSL Context Provisioning: Creation of client and server SSL contexts backed by keystores and truststores for secure connections.
- SSL and Trust Configuration: Configure keystores, truststores, SSL context, trust managers, and self-signed certificate acceptance for secure connections.
- TLS/SSL Configuration: Configures secure HTTPS connections via SSL context, keystore, truststore, hostname verification, and trust management.
- Trust Self-Signed Certificates: Enables clients to accept self-signed TLS server certificates by resolving a permissive SSL context and trust manager.
Authentication and Credentials
Authenticates requests using Basic, Digest, and Bearer token credentials and resolves the authenticated principal.
- Authentication Credentials Configuration: Supplies user-facing authentication inputs — username, password, and bearer token — plus SSL context for secured client connections.
- Basic Authentication: Authenticates a request by validating a supplied username and password against the credentials carried in the request's auth header.
- Bearer Token Authentication: Supports authenticating requests using a bearer token credential alongside username and password credentials.
- Digest Authentication: Enables clients to authenticate against a server using HTTP Digest authentication by building requests with digest credentials and processing server challenges.
- HTTP Basic Authentication: Clients can authenticate to a protected endpoint using HTTP Basic credentials, with discovery and validation of the Basic auth challenge.
- HTTP Digest Authentication: Client-side HTTP Digest authentication capability for authenticating requests against a server.
- User Authentication: Users authenticate by supplying credentials that expose a username and password for login.
Authorization and Access Control
Enforces role-based and resource-level authorization on requests and grants or denies access to protected resources.
- Basic Auth Access Control: Provides HTTP Basic Auth secured resource access where requests are allowed either for any authenticated user or restricted to authorized users only.
- Forbidden Access Handling: The system returns and surfaces a distinct forbidden-access response when an authenticated client lacks permission.
- Permission Checking: Determines whether a requested permission is granted to a target within a given context.
- Resource Access Authorization: Grants or refuses access to resources based on an authorization check.
- Role-Based Access Control: Restrict access to application resources based on user roles, with options to permit all, deny all, or allow specific roles for a given method.
- Role-Based Authorization: Allows checking whether a given user holds a particular role.
- Security Check: A resource that performs security checks on incoming client requests using configuration and URI information.
Bean Validation
Validates beans, method parameters, and return values against constraints and reports constraint violations.
- Bean Validation: Validates objects, method parameters, and return values against declared constraints, producing constraint violations on failure.
- Bean Validation Execution: Validates method parameters, return values, and constrained fields/properties at runtime, producing constraint violations for callers.
- CDI Constraint Validation: Validates CDI-managed beans and method parameters against bean validation constraints, exposing a validator that can be checked from CDI contexts.
- Constraint Validation: Validates input values against constraints, producing pass/fail results with messages for the caller.
- Constraint Violation Reporting: Reports constraint violations with details such as message, path, and payload to the caller.
- Field Constraint Validation: Validates constraints declared on individual fields of a class.
- Method Parameter and Return Value Validation: Validates a method's parameters and return value against declarative constraints, exposing validity checks and consolidated violation reporting.
Caching
Caches HTTP responses, values, and keys with bounded size and expiration, including conditional ETag-based validation.
- Bounded Cache with Percentage Allowance: A size-limited in-memory cache with optional percentage-based overcommit allowance and LRU eviction.
- Browser Cache: Provides a cache for storing, retrieving, and evicting named browser-cached values with expiration.
- Cache Management: Provides an in-memory map-based cache supporting storing, retrieving, inspecting, and removing cached entries.
- Cached Value Lookup: Enables lookup of cached values by key, including retrieving any or all matching entries.
- HTTP Response Caching: Serving cached HTTP responses with conditional ETag-based validation to clients.
- Key Caching: Cache discovered public and private keys and expire them after a configurable timeout.
- Request Caching: Caches processed requests and responses using a keyed cache to serve repeated requests.
What was analyzed
- Java · 3,948 files · 231,725 lines
- AsciiDoc · 63 files · 11,902 lines
- Maven · 56 files · 7,861 lines
- XML · 158 files · 3,769 lines
- Properties · 34 files · 906 lines
- YAML · 12 files · 884 lines
- Bourne Shell · 3 files · 679 lines
- JavaScript · 1 file · 166 lines
- DOS Batch · 1 file · 165 lines
- Text · 11 files · 163 lines
- Python · 7 files · 101 lines
- Other (7 languages) · 10 files · 120 lines
Whole repository: 4,446 files. cloc 2.06 counts 258,441 lines of code in 4,304 of them (355,978 lines with comments and blanks).
Where this came from
Extracted by CoreStory V3 (build 4470 with two small engine fixes) using DeepSeek-V4.1-Flash from the public repository at commit 4847d10 on 2026-11-15. Capability descriptions are from the same run.
- Repository resteasy/resteasy
- Commit 4847d1029a207152d818baa388fad50bd2a9403d
- Line counts cloc 2.06
- Rule citations Each rule shown was checked: its quote was compared with the repository source at the cited lines at this commit.
Code excerpts are from the upstream repository and remain under its Apache-2.0 license. CoreStory is not affiliated with or endorsed by the RESTEasy project.
Want this for your own codebase?
Talk to us about mapping the business rules in your repositories.