You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@juneau.apache.org by ja...@apache.org on 2026/07/01 18:56:38 UTC
(juneau) 01/02: Merge test-module docs into juneau-test + documentation sweep
This is an automated email from the ASF dual-hosted git repository.
jamesbognar pushed a commit to branch docs
in repository https://gitbox.apache.org/repos/asf/juneau.git
commit 3c6aced9c6e5517c7b50d229f90d236f28020e77
Author: James Bognar <ja...@apache.org>
AuthorDate: Wed Jul 1 12:28:30 2026 -0400
Merge test-module docs into juneau-test + documentation sweep
Documentation for the juneau-assertions/juneau-bct/juneau-junit5 -> juneau-test
module merge:
- Collapse the assertions + bct sidebar categories into a single juneau-test
category (Assertions / Bean-Centric Testing / JUnit Extensions).
- Add the JUnit Extensions page (08.04.JuneauTestJUnitExtensions.md).
- Update artifact/module names, Maven snippets, package references and javadoc
doclinks to juneau-test / org.apache.juneau.test.*.
- Rewrite removed asJson() assertion examples to asString(serializer.asFunction()).
- Remove assertions/bct content from the shaded-jar pages.
- Add a 10.0.0 breaking-change/migration release note.
- Regenerate static/ai artifacts.
Also includes an in-progress documentation formatting normalization sweep
(heading levels) and new overview pages (Commons, SimpleVariableLanguage,
BeanContextOverview, MicroserviceOverview).
Co-authored-by: Cursor <cu...@cursor.com>
---
README.md | 5 +-
.../02.06.CodeFormattingStylesheet.md | 20 +-
pages/release-notes/10.0.0.md | 58 +--
pages/release-notes/9.2.0.md | 66 ++--
pages/release-notes/9.5.0.md | 432 ++++++++++-----------
pages/topics/01.01.01.Commons.md | 269 +++++++++++++
pages/topics/01.01.JuneauEcosystemOverview.md | 8 +-
pages/topics/01.02.01.SimpleVariableLanguage.md | 95 +++++
pages/topics/01.02.02.BeanContextOverview.md | 298 ++++++++++++++
pages/topics/01.02.Marshalling.md | 110 +-----
pages/topics/01.04.RestServer.md | 14 +-
pages/topics/01.05.RestClient.md | 2 +-
pages/topics/01.06.DtoBeans.md | 8 +-
pages/topics/01.08.FluentAssertions.md | 13 +-
pages/topics/02.01.JuneauMarshallBasics.md | 8 +-
pages/topics/02.03.SerializersAndParsers.md | 14 +-
.../02.08.01.MarshalledNodeAndJsonPointer.md | 16 +-
pages/topics/02.21.PojoCategories.md | 6 +-
pages/topics/02.23.Encoders.md | 6 +-
pages/topics/02.24.ObjectTools.md | 14 +-
pages/topics/02.30.02.UonMethodology.md | 2 +-
pages/topics/02.31.02.UrlEncMethodology.md | 2 +-
pages/topics/03.01.JuneauMarshallRdfOverview.md | 8 +-
pages/topics/04.01.JuneauBeanBasics.md | 8 +-
pages/topics/04.03.JuneauBeanAtom.md | 2 +-
pages/topics/05.01.JuneauConfigBasics.md | 8 +-
pages/topics/06.01.JuneauCommonsBasics.md | 8 +-
pages/topics/06.02.01.JuneauCommonsCollections.md | 36 +-
pages/topics/06.02.02.JuneauCommonsUtils.md | 2 +-
pages/topics/06.02.05.JuneauCommonsLang.md | 10 +-
pages/topics/07.01.JuneauAssertionBasics.md | 18 +-
pages/topics/07.02.AssertionsOverview.md | 37 +-
pages/topics/08.01.JuneauBctBasics.md | 54 +--
pages/topics/08.02.CustomErrorMessages.md | 2 +-
pages/topics/08.03.01.Customization.md | 12 +-
pages/topics/08.03.02.Stringifiers.md | 2 +-
pages/topics/08.03.03.Listifiers.md | 2 +-
pages/topics/08.03.04.Swappers.md | 2 +-
pages/topics/08.03.05.PropertyExtractors.md | 2 +-
pages/topics/08.04.JuneauTestJUnitExtensions.md | 49 +++
pages/topics/09.01.JuneauRestCommonBasics.md | 8 +-
pages/topics/09.02.HelperClasses.md | 10 +-
pages/topics/09.04.HttpHeaders.md | 4 +-
pages/topics/09.05.HttpParts.md | 2 +-
pages/topics/09.06.HttpEntitiesAndResources.md | 4 +-
pages/topics/10.01.JuneauRestServerBasics.md | 8 +-
pages/topics/10.04.04.JavaMethodReturnTypes.md | 12 +-
pages/topics/10.04.05.JavaMethodThrowableTypes.md | 10 +-
pages/topics/10.05.01.HttpPartBasics.md | 4 +-
pages/topics/10.05.03.HttpPartAnnotations.md | 6 +-
pages/topics/10.05.08.HttpPartValidation.md | 12 +-
pages/topics/10.07.HandlingFormPosts.md | 2 +-
pages/topics/10.19.SvlVariables.md | 4 +-
pages/topics/10.29.04.BasicSwaggerInfo.md | 4 +-
pages/topics/10.29.05.SwaggerTags.md | 6 +-
pages/topics/10.29.06.SwaggerOperations.md | 4 +-
pages/topics/10.29.07.SwaggerParameters.md | 4 +-
pages/topics/10.29.09.SwaggerModels.md | 4 +-
pages/topics/10.31.04.HtmlPredefinedWidgets.md | 12 +-
pages/topics/10.32.LoggingAndDebugging.md | 6 +-
.../10.36.RestServerRateLimitAndRequestId.md | 8 +-
pages/topics/10.37.RestServerTestBeanInjection.md | 10 +-
pages/topics/10.48.SessionOptions.md | 6 +-
pages/topics/10.53.RestRpc.md | 20 +-
pages/topics/10.55.UtilityBeans.md | 20 +-
pages/topics/10.58.Log4j.md | 4 +-
.../12.01.JuneauRestServerSpringbootBasics.md | 10 +-
pages/topics/13.01.JuneauRestClientBasics.md | 12 +-
pages/topics/13.06.ResponseHeaders.md | 8 +-
pages/topics/13.07.ResponseContent.md | 8 +-
pages/topics/13.10.02.Remote.md | 6 +-
pages/topics/13.10.03.RemoteMethod.md | 6 +-
pages/topics/14.01.JuneauRestMockBasics.md | 8 +-
pages/topics/15.00.MicroserviceOverview.md | 265 +++++++++++++
pages/topics/15.01.JuneauMicroserviceBasics.md | 10 +-
.../topics/16.01.JuneauMicroserviceJettyBasics.md | 8 +-
pages/topics/16.06.Config.md | 2 +-
pages/topics/16.09.Extending.md | 6 +-
.../topics/17.01.JuneauMicroserviceTomcatBasics.md | 8 +-
pages/topics/18.02.ScServerOverview.md | 6 +-
pages/topics/18.03.ScClientOverview.md | 4 +-
pages/topics/20.01.JuneauExamplesCore.md | 10 +-
pages/topics/21.02.JuneauShadedCore.md | 22 --
pages/topics/21.06.JuneauShadedAll.md | 20 +-
pages/topics/22.02.MarshallingSecurity.md | 4 +-
pages/topics/22.05.ContentSecurityPolicy.md | 10 +-
sidebars.ts | 249 ++++++------
src/pages/about.md | 5 +-
src/pages/downloads.md | 3 +-
static/ai/juneau-knowledge.jsonl | 223 ++++++-----
static/ai/manifest.json | 8 +-
static/ai/taxonomy.json | 26 +-
92 files changed, 1893 insertions(+), 976 deletions(-)
diff --git a/README.md b/README.md
index 84d6163884..3c304965e5 100644
--- a/README.md
+++ b/README.md
@@ -56,7 +56,7 @@ Apache Juneau™ excels in the following scenarios:
* **Serverless unit testing of REST APIs** - Test REST services without servlet containers using MockRestClient for fast, comprehensive testing
* **Microservice development** - Build lightweight microservices with embedded Jetty or Spring Boot integration
* **Data transformation and mapping** - Convert between different data formats and handle complex object hierarchies with swap mechanisms
-* **Bean-Centric Testing and fluent-style assertions** - Write readable test assertions with comprehensive validation capabilities using juneau-bct and juneau-assertions
+* **Bean-Centric Testing and fluent-style assertions** - Write readable test assertions with comprehensive validation capabilities using juneau-test
* **Content negotiation and HTTP/2 support** - Handle multiple content types automatically with modern HTTP features
## Getting Started in 5 Minutes
@@ -275,8 +275,7 @@ Apache Juneau™ is a single cohesive Java ecosystem consisting of the following
* **juneau-marshall-rdf** - Additional support for various RDF languages.
* **juneau-bean-atom, juneau-bean-common, juneau-bean-html5, juneau-bean-jsonschema, juneau-bean-openapi-v3** - A variety of predefined serializable beans such as HTML5, Swagger and ATOM.
* **juneau-config** - A sophisticated configuration file API.
-* **juneau-assertions** - Fluent-style assertions API.
-* **juneau-bct** - Bean-Centric Testing framework that extends JUnit with streamlined assertion methods for Java objects.
+* **juneau-test** - Fluent-style assertions, Bean-Centric Testing, and JUnit 5 extensions.
* **juneau-svl** - Simple Variable Language for dynamic string processing.
* **juneau-rest-common** - REST APIs common to client and server side.
* **juneau-rest-server** - A universal REST server API for creating Swagger-based self-documenting REST interfaces using POJOs, simply deployed as one or more top-level servlets in any Servlet 3.1.0+ container. Includes Spring Boot and JAX-RS integration support.
diff --git a/pages/developer-info/02.06.CodeFormattingStylesheet.md b/pages/developer-info/02.06.CodeFormattingStylesheet.md
index 538ad87575..d159396d4d 100644
--- a/pages/developer-info/02.06.CodeFormattingStylesheet.md
+++ b/pages/developer-info/02.06.CodeFormattingStylesheet.md
@@ -52,7 +52,7 @@ The stylesheet includes comprehensive styling for standard JavaDoc elements:
The stylesheet provides extensive inline code highlighting tags for syntax coloring:
-#### Java Code Tags
+### Java Code Tags
- `<jc>` - Java comment (green)
- `<jd>` - Javadoc comment (#3f5fbf)
- `<jt>` - Javadoc tag (#7f9fbf, bold)
@@ -65,14 +65,14 @@ The stylesheet provides extensive inline code highlighting tags for syntax color
- `<jp>` - Java parameter (#654040)
- `<jv>` - Java local variable (#654040)
-#### XML Code Tags
+### XML Code Tags
- `<xt>` - XML tag (DarkCyan)
- `<xa>` - XML attribute (purple)
- `<xc>` - XML comment (mediumblue)
- `<xs>` - XML string (#00B, italic)
- `<xv>` - XML value (black)
-#### Other Code Tags
+### Other Code Tags
- `<mk>` - Manifest file key (DarkRed, bold)
- `<mv>` - Manifest file value (DarkBlue)
- `<cc>` - Config file comment (green)
@@ -80,7 +80,7 @@ The stylesheet provides extensive inline code highlighting tags for syntax color
- `<ck>` - Config file key (DarkRed)
- `<cv>` - Config file value (DarkBlue)
-#### Code Block Classes
+### Code Block Classes
- `.bcode`, `.bjava`, `.bjson`, `.bxml`, `.bini`, `.buon`, `.burlenc`, `.bconsole`, `.bschema` - Bordered code blocks with left border and background
- `.code` - Unbordered code block
@@ -95,18 +95,18 @@ The stylesheet provides extensive inline code highlighting tags for syntax color
### Special Classes
-#### Topic Headers
+### Topic Headers
- `h2.topic`, `h3.topic`, `h4.topic`, `h5.topic` - Styled topic headers with borders and background gradients
- Automatically includes a decorative icon
-#### Tables
+### Tables
- `table.styled` - Table with alternating row colors and styled borders
- `table.unstyled` - Plain table with borders but no row coloring
- `table.borderless` - Table without borders
- `table.plain` - Table with plain borders
- `table.striped` - Table with striped rows
-#### Lists
+### Lists
- `ul.toc`, `ol.toc` - Table of contents with styled background
- `ul.spaced-list`, `ol.spaced-list` - Lists with extra spacing between items
- `ul.javatree`, `ol.javatree` - Java class hierarchy lists with special markers
@@ -115,13 +115,13 @@ The stylesheet provides extensive inline code highlighting tags for syntax color
- `ul.values` - Values lists with automatic label
- `ul.format` - Format lists with automatic label
-#### Alert Blocks
+### Alert Blocks
- `div.info` - Information block (blue border, light blue background)
- `div.warn` - Warning block (orange border, light orange background)
- `div.severe` - Severe warning block (red border, light red background)
- `p.severe`, `p.warn`, `p.info`, `p.todo` - Paragraph-level alerts
-#### Special Elements
+### Special Elements
- `.bordered` - Adds border around images or blocks
- `.fixedWidth` - Forces block to be 800px wide
- `a.doclink` - Styled link to documentation with dotted underline
@@ -129,7 +129,7 @@ The stylesheet provides extensive inline code highlighting tags for syntax color
- `<review>` - Review marker block (yellow background)
- `<reviewed>` - Reviewed marker block (green background)
-#### Width Utilities
+### Width Utilities
- `.w400` - 400px width
- `.w500` - 500px width
- `.w800` - 800px width
diff --git a/pages/release-notes/10.0.0.md b/pages/release-notes/10.0.0.md
index c0982e6d91..1d26841591 100644
--- a/pages/release-notes/10.0.0.md
+++ b/pages/release-notes/10.0.0.md
@@ -32,7 +32,7 @@ No functional behavior was changed as part of this cleanup; all changes were pur
### juneau-marshall / juneau-commons
-#### View-based property projection (`@MarshalledProp(view=...)`)
+### View-based property projection (`@MarshalledProp(view=...)`)
Juneau now supports **view-based projection**: declare named views on bean properties and select an active
view per serialize/parse call so only the in-view properties are emitted or consumed. This is the Juneau
@@ -80,7 +80,7 @@ Jackson migration table.
### juneau-config / juneau-commons
-#### Config profiles + relaxed binding (cloud-native environment config)
+### Config profiles + relaxed binding (cloud-native environment config)
Juneau 10.0 adds two Spring-Boot-style ergonomics to the config + settings system, both additive and off-by-default
so existing configs are unaffected:
@@ -102,7 +102,7 @@ activation conventions, overlay/merge precedence, and the candidate-generation r
### juneau-microservice-jetty
-#### `JettyMicroservice` zero-config facade + bundled defaults
+### `JettyMicroservice` zero-config facade + bundled defaults
`juneau-microservice-jetty` now ships a thin convenience facade, `JettyMicroservice`, that collapses the `Microservice` + `JettyConfiguration` bootstrap into a single static call, plus classpath defaults for `jetty.xml` and `juneau.cfg`. End result: stand up a Jetty-backed Juneau microservice with one Maven dependency and one `@Bean Servlet`.
@@ -127,13 +127,13 @@ The `JettyMicroservice.run(...)` facade has three overloads:
- `run(String[] args, Servlet rootServlet, boolean startConsole)` — explicit console opt-in/out.
- `run(String[] args, WritableBeanStore beanStore, boolean startConsole, Class<?>... configurations)` — power-user form for callers contributing multiple `@Bean Servlet`s, custom `MicroserviceListener`s, or a parent bean store.
-#### `juneau-my-jetty-microservice` retired (BREAKING)
+### `juneau-my-jetty-microservice` retired (BREAKING)
The legacy `juneau-my-jetty-microservice` template module has been removed from the reactor. Consumers should migrate to the new `JettyMicroservice` facade in `juneau-microservice-jetty` — it delivers the same zero-config developer experience without requiring the consumer to copy a template project.
### juneau-microservice-jetty / juneau-microservice-tomcat
-#### Graceful shutdown + readiness gating (zero-downtime k8s rollouts)
+### Graceful shutdown + readiness gating (zero-downtime k8s rollouts)
Both embedded-server microservice flavors now perform a zero-downtime graceful shutdown suitable for rolling Kubernetes deployments, sharing one identical shutdown contract.
@@ -157,7 +157,7 @@ See the new [Graceful Shutdown & Readiness Gating](/docs/topics/GracefulShutdown
### juneau-microservice-test (new module)
-#### `@MicroserviceTest` — whole-microservice JUnit 5 integration tests
+### `@MicroserviceTest` — whole-microservice JUnit 5 integration tests
A new `juneau-microservice-test` module adds `@MicroserviceTest`, a JUnit 5 extension that boots a whole `Microservice` (config + lifecycle + embedded Jetty on an ephemeral port) for a test class — the standalone-microservice analog of Spring's `@SpringBootTest`.
@@ -172,7 +172,7 @@ See the new [Whole-Microservice Integration Tests (@MicroserviceTest)](/docs/top
### Build & packaging (BOM + curated bundles)
-#### Published BOM + curated dependency bundles
+### Published BOM + curated dependency bundles
Juneau now publishes a **Bill of Materials** and a small set of **curated dependency bundles** so consumers can depend on a coherent, version-aligned slice of the framework without hand-maintaining `<version>` tags — while keeping Juneau's **explicit-over-magic** configuration model (no Spring-style classpath auto-configuration).
@@ -202,7 +202,7 @@ A reactor-consistency guard (`scripts/check-bom-completeness.py`, wired into the
See the new [Dependency Management (BOM & Bundles)](/docs/topics/DependencyManagement) topic page for usage and the full explicit-over-magic rationale.
-#### GraalVM native-image feasibility verdict + Docker layering guidance
+### GraalVM native-image feasibility verdict + Docker layering guidance
A feasibility assessment of GraalVM **native-image** support for Juneau's reflection-heavy marshalling/bean core landed a **CONDITIONAL GO** verdict: all reflection is funnelled through one wrapper layer (`org.apache.juneau.commons.reflect.*`, single `setAccessible()` choke point) with no `Unsafe`/`MethodHandle`/bytecode generation, and the `BeanContext`/`ClassMeta` model already computes the exact member set reachability metadata needs — making a Juneau-authored metadata emitter realist [...]
@@ -210,7 +210,7 @@ A feasibility assessment of GraalVM **native-image** support for Juneau's reflec
Three new modules under a top-level `juneau-petstore/` aggregator together form the canonical Juneau petstore showcase application. The legacy `juneau-examples-rest{,-jetty,-springboot,-jetty-ftest}` family of modules has been retired in this release in favor of the petstore family — see the **Breaking Changes** section below.
-#### `juneau-petstore-core`
+### `juneau-petstore-core`
Shared, deployment-agnostic surface consumed verbatim by both the Jetty and Spring Boot deployments. Owns:
@@ -221,7 +221,7 @@ Shared, deployment-agnostic surface consumed verbatim by both the Jetty and Spri
- **No-build React SPA demo** — `PetstoreUiResource` mounts `StaticFilesMixin` to serve `htdocs/petstore-ui.html`, a single-page React UI that calls `/petstore/pets` over `fetch()`. Demonstrates the headless-JSON + decoupled-SPA pattern alongside the server-rendered HTML-doc UI; no Node/npm in the build (loads React from CDN as a v1 placeholder; production should vendor with appropriate NOTICE/LICENSE).
- **`PetSecureResource` + `StubBearerTokenValidator`** — auth-gated CRUD subset under `/petstore-secure/*`, gated by a `BearerTokenGuard` (fail-closed, op-level) backed by the in-memory stub validator. Demonstrates the bearer-token + `@Auth Principal` pattern; resource-Javadoc cross-references `AuthFilterChain` for multi-mechanism deployments.
-#### `juneau-petstore-jetty`
+### `juneau-petstore-jetty`
Jetty/`Microservice` deployment glue:
@@ -234,7 +234,7 @@ Jetty/`Microservice` deployment glue:
Launcher: `python3 scripts/start-petstore-jetty.py`.
-#### `juneau-petstore-springboot`
+### `juneau-petstore-springboot`
Spring Boot deployment glue:
@@ -248,13 +248,13 @@ Spring Boot deployment glue:
Launcher: `python3 scripts/start-petstore-springboot.py`.
-#### Parity story
+### Parity story
The core-hosted surface (CRUD, view demos, React SPA demo, auth-gated subset) is identical across both deployments by construction — it's shared code, not parallel copies. The deployment-specific surface (Jetty's microservice console + admin resources vs Spring Boot's `@Autowired` injection demo) is intentionally non-parity and documented as such.
### juneau-rest-common / juneau-rest-server
-#### Content Security Policy (CSP) support
+### Content Security Policy (CSP) support
Juneau can now emit `Content-Security-Policy` response headers for the HTML it serves, including dynamic per-request nonce support. New in this release:
@@ -266,7 +266,7 @@ See the new [Content Security Policy](/docs/topics/ContentSecurityPolicy) topic
This feature was inspired by an earlier proposal from **Gary Gregory** ([@garydgregory](https://github.com/garydgregory), PR #57); the implementation shipped here is a fresh one built against the current 10.0 APIs.
-#### Actuator-style management surface
+### Actuator-style management surface
Juneau 10.0 adds a coherent, discoverable **Actuator-style management surface** while keeping Juneau's a-la-carte composability. Every endpoint ships in two independently-mountable flavors — a composable `*Mixin` and a routed `*Resource` sharing one worker — and a convenience `BasicActuatorGroup` assembles them under one configurable path prefix (default `/actuator`, overridable via the `juneau.actuator.path` system property).
@@ -281,7 +281,7 @@ Exposure is **on-by-default-with-gating**: non-sensitive reads are exposed; muta
See the new [Management Surface](/docs/topics/ManagementSurface) topic page for the endpoint catalog, the `BasicActuatorGroup` one-liner, the exposure policy, and the manifest-stamping recipe.
-#### `/loggers` non-JUL backends (Logback, Log4j2)
+### `/loggers` non-JUL backends (Logback, Log4j2)
The `/loggers` endpoint (above) now drives a pluggable **`LogBackend`** instead of being hardwired to `java.util.logging`. `juneau-rest-server` still ships only the JUL backend (`JulLogBackend`, the default) so the core stays dependency-free, and a new opt-in **`juneau-rest-server-management-logging`** module adds `LogbackLogBackend` + `Log4j2LogBackend` (the backends declared `provided`, so they never leak transitively).
@@ -291,7 +291,7 @@ The `/loggers` endpoint (above) now drives a pluggable **`LogBackend`** instead
This closes the 174b JUL-only `/loggers` limitation. See the extended [Management Surface](/docs/topics/ManagementSurface#loggers-backends-jul-logback-log4j2) topic page.
-#### Host-side mixin overrides — `@Rest(mixinDefs=@Mixin(...))`
+### Host-side mixin overrides — `@Rest(mixinDefs=@Mixin(...))`
`@Rest(mixins=...)` (since 9.5.0) lets a mixin class declare its own `@Rest` settings that apply only to its endpoints — but the composition decision often belongs to the *host*. New in 10.0.0, the `@Rest(mixinDefs=@Mixin(...))` attribute lets a host declare a mixin **and** override selected `@Rest`-level settings for that mixin's endpoints, in one place, without editing or subclassing the mixin:
@@ -308,7 +308,7 @@ public class ApiResource extends BasicRestServlet { ... }
Internally this also normalized mixin discovery (one `ResolvedMixin` carrier for both bare and rich forms) and replaced the `RestContext.Args` boolean `mixinContext` flag with a typed `ContextKind` discriminator (`Root`/`Child`/`Mixin`). See [Host-side overrides with `@Mixin`](/docs/topics/RestServerMixinSubContexts#host-side-overrides-with-mixin-1000).
-#### Custom observations + one-dependency OTLP export + log correlation
+### Custom observations + one-dependency OTLP export + log correlation
Juneau 10.0 extends its request-boundary observability to cover custom (non-request) observations, ships a single OTLP export bundle, and adds OpenTelemetry trace-id log correlation — all keeping the explicit-over-magic, off-by-default contract (no classpath auto-configuration).
@@ -318,7 +318,7 @@ Juneau 10.0 extends its request-boundary observability to cover custom (non-requ
See the extended [Observability — Micrometer + OpenTelemetry](/docs/topics/RestServerObservability) topic page.
-#### Resource-level authentication — `RestAuthenticator`
+### Resource-level authentication — `RestAuthenticator`
Juneau 10.0 adds a `RestAuthenticator` SPI (`org.apache.juneau.rest.server.auth`) — an ergonomic, **in-resource** way to resolve a request's `Principal` + roles so `roleGuard`, `RoleBasedRestGuard`, `@Auth Principal`, and `req.isUserInRole(...)` all work with no container-managed security and no servlet-layer filter. It **complements** the [AuthN Filter Framework](/docs/topics/AuthFilterFramework) and reuses the same underlying auth implementations.
@@ -341,7 +341,7 @@ See the new [REST Authenticator — Resource-Level Authentication](/docs/topics/
### juneau-rest-client / juneau-rest-common
-#### Next-generation remote-proxy declarative features
+### Next-generation remote-proxy declarative features
Juneau 10.0 significantly expands what the [REST proxy](/docs/topics/RestProxyBasics) annotation family (`@Remote`, `@RemoteOp`, and the verb annotations `@RemoteGet` / `@RemotePost` / `@RemotePut` / `@RemoteDelete` / `@RemotePatch`) can express declaratively. Every addition below is honored by the **next-generation** proxy engine only (`RestClient.remote(...)` → `RemoteClient`); the classic `getRemote(...)` engine is unchanged and ignores these members.
@@ -358,7 +358,7 @@ See the expanded [Declarative Remote-Proxy Features](/docs/topics/NextGenRestCli
### juneau-marshall
-#### Token-Streaming and Record-Streaming API
+### Token-Streaming and Record-Streaming API
Juneau 10.0 introduces a public low-level streaming surface that complements the POJO databind path with cursor-based push and pull primitives, layered:
@@ -391,7 +391,7 @@ A full topic-page family lives under "2.50. Token / Record Streaming" in the Mar
The streaming surface is **purely structural** — object swaps and `@Schema` annotations apply only on the POJO databind path, never at the token layer. Both surfaces are additive; the existing POJO ↔ document API remains the primary, recommended path.
-#### JSON5L line-delimited format
+### JSON5L line-delimited format
Juneau 10.0 adds **JSON5L** — a new line-delimited format combining the relaxed [JSON5](/docs/topics/Json5) dialect with [JSONL](/docs/topics/JsonlBasics)'s one-document-per-line framing. It ships as a new `org.apache.juneau.marshall.json5l` package (`Json5lSerializer` / `Json5lParser` / sessions / `Json5lTokenReader`), a `Json5l` marshaller, and a `@Json5lConfig` annotation.
@@ -402,7 +402,7 @@ Juneau 10.0 adds **JSON5L** — a new line-delimited format combining the relaxe
See the new <a href="/docs/topics/Json5lBasics">JSON5L Basics</a> topic page.
-#### Inclusion knob: `nonDefault()` on `Serializer.Builder`
+### Inclusion knob: `nonDefault()` on `Serializer.Builder`
Juneau 10.0 adds a new serializer-side inclusion knob to suppress properties whose value equals the type's
default — the Juneau equivalent of Jackson's `@JsonInclude(NON_DEFAULT)`. It lives alongside the existing
@@ -432,7 +432,7 @@ The matching annotation setting is `@SerializerConfig(nonDefault = "true")`.
Precedence (first "omit" wins): `keepNullProperties` (handles `null` and `Optional.empty()`) →
`trimStrings` → `trimEmptyCollections` / `trimEmptyMaps` → `nonDefault`.
-#### Parser-side null coercion: `Nulls` policy
+### Parser-side null coercion: `Nulls` policy
A new `org.apache.juneau.marshall.Nulls` enum + matching `nulls` setting on `Parser.Builder` /
`@ParserConfig` / `@MarshalledProp` controls what happens when a `null` reaches a bean property during
@@ -464,7 +464,7 @@ var b = p.parse("{\"s\":null,\"t\":null,\"u\":null}", Bean.class);
See the new [Null & Inclusion Policies](/docs/topics/NullAndInclusionPolicies) topic page for the full
contract, including a Jackson migration table.
-#### First-class JDK datatype coverage (`OptionalInt` / `OptionalLong` / `OptionalDouble` / `BitSet`)
+### First-class JDK datatype coverage (`OptionalInt` / `OptionalLong` / `OptionalDouble` / `BitSet`)
Juneau 10.0 extends its direct, in-box JDK datatype coverage with first-class handling for the primitive
`Optional` variants — `OptionalInt`, `OptionalLong`, `OptionalDouble` — and for `BitSet`.
@@ -485,7 +485,7 @@ A new [Supported JDK Datatypes](/docs/topics/SupportedJdkDatatypes) topic page e
matrix and contrasts Juneau's first-class-in-box approach with Jackson's per-module `jackson-datatype-*`
family.
-#### `MarshalledNode` typed tree façade + RFC 6901 JSON-Pointer addressing
+### `MarshalledNode` typed tree façade + RFC 6901 JSON-Pointer addressing
Juneau 10.0 adds a typed tree façade and an RFC 6901 JSON-Pointer surface over the existing `MarshalledMap`/`MarshalledList` collections model (in `org.apache.juneau.marshall.collections`):
@@ -502,7 +502,7 @@ MarshalledNode.of(doc).set("/foo/bar/-", "z"); // appends -> ['x','y','z']
Both `MarshalledNode` and `JsonPointer` are marked **Beta — API subject to change**. See the new [Tree Model & RFC 6901 JSON-Pointer](/docs/topics/MarshalledNode) topic page.
-#### Protobuf binary wire-format codec
+### Protobuf binary wire-format codec
Juneau 10.0 adds a native, bean-driven **Protocol Buffers binary** serializer and parser in the new
`org.apache.juneau.marshall.protobuf` package — distinct from the existing text-format `marshall.prototext`
@@ -542,7 +542,7 @@ annotation.
See the new [Protobuf Binary Format Basics](/docs/topics/ProtobufBinaryBasics) topic page for the full
scalar/container mapping tables, field-number rules, and round-trip guarantees.
-#### Parquet external-read interop + binary-native logical types
+### Parquet external-read interop + binary-native logical types
Juneau 10.0 extends the Parquet codec to read spec-compliant files produced by external writers
(parquet-mr / Spark / Hive), not just files Juneau itself emits, and to understand the binary-native
@@ -599,6 +599,10 @@ _TBD — to be filled in as development continues._
- Resolution precedence is now: exact media-type match → explicitly-configured default → none.
- A response whose `Content-Type` matches no registered parser (and with no default parser configured) now fails with **`UnsupportedMediaType`** (HTTP 415) instead of silently parsing as JSON — affecting `ResponseBody.as(...)` and remote-proxy (`@Remote`) response deserialization. On the request/serializer side, serializing a POJO body with no matching or default serializer now throws a clear client-side `IllegalStateException` rather than defaulting to JSON.
- Migration: if you relied on the out-of-the-box JSON behavior, add `.defaultParser(JsonParser.DEFAULT)` and/or `.defaultSerializer(JsonSerializer.DEFAULT)` to your `RestClient.Builder`. The classic `org.apache.juneau.rest.client.classic.RestClient` is unaffected.
+- **Test modules merged into a single `juneau-test` artifact.** `juneau-assertions`, `juneau-bct`, and `juneau-junit5` have been consolidated into one commons-only module, `org.apache.juneau:juneau-test`, and the three old artifacts are removed (no relocation POMs). Migration:
+ - **Dependency:** replace any `juneau-assertions` / `juneau-bct` / `juneau-junit5` dependency with a single `juneau-test` dependency (dedupe where you used more than one).
+ - **Package renames:** `org.apache.juneau.assertions` → `org.apache.juneau.test.assertions`; `org.apache.juneau.junit5` → `org.apache.juneau.test.junit`; `org.apache.juneau.junit.bct` → `org.apache.juneau.test.junit.bct` (and `…bct.annotations` → `org.apache.juneau.test.junit.bct.annotations`). Update imports accordingly.
+ - **Removed JSON-assertion methods on `FluentObjectAssertion`:** `asJson()`, `asJsonSorted()`, `isJson(String)`, `isSameJsonAs(Object)`, `isSameSortedJsonAs(Object)`, `asString(WriterSerializer)`, and `isSameSerializedAs(Object, WriterSerializer)` are gone (the assertions module no longer depends on `juneau-marshall`). Where you still want JSON/serialized comparisons, pass a serializer explicitly via the new opt-in bridge: `assertObject(x).asString(Json5Serializer.DEFAULT.asFunction()) [...]
_Other entries TBD — to be filled in before release. See also the major version bump note above._
diff --git a/pages/release-notes/9.2.0.md b/pages/release-notes/9.2.0.md
index e9dc2b725d..c4b06134cc 100644
--- a/pages/release-notes/9.2.0.md
+++ b/pages/release-notes/9.2.0.md
@@ -28,7 +28,7 @@ Major changes include:
### juneau-dto
-#### juneau-bean-jsonschema
+### juneau-bean-jsonschema
- **JSON Schema Draft 2020-12 Compliance**: The `JsonSchema` bean has been upgraded to support JSON Schema Draft 2020-12 while maintaining backward compatibility with Draft 04.
@@ -59,7 +59,7 @@ Major changes include:
- Added `@BeanIgnore` to internal setters (`setName`, `setSchemaMap`) to prevent serialization issues in HTML round-trip tests
- Fixed fallback logic for deprecated properties to prevent double serialization
-#### juneau-bean-openapi3
+### juneau-bean-openapi3
- **Enhanced Test Coverage**: Achieved near 100% instruction coverage for all OpenAPI 3.0 beans
- Added comprehensive tests for `MediaType`, `Link`, `Example`, `RequestBody`, `Header`, `Encoding`, `SecurityScheme`, `OAuthFlows`, `OAuthFlow`, `ServerVariable`, `Discriminator`, `Xml`, `ExternalDocumentation`
@@ -76,7 +76,7 @@ Major changes include:
- Fixed `OpenApi.resolveRefs()` to properly handle `servers` array references
- Added null-safety checks in various `resolveRefs()` implementations
-#### juneau-bean-swagger
+### juneau-bean-swagger
- **Enhanced Test Coverage**: Achieved near 100% instruction coverage for all Swagger 2.0 beans
- Added comprehensive tests for `ParameterInfo`, `HeaderInfo`, `Tag`, `SecurityScheme`, `Xml`, `ExternalDocumentation`
@@ -89,7 +89,7 @@ Major changes include:
- Fixed `Swagger.resolveRefs()` to properly resolve references in nested structures
- Added null-safety checks in path and definition resolution
-#### juneau-bean-html5
+### juneau-bean-html5
- **`@Html(style)` Annotation**: Added `style()` property to the `@Html` annotation for applying CSS styles to HTML elements.
- Provides a simpler alternative to `@Html(render=...)` when only CSS styling is needed
@@ -125,7 +125,7 @@ Major changes include:
### juneau-core
-#### Multi-Key Cache and Concurrent Map Classes
+### Multi-Key Cache and Concurrent Map Classes
**Class Renaming for Consistency:**
@@ -198,14 +198,14 @@ String greeting = i18nCache.get("en", "US", 1); // "Hello"
- `ConcurrentXKeyHashMap` constructors no longer accept `disabled` or `supplier` parameters
- Passing null keys to `get()` or `put()` now throws `IllegalArgumentException` instead of bypassing cache
-#### License Header Standardization
+### License Header Standardization
- **Java Files**: Replaced non-standard comment-based license headers with the standard Apache License block comment format across all Java files
- **Properties Files**: Updated license headers in `.properties` files to use the standard format
- **XML Files**: Standardized XML license headers with proper comment syntax
- **Package Statement Fixes**: Corrected package statements that were in unusual positions after license header changes
-#### StringUtils Improvements
+### StringUtils Improvements
- **Input Validation for Hex Methods**: Added negative number validation to `StringUtils.toHex4()` and `StringUtils.toHex8()` methods to prevent invalid input processing:
- `toHex4(int)` now throws `NumberFormatException` for negative numbers
@@ -241,13 +241,13 @@ String greeting = i18nCache.get("en", "US", 1); // "Hello"
- Removed commented-out `list2()` method from `CollectionUtils.java`
- Preserved test method section headers as they serve as useful documentation
-#### Mockito Compatibility
+### Mockito Compatibility
- **Removed `final` Modifiers**: Removed `final` modifiers from many classes across the framework to improve testability with Mockito and other mocking frameworks that require non-final classes. This change makes it significantly easier to write unit tests for code that uses Juneau APIs.
### juneau-marshall
-#### Hjson (Human JSON) Support
+### Hjson (Human JSON) Support
- **New Hjson Serializer and Parser**: Added native support for Hjson (Human JSON), a syntax extension of JSON designed for human-friendly configuration files and hand-edited data.
- **Media types**: Produces `application/hjson`; accepts `application/hjson`, `application/hjson+json`
@@ -257,7 +257,7 @@ String greeting = i18nCache.get("en", "US", 1); // "Hello"
- **Readable and compact modes**: `Hjson.DEFAULT` (newlines between members) and `Hjson.DEFAULT_COMPACT` (single-line)
- See [Hjson Basics](/docs/topics/HjsonBasics) for full documentation.
-#### @Schema Annotation - JSON Schema Draft 2020-12 Support
+### @Schema Annotation - JSON Schema Draft 2020-12 Support
- **Draft 2020-12 Compliance**: The `@Schema` annotation has been upgraded to support JSON Schema Draft 2020-12 while maintaining full backward compatibility with Draft 04 (used by Swagger 2.0 and OpenAPI 3.0).
@@ -329,7 +329,7 @@ String greeting = i18nCache.get("en", "US", 1); // "Hello"
- Backward compatibility scenarios
- Precedence rules (new vs old style)
-#### HttpPartFormat - JSON Schema/OpenAPI Format Types
+### HttpPartFormat - JSON Schema/OpenAPI Format Types
- **Complete Format Coverage**: Added 18 new format types to the `HttpPartFormat` enum to align with JSON Schema Draft 2020-12 and OpenAPI 3.x specifications:
@@ -395,7 +395,7 @@ String greeting = i18nCache.get("en", "US", 1); // "Hello"
- Validation failures throw `SchemaValidationException` with detailed error messages
- Format validation integrates seamlessly with existing pattern, min/max length, and other validations
-#### Jakarta Bean Validation Integration
+### Jakarta Bean Validation Integration
- **Reflective Jakarta Validation Support**: `HttpPartSchema` now automatically detects and processes Jakarta Bean Validation constraints without requiring a direct dependency on `jakarta.validation-api`:
@@ -459,7 +459,7 @@ String greeting = i18nCache.get("en", "US", 1); // "Hello"
- **Enhanced OpenAPI Compatibility**: Jakarta Validation constraints are now seamlessly translated to OpenAPI schema properties, enabling automatic documentation generation and client-side validation in tools like Swagger UI.
-#### @PathRemainder Annotation
+### @PathRemainder Annotation
- **New Annotation**: Added `@PathRemainder` as an intuitive shortcut for `@Path("/*")` to capture the path remainder in REST endpoints.
@@ -496,7 +496,7 @@ String greeting = i18nCache.get("en", "US", 1); // "Hello"
- Updated `/docs/topics/09.03.04.PathVariables.md` with path remainder examples
- Updated `/docs/topics/11.10.08.Path.md` for remote proxy usage
-#### CSV Serializer - Object Swap Support
+### CSV Serializer - Object Swap Support
- **Full Object Swap Support**: The `CsvSerializer` now supports object swaps, bringing it to feature parity with other Juneau serializers like JSON, XML, and UON.
@@ -565,7 +565,7 @@ String greeting = i18nCache.get("en", "US", 1); // "Hello"
- `@Swap` annotation on bean fields
- Enum serialization
-#### XML Serialization
+### XML Serialization
- **Text Node Delimiter**: Added `textNodeDelimiter` property to `XmlSerializer` and `HtmlSerializer` to control spacing between consecutive text nodes.
@@ -599,7 +599,7 @@ String greeting = i18nCache.get("en", "US", 1); // "Hello"
**Note**: Disabling JSON tags can cause different data to be parsed (e.g., strings instead of numbers) since type information is not preserved in the XML.
-#### Bug Fixes
+### Bug Fixes
- **@Beanp Annotation Inheritance**: Fixed a critical bug where `@Beanp` and `@Name` annotations were not properly inherited when bean property methods (getters, setters, extraKeys) were overridden in subclasses without re-annotating them. This caused the serialization framework to create duplicate bean properties with different names (one from the parent's annotation, one from the method name), resulting in `SerializeException: ELEMENTS and ELEMENT properties found on the same bean. The [...]
@@ -686,11 +686,11 @@ String greeting = i18nCache.get("en", "US", 1); // "Hello"
### juneau-bct (NEW MODULE)
-#### Bean-Centric Testing Framework
+### Bean-Centric Testing Framework
A new testing module that provides fluent, powerful APIs for testing Java beans with minimal boilerplate code.
-#### Enhanced Stringifier Support
+### Enhanced Stringifier Support
- **New charArrayStringifier**: Added `charArrayStringifier()` to the `Stringifiers` class for simplified char array testing
- Converts char arrays directly to strings using `new String(chars)`
@@ -773,7 +773,7 @@ See the module documentation for complete API reference and examples.
### juneau-shaded (NEW MODULE)
-#### Shaded Artifacts for Simplified Dependency Management
+### Shaded Artifacts for Simplified Dependency Management
Introduced a new `juneau-shaded` module that provides five shaded (uber) JAR artifacts. These artifacts bundle multiple Juneau modules into single JARs, making them ideal for:
- **Bazel and strict dependency build systems** - Eliminates the need to manually declare all transitive Juneau dependencies
@@ -781,7 +781,7 @@ Introduced a new `juneau-shaded` module that provides five shaded (uber) JAR art
- **Standalone applications** - Convenient uber JAR deployment
- **Quick prototyping** - Get started faster with fewer dependency decisions
-#### Available Shaded Artifacts
+### Available Shaded Artifacts
| Artifact | Size | Contents |
|----------|------|----------|
@@ -791,7 +791,7 @@ Introduced a new `juneau-shaded` module that provides five shaded (uber) JAR art
| **juneau-shaded-rest-server-springboot** | 3.8 MB | REST server + Spring Boot integration |
| **juneau-shaded-all** | 4.0 MB | Complete Juneau framework in one JAR |
-#### Maven Usage
+### Maven Usage
```xml
<dependency>
@@ -801,7 +801,7 @@ Introduced a new `juneau-shaded` module that provides five shaded (uber) JAR art
</dependency>
```
-#### Bazel Usage
+### Bazel Usage
```python
maven_jar(
@@ -816,7 +816,7 @@ java_library(
)
```
-#### Key Features
+### Key Features
- **Bundles all Juneau modules** - No need to declare transitive Juneau dependencies
- **External dependencies still required** - Apache HttpClient, Jakarta Servlet API, etc. must be declared separately
@@ -825,7 +825,7 @@ java_library(
- **Service file merging** - Automatically merges `META-INF/services` files
- **Dependency-reduced POMs** - Shows exactly which external dependencies are needed
-#### Included in Distribution
+### Included in Distribution
All five shaded artifacts are now included in the binary distribution under `/shaded/`:
- `juneau-shaded-core-${version}.jar`
@@ -834,7 +834,7 @@ All five shaded artifacts are now included in the binary distribution under `/sh
- `juneau-shaded-rest-server-springboot-${version}.jar`
- `juneau-shaded-all-${version}.jar`
-#### Documentation
+### Documentation
- **[Shaded Artifacts Overview](/docs/topics/JuneauShadedOverview)** - Complete guide with Bazel examples
- **[juneau-shaded-core](/docs/topics/JuneauShadedCore)** - Core functionality
@@ -843,7 +843,7 @@ All five shaded artifacts are now included in the binary distribution under `/sh
- **[juneau-shaded-rest-server-springboot](/docs/topics/JuneauShadedRestServerSpringboot)** - Spring Boot
- **[juneau-shaded-all](/docs/topics/JuneauShadedAll)** - Complete framework
-#### Deprecation of juneau-all
+### Deprecation of juneau-all
The previous `juneau-all` module has been deprecated and removed in favor of `juneau-shaded-all`. The shaded version provides the same functionality with better support for modern build systems like Bazel.
@@ -853,7 +853,7 @@ The previous `juneau-all` module has been deprecated and removed in favor of `ju
### juneau-rest-client
-#### RestRequest and RestResponse
+### RestRequest and RestResponse
- **Try-With-Resources Support**: Enhanced `RestRequest` and `RestResponse` to work cleanly with try-with-resources blocks:
- `RestRequest` now implements `AutoCloseable` and automatically closes `RestResponse` if a response has been created
@@ -871,7 +871,7 @@ The previous `juneau-all` module has been deprecated and removed in favor of `ju
- **Improved Error Handling**: Added comprehensive logging for exceptions caught during cleanup to aid debugging while maintaining AutoCloseable compliance and preventing exception masking in try-catch blocks
-#### Remote Proxy Default Values
+### Remote Proxy Default Values
- **Parameter-Level and Method-Level Default Values**: Added support for specifying default values on remote proxy interface parameters and methods using the `def` attribute on HTTP part annotations:
- `@Header(name="...", def="...")` - Default HTTP request headers
@@ -944,7 +944,7 @@ The previous `juneau-all` module has been deprecated and removed in favor of `ju
### juneau-rest-server
-#### CallLogger Exception Statistics Fix
+### CallLogger Exception Statistics Fix
- **Fixed CallLogger.getThrownStats()**: Corrected the method to call `thrownStore.add(Throwable)` instead of `thrownStore.getStats(Throwable)`
- The `add()` method properly increments the exception count and creates new stats if needed
@@ -952,7 +952,7 @@ The previous `juneau-all` module has been deprecated and removed in favor of `ju
- This ensures accurate exception statistics tracking in REST call logging
- Exception counts and hashes are now properly maintained in the ThrownStore
-#### Class-Level HTTP Parameter Defaults
+### Class-Level HTTP Parameter Defaults
- **`@Rest` Parameter Arrays**: Added support for defining default HTTP parameter values at the REST class level that apply to all methods in the resource.
- **`queryParams={...}`**: Define default query parameter values
@@ -1011,7 +1011,7 @@ The previous `juneau-all` module has been deprecated and removed in favor of `ju
### Documentation
-#### Historical Javadocs
+### Historical Javadocs
- **Javadocs Archive**: Set up versioned javadocs hosting at `/javadocs/` with:
- Landing page with cards for all historical versions (7.1.0 through 9.1.0)
@@ -1021,11 +1021,11 @@ The previous `juneau-all` module has been deprecated and removed in favor of `ju
- **Git LFS Considerations**: Documented Git LFS limitations with Apache GitBox and alternative deployment strategies
-#### Known Issues
+### Known Issues
None at this time.
-#### Migration Notes
+### Migration Notes
- **juneau-all → juneau-shaded-all**: The `juneau-all` module has been removed. Update your dependencies:
diff --git a/pages/release-notes/9.5.0.md b/pages/release-notes/9.5.0.md
index 1d664b3f6e..ecdfcee184 100644
--- a/pages/release-notes/9.5.0.md
+++ b/pages/release-notes/9.5.0.md
@@ -14,7 +14,7 @@ Juneau 9.5.0 is a minor release with native OpenAPI 3.1 emission (alongside Swag
### juneau-marshall
-#### Duration/Period wire format controls (TODO-4)
+### Duration/Period wire format controls (TODO-4)
- Added new enum strategies:
- `org.apache.juneau.DurationFormat` (`ISO_8601`, `ISO_8601_WITH_DAYS`, `NANOS`, `MILLIS`, `SECONDS`, `HOCON`)
@@ -39,7 +39,7 @@ Juneau 9.5.0 is a minor release with native OpenAPI 3.1 emission (alongside Swag
.build();
```
-#### Date/time + Locale wire format controls (TODO-51)
+### Date/time + Locale wire format controls (TODO-51)
This is a **major-release breaking change**. The legacy `Temporal*Swap` inner-class family and named root-level temporal/locale/timezone swaps are removed without deprecation shims; configure formats via `MarshallingContext` or the new annotations instead.
@@ -83,7 +83,7 @@ This is a **major-release breaking change**. The legacy `Temporal*Swap` inner-cl
- Replace `@Swap(TemporalSwap.IsoXxx.class)` with `@MarshalledProp(temporalFormat=TemporalFormat.ISO_XXX)`.
- For context-level configuration, replace `swaps(TemporalXxxSwap.IsoYyy.class)` on serializer/parser builders with `xxxFormat(XxxFormat.ISO_YYY)`.
-#### Binary + Enum wire format controls (TODO-52)
+### Binary + Enum wire format controls (TODO-52)
This is a **major-release breaking change**. The legacy global `ByteArraySwap` family, the
`OutputStreamSerializer.Builder` / `InputStreamParser.Builder` `binaryFormat(...)` setters, and the
@@ -125,7 +125,7 @@ This is a **major-release breaking change**. The legacy global `ByteArraySwap` f
- Replace `OutputStreamSerializer.Builder#binaryFormat(...)` / `InputStreamParser.Builder#binaryFormat(...)` calls with the inherited `binaryFormat(...)` from `MarshallingContextable.Builder` (no source change needed for builder chains; the inherited setter has the same signature).
- Replace `useEnumNames()` / `useEnumNames(true)` with `enumFormat(EnumFormat.NAME)`.
-#### UUID + BigInteger/BigDecimal wire format controls (TODO-50, Phase 3)
+### UUID + BigInteger/BigDecimal wire format controls (TODO-50, Phase 3)
- Added new enum strategies under `org.apache.juneau`:
- `UuidFormat` (default `STANDARD`; also `NO_DASHES` for the 32-hex-character compact form, and `URN` for the RFC 4122 `urn:uuid:` namespace).
@@ -144,7 +144,7 @@ This is a **major-release breaking change**. The legacy global `ByteArraySwap` f
This completes the umbrella TODO-50 wire-format-control plan (Phases 1, 2, and 3 are all delivered in 9.5.0).
-#### Boolean / Float / Currency / Class wire format controls (TODO-54)
+### Boolean / Float / Currency / Class wire format controls (TODO-54)
Round-2 follow-up to TODO-50 extending the `MarshallingContext` format-control surface to four additional types. Same template (precedence chain, lenient parsers, binary-native fall-through) as the UUID / BigNumber phases.
@@ -181,7 +181,7 @@ Round-2 follow-up to TODO-50 extending the `MarshallingContext` format-control s
- **`CurrencyFormat.SYMBOL` / `DISPLAY_NAME` round-trip is best-effort and locale-dependent on parse.** ISO_CODE is the only constant with strict round-trip guarantees — `$` can resolve to USD / CAD / AUD / etc.; the parser prefers the locale's default currency on ambiguity and throws `IllegalArgumentException` when no match is found.
- **`ClassFormat.SIMPLE_NAME` is serialize-only** — `parse(...)` throws `UnsupportedOperationException`. Use `FQCN` (default) or `BINARY_NAME` for round-trippable wires.
-#### Format-control round-trip hardening (TODO-57)
+### Format-control round-trip hardening (TODO-57)
Closes out the format-control extension work (TODO-4 / TODO-50 / TODO-52 / TODO-54) with a cross-serializer/parser round-trip test matrix over all 16 `*Format` enums and 8 additional `TemporalFormat` subtypes. The matrix surfaced and closed 18 production bugs across the format-control dispatch layer; new public helpers and capabilities were added to support the fixes.
@@ -226,14 +226,14 @@ Closes out the format-control extension work (TODO-4 / TODO-50 / TODO-52 / TODO-
- New `.mvn/maven.config` containing `--also-make`. Affects developers running `mvn -pl <module> …` from the workspace root: upstream modules are now automatically added to the active reactor instead of being resolved from `~/.m2/repository`. Inert without `-pl`, so root-level builds (`mvn clean install`, `./scripts/test.py`, `./scripts/push.py`) and CI are unaffected. Fixes a long-standing developer-loop footgun where in-tree edits to upstream modules wouldn't be picked up by `mvn -pl j [...]
-#### Typed `JsonSchema` bean generation bridge (TODO-8)
+### Typed `JsonSchema` bean generation bridge (TODO-8)
- Added `JsonSchemaBeanGenerator` in `juneau-bean-jsonschema` to generate typed `JsonSchema` beans from Java types via `JsonSchemaGenerator`.
- Added static convenience factories on `JsonSchema`: `JsonSchema.of(Type)` and `JsonSchema.of(Class<?>)`.
- Added `JsonSchema` bean support for `format`, `$comment`, and `deprecated` so bean output preserves generator metadata.
- Added tests covering `JsonSchemaBeanGenerator` output parity with `JsonSchemaGenerator` map output and round-trip conversion.
-#### Schema validation mode for parsers and serializers (TODO-12)
+### Schema validation mode for parsers and serializers (TODO-12)
- Added an opt-in `validateSchema` flag on `MarshallingContext` that validates bean-property values against the constraints declared by `@Schema` annotations during both parsing (value set on the bean) and serialization (value read from the bean).
- Backed by a new `JsonSchemaValidator` in `juneau-bean-jsonschema` that implements JSON Schema Draft 2020-12 semantics on top of the typed `JsonSchema` bean.
@@ -252,7 +252,7 @@ Closes out the format-control extension work (TODO-4 / TODO-50 / TODO-52 / TODO-
p.parse("{\"name\":\"a\"}", MyBean.class); // throws ParseException - too short
```
-#### AI-friendly `summary` field on `@Schema` and related annotations (TODO-6)
+### AI-friendly `summary` field on `@Schema` and related annotations (TODO-6)
- Added a `summary` field (alias `su`) to `@Schema`, designed to hold a short, single-line description suitable for AI / LLM consumption, compact docs, and tooltips. Complements (and does not replace) the existing multi-line `description` field.
- `summary` flows through `SchemaAnnotation.asMap()` and `JsonSchemaGenerator` into the generated JSON Schema output under the key `"summary"`.
@@ -271,7 +271,7 @@ Closes out the format-control extension work (TODO-4 / TODO-50 / TODO-52 / TODO-
public class Pet { ... }
```
-#### Neutral `MarshalledMap` / `MarshalledList` collections + `Json5Map` / `Json5List` (TODO-34)
+### Neutral `MarshalledMap` / `MarshalledList` collections + `Json5Map` / `Json5List` (TODO-34)
A major refactor of the generic-model collection hierarchy. `JsonMap` / `JsonList` are no longer the
single one-size-fits-all generic-model types: they are now strict-JSON-flavored subclasses of a new
@@ -376,7 +376,7 @@ Per-language flavored `XMap` / `XList` pairs for the remaining marshallers (`Xml
land, parser sessions other than `JsonParserSession` / `Json5ParserSession` produce the neutral
`MarshalledMap` / `MarshalledList`.
-#### MessagePack media type normalized to `application/msgpack`
+### MessagePack media type normalized to `application/msgpack`
- `MsgPackSerializer` and `MsgPackParser` now use the RFC 6838-conforming `application/msgpack` as the
canonical media type. The previous invalid `octal/msgpack` value (`octal` is not a registered MIME
@@ -390,7 +390,7 @@ land, parser sessions other than `JsonParserSession` / `Json5ParserSession` prod
- Updated the `RestClient.msgPack()` / `RestRequest.msgPack()` Javadoc to document the new media-type
value sent on the `Accept` and `Content-Type` request headers.
-#### Bugs
+### Bugs
- **`@Inject`-method and constructor `@Value Optional<T>` parameters** now wrap resolved values
correctly (TODO-128). Previously, declaring a parameter as `@Value("${maybe}") Optional<String>`
@@ -434,7 +434,7 @@ land, parser sessions other than `JsonParserSession` / `Json5ParserSession` prod
### juneau-commons
-#### `@Value` annotation + `${xxx}` shortcut (TODO-79)
+### `@Value` annotation + `${xxx}` shortcut (TODO-79)
- Added `org.apache.juneau.commons.inject.Value` annotation for declarative injection of configuration
values into `BeanInstantiator`-created beans (fields, constructor parameters, setter parameters,
@@ -458,7 +458,7 @@ land, parser sessions other than `JsonParserSession` / `Json5ParserSession` prod
- `Optional<T>` field/parameter injection collapses `null` and empty-string results to
`Optional.empty()` — matching the "missing-key" intuition that consumers expect.
-#### SVL overhaul: `#{...}` scripting + `VarTemplate` compilation (TODO-102 + TODO-103)
+### SVL overhaul: `#{...}` scripting + `VarTemplate` compilation (TODO-102 + TODO-103)
This is a **major-release breaking change** in the SVL surface. The 11 single-purpose
transformation `Var` classes are removed without `@Deprecated` shims; their behaviour is
@@ -617,19 +617,19 @@ For any SVL template that uses one of the 11 removed `Var` prefixes, rewrite to
The full `${...}` shortcut, `$S{}`/`$E{}`/`$MF{}`/`$A{}`/`$P{}` source vars, and `$C{}` config
var keep their existing syntax — no migration required for those.
-#### Breaking changes
+### Breaking changes
- **`org.apache.juneau.commons.lang.Value` renamed to `Holder`.** The mutable reference-wrapper utility class has been renamed to `Holder<T>` to resolve an import-name collision with the `@Value` injection annotation. Update import statements: `import org.apache.juneau.commons.lang.Value` → `import org.apache.juneau.commons.lang.Holder`. No behavioral change.
- **`XValue` primitive-holder companions renamed to `XHolder`.** The nine typed primitive-holder subclasses have been renamed for consistency with the `Value` → `Holder` rename: `BooleanValue` → `BooleanHolder`, `ByteValue` → `ByteHolder`, `CharValue` → `CharHolder`, `DoubleValue` → `DoubleHolder`, `FloatValue` → `FloatHolder`, `IntegerValue` → `IntegerHolder`, `LongValue` → `LongHolder`, `ShortValue` → `ShortHolder`, `StringValue` → `StringHolder`. Update import statements and type refe [...]
-#### Security
+### Security
- **`LocalDir.resolve(...)` now enforces path-traversal boundary defensively (consistent with `FileUtils.resolveSafely(...)`).** On the filesystem-root branch, resolution is delegated to `FileUtils.resolveSafely(...)` which rejects any path that escapes the configured root (via `../`, absolute-path injection, or symlinks pointing outside the root) with `IllegalArgumentException`. On the classpath-resource branch, paths containing `..` segments are likewise rejected. This makes `LocalDir` [...]
### juneau-config
-#### Classpath-default `Config` bridge to `Settings` (TODO-79)
+### Classpath-default `Config` bridge to `Settings` (TODO-79)
- Added `org.apache.juneau.config.ConfigPropertySourceProvider`, a `META-INF/services`-discovered
`PropertySourceProvider` that bridges `Config.getSystemDefault()` (i.e. the classpath
@@ -649,14 +649,14 @@ var keep their existing syntax — no migration required for those.
`Settings.get().addSource(...)` registered later (microservice, `RestContext`, Spring) shadows
the classpath default at lookup time.
-#### YAML config format support (TODO-32)
+### YAML config format support (TODO-32)
- Added optional YAML config support to `juneau-config` alongside the existing INI/CFG format.
- Added format selection via config name extension (`.yml` / `.yaml`) and explicit builder methods (`.yaml()` / `.ini()`).
- Added path-style section support (e.g. `[foo/bar/baz]`) to align INI sections with nested YAML mappings.
- Updated default `FileStore` extension search order to include `cfg,yml,yaml` (with `cfg` remaining first for backward compatibility).
-#### Unified Property Source Hierarchy (TODO-27 + TODO-13)
+### Unified Property Source Hierarchy (TODO-27 + TODO-13)
- Added a new property-source SPI naming model: `PropertySource` / `PropertyStore` and functional variants.
- Added `PropertySourceProvider` (ServiceLoader SPI) so ambient sources can be auto-registered onto `Settings`.
@@ -666,7 +666,7 @@ var keep their existing syntax — no migration required for those.
- Existing `$S` / `$E` / `$A` / `$MF` vars remain supported as source-specific resolvers, now aligned with the unified settings model.
- **Breaking:** `SettingSource`, `SettingStore`, `FunctionalSource`, and `FunctionalStore` have been removed outright (no deprecation shims). Migrate to `PropertySource`, `PropertyStore`, `FunctionalPropertySource`, and `FunctionalPropertyStore` respectively.
-#### Bean→Marshalled Rename (TODO-21)
+### Bean→Marshalled Rename (TODO-21)
A comprehensive rename of annotation and engine types to clarify the distinction between *Java-bean-structure* types (which keep `BeanXxx` names) and *marshalling-process* types (which are now `MarshallingXxx`).
@@ -858,7 +858,7 @@ public class NewClass { @Override public String toString() { return "value"; } }
**Migration:** If you previously used `@BeanIgnore` on a class to force `toString()` serialization, replace it with `@Marshalled(as=STRING)`. If you truly want to suppress serialization (output `null`), use `@MarshalledIgnore`.
-#### Removed `@MarshalledProp(properties)` Attribute (breaking)
+### Removed `@MarshalledProp(properties)` Attribute (breaking)
The `@MarshalledProp(properties=...)` attribute has been removed. The attribute was used to limit which child properties of a nested bean/map are rendered by serializers:
@@ -881,17 +881,17 @@ The related internal types are gone too:
**Migration:** If you need per-property filtering for a serialization, use a custom `BeanFilter`/`@Marshalled(properties=...)` at the bean-class level instead, or configure include/exclude lists on the `MarshallingContext.Builder`. The marshalling-context-level filtering pre-dated `@MarshalledProp(properties)` and remains fully supported.
-#### `@Beanp("*")` on non-Map fields
+### `@Beanp("*")` on non-Map fields
On a field whose type is not a `Map`, `@Beanp("*")` (or `@Beanp(name="*")`) no longer tries to register a dyna property. The property name is taken from the field (via the configured `PropertyNamer`); other `@Beanp` attributes still apply. `Map` fields keep the dyna property `*` as before.
-#### HTML documentation: bare `request:` / `servlet:` / `context:` navlinks
+### HTML documentation: bare `request:` / `servlet:` / `context:` navlinks
`BasicHtmlDocTemplate` now treats bare navlink lines like `request:?Accept=...` or `request:/?Accept=...` (no `label:` prefix) as full marshall URIs. Previously the first `:` split dropped the scheme, producing relative `href` values that browsers resolved under the current path (e.g. `.../request:?Accept=...`). The same rejoin applies to `servlet:` and `context:` when the part after the colon starts with `/`, `?`, or `#`.
Labeled navlinks (e.g. `JSON: request:?Accept=...`) were already correct; the bug affected **bare** entries where the text before the first `:` is only the marshall scheme name.
-#### Native TOML Support
+### Native TOML Support
Juneau now includes built-in TOML (Tom's Obvious Minimal Language) v1.0.0 serialization and parsing support, implemented entirely without external library dependencies. TOML is a configuration file format widely used in projects like Cargo (Rust) and Python's `pyproject.toml`.
@@ -933,7 +933,7 @@ TOML is included in `BasicUniversalConfig` by default, or can be used standalone
See [TOML Basics](/docs/topics/TomlBasics) for full documentation.
-#### JSONL (JSON Lines) Support
+### JSONL (JSON Lines) Support
Juneau now includes built-in JSONL (JSON Lines / NDJSON) serialization and parsing support. JSONL is a text format where each line is a valid JSON value, widely used for LLM fine-tuning datasets, streaming AI inference, log aggregation, and bulk data pipelines.
@@ -972,7 +972,7 @@ JSONL is included in `BasicUniversalConfig` by default, or can be used standalon
See [JSONL Basics](/docs/topics/JsonlBasics) for full documentation.
-#### Server-Sent Events (SSE) Support
+### Server-Sent Events (SSE) Support
Juneau now ships with a native serializer / parser for the
[WHATWG Server-Sent Events](https://html.spec.whatwg.org/multipage/server-sent-events.html)
@@ -1055,7 +1055,7 @@ public class MyStreamResource {
See [SSE Basics](/docs/topics/SseBasics) for full documentation.
-#### BSON (Binary JSON) Support
+### BSON (Binary JSON) Support
Juneau now includes built-in BSON (Binary JSON) serialization and parsing support, implemented without external library dependencies. BSON is the binary serialization format used by MongoDB, extending JSON with typed integers (int32/int64), native datetime, decimal128, and binary data.
@@ -1095,7 +1095,7 @@ BSON is included in `BasicUniversalConfig` by default, or can be used standalone
See [BSON Basics](/docs/topics/BsonBasics) for full documentation.
-#### CBOR (Concise Binary Object Representation) Support
+### CBOR (Concise Binary Object Representation) Support
Juneau now includes built-in CBOR per [RFC 8949](https://www.rfc-editor.org/rfc/rfc8949.html) serialization and parsing support, implemented without external library dependencies. CBOR is a compact binary format designed for extremely small code size and message size, widely used in IoT, constrained environments, COSE (CBOR Object Signing and Encryption), and WebAuthn.
@@ -1132,7 +1132,7 @@ CBOR is included in `BasicUniversalConfig` by default, or can be used standalone
See [CBOR Basics](/docs/topics/CborBasics) for full documentation.
-#### HOCON Parser Enhancements
+### HOCON Parser Enhancements
The `HoconParser` now supports additional HOCON features for configuration files:
@@ -1144,7 +1144,7 @@ The `HoconParser` now supports additional HOCON features for configuration files
See [HOCON Basics](/docs/topics/HoconBasics) for full documentation.
-#### JCS (JSON Canonicalization Scheme) Support
+### JCS (JSON Canonicalization Scheme) Support
Juneau now includes built-in JCS (JSON Canonicalization Scheme) per [RFC 8785](https://www.rfc-editor.org/rfc/rfc8785). JCS produces a deterministic, byte-for-byte canonical representation of JSON data, enabling reliable cryptographic operations such as hashing and digital signing.
@@ -1181,7 +1181,7 @@ JCS is included in `BasicUniversalConfig` by default.
See [JCS Basics](/docs/topics/JcsBasics) for full documentation.
-#### JsonSerializer/JsonParser and Json5Serializer/Json5Parser Separation
+### JsonSerializer/JsonParser and Json5Serializer/Json5Parser Separation
`JsonSerializer` and `JsonParser` now strictly enforce RFC 8259 JSON (double-quoted strings only). Single-quoted JSON, comments, trailing commas, and unquoted keys are rejected by `JsonParser`.
@@ -1198,7 +1198,7 @@ For JSON5 syntax (single quotes, comments, trailing commas, unquoted keys), use
See [JSON Basics](/docs/topics/JsonBasics), [JSON Parsers](/docs/topics/JsonParsers), and [JSON 5](/docs/topics/Json5) for full documentation.
-#### Sorted Bean Properties by Default; `@Bean(unsorted)` Opt-Out
+### Sorted Bean Properties by Default; `@Bean(unsorted)` Opt-Out
Bean properties are now serialized in **alphabetical order by default** across all serializers. Previously, the default was natural JVM order and opting in to sorted output required explicit configuration.
@@ -1244,7 +1244,7 @@ JsonSerializer s = JsonSerializer.create().unsortedProperties().build();
- `BeanMeta.sortProperties` field — Renamed to `unsortedProperties` with inverted semantics. The field now stores `true` when the bean opts out of default sorted order, rather than `true` when sorted is explicitly enabled.
-#### `@BeanIgnore(ignoreAccessors=true)` on fields
+### `@BeanIgnore(ignoreAccessors=true)` on fields
`@BeanIgnore` gains **`ignoreAccessors`** (default **`false`**) for use on **fields**. When **`ignoreAccessors = true`**, `BeanMeta` also excludes the matching **JavaBean accessor pair** (`getX`/`setX`, or `isX` for booleans) from bean property discovery, so the property is omitted from serialization, parsing, and `BeanMap` metadata while accessors can remain for other frameworks.
@@ -1255,7 +1255,7 @@ The default **`false`** preserves existing behavior: `@BeanIgnore` on a field on
See [@BeanIgnore Annotation](/docs/topics/BeanIgnoreAnnotation).
-#### Protobuf Text Format Support
+### Protobuf Text Format Support
Juneau now includes built-in Protobuf Text Format serialization and parsing support, implemented without external library dependencies. This is the **human-readable** text format (not the binary wire format), suitable for configuration, debugging, and interop with tools that use the text format.
@@ -1293,7 +1293,7 @@ Proto is included in `BasicUniversalConfig` by default, or can be used standalon
See [Protobuf Basics](/docs/topics/ProtobufBasics) for full documentation.
-#### Full CSV Parser Support
+### Full CSV Parser Support
The `CsvParser` is now fully implemented. Previously, parsing always threw `"Not implemented."`.
The parser supports the same range of target types as other Juneau parsers.
@@ -1336,7 +1336,7 @@ date/time types, and any type supported by Juneau's `convertToType()`.
The unquoted literal `null` in a cell is parsed as Java `null`.
-#### CSV Serializer Fixes
+### CSV Serializer Fixes
- **RFC 4180 Quote Escaping**: `CsvWriter.writeEntry()` now correctly escapes embedded double-quote
characters by doubling them (`"` → `""`), as required by RFC 4180. Previously, values containing
@@ -1348,7 +1348,7 @@ The unquoted literal `null` in a cell is parsed as Java `null`.
See [CSV Basics](/docs/topics/CsvBasics) for full documentation.
-#### Native Markdown Support
+### Native Markdown Support
Juneau now includes built-in Markdown serialization and parsing support, implemented entirely without external library
dependencies. Markdown output is optimized for both human readability and LLM/AI consumption, with fragment mode
@@ -1378,7 +1378,7 @@ Markdown is included in `BasicUniversalConfig` and `RestClient.universal()` by d
See [Markdown Basics](/docs/topics/MarkdownBasics) for full documentation.
-#### Native YAML Support
+### Native YAML Support
Juneau now includes built-in YAML serialization and parsing support, implemented entirely without external library
dependencies. Like all other Juneau serializers and parsers, the YAML implementation uses a highly-efficient
@@ -1454,7 +1454,7 @@ See [YAML Basics](/docs/topics/YamlBasics) for full documentation.
`OpenApiYamlRoundTrip_Test#c01` had to scope to a single `OpenApiMixin` mount via
`noInherit={"mixins"}` to dodge the underflow; that workaround has been removed.
-#### Direct Iterator/Iterable/Stream/Enumeration Serialization
+### Direct Iterator/Iterable/Stream/Enumeration Serialization
`Iterator`, `Iterable` (non-Collection), `Enumeration`, and `java.util.stream.Stream` types are now serialized directly as arrays by all serializers without requiring intermediate `List` materialization.
@@ -1500,7 +1500,7 @@ String json3 = Json5Serializer.DEFAULT.serialize(iterable);
The POJO categories table has been updated. `Iterator`, `Iterable`, `Enumeration`, and `Stream` are no longer in the "swapped objects" category (group 4b). They are now in a new group (2c) alongside Collections and arrays as natively serializable sequence types.
-#### Large-Dataset Streaming APIs
+### Large-Dataset Streaming APIs
New interfaces and annotations enable streaming serialization and parsing of arbitrarily large
datasets without loading all elements into memory. Every serializer and parser format supports
@@ -1595,7 +1595,7 @@ public class EmployeeConsumer implements BeanConsumer<Employee> {
See [Large-Dataset Streaming](/docs/topics/LargeDatasetStreaming) for full documentation.
-#### Java Records Support
+### Java Records Support
Java records are now fully supported for both serialization and parsing across all serializers and parsers.
@@ -1651,7 +1651,7 @@ defaults for omitted components.
See [Java Records Support](/docs/topics/JavaRecordsSupport) for full documentation.
-#### Built-in Date/Time and Duration Serialization
+### Built-in Date/Time and Duration Serialization
Date, time, and duration types are now serialized and parsed natively as ISO 8601 strings by all serializers and parsers without requiring `ObjectSwap` registration.
@@ -1711,7 +1711,7 @@ The POJO categories table has been updated. `Calendar`, `Date`, `Temporal` subty
See [POJO Categories](/docs/topics/PojoCategories) for the updated table.
-#### RDF/THRIFT and RDF/PROTO Binary Format Support
+### RDF/THRIFT and RDF/PROTO Binary Format Support
The `juneau-marshall-rdf` module now includes full support for RDF/THRIFT and RDF/PROTO binary serialization formats, enabling compact binary representation of RDF graphs for efficient storage and network transfer.
@@ -1748,7 +1748,7 @@ RDF/XML, RDF/THRIFT, and RDF/PROTO are now included in the `RoundTripTest_Base`
See [RDF Basics](/docs/topics/RdfBasics) for full documentation.
-#### ClassInfoTyped
+### ClassInfoTyped
`ClassInfo.of(Class)` now returns `ClassInfoTyped<T>`, a generic subclass of `ClassInfo` that preserves the type parameter at compile time. The API remains identical—existing code continues to work without changes—but callers can now benefit from stronger typing:
@@ -1757,7 +1757,7 @@ ClassInfoTyped<String> ci = ClassInfo.of(String.class);
// ci carries type information for String
```
-#### Per-Session Property Overrides (Extended)
+### Per-Session Property Overrides (Extended)
`Session.Builder.property(String, Object)` and `properties(Map)` now dispatch to typed session-level setter methods across a broad range of serializer and parser session classes, enabling per-request override of serializer/parser configuration without rebuilding the context.
@@ -1810,7 +1810,7 @@ Several session classes were overriding accessor methods to return `ctx.isAddBea
Similarly, `ParserSession.isTrimStrings()` now returns the session-level field (initialized from the context) instead of delegating to `ctx.isTrimStrings()`. And `UonSerializerSession.getQuoteChar()` no longer bypasses the `WriterSerializerSession` session field.
-#### `MarshallUtils`: Static Serialization and Parsing Helpers
+### `MarshallUtils`: Static Serialization and Parsing Helpers
A new utility class, `org.apache.juneau.marshaller.MarshallUtils`, provides a single point of static
convenience methods for every serialization format supported by Juneau. All methods are designed to
@@ -1901,7 +1901,7 @@ Both marshaller classes were updated to expose the full static API:
`to(byte[], Type, Type...)` (Parquet parse methods return `List<T>` since the format is
always collection-oriented).
-#### `JsonMap` and `JsonList`: New `toX()` Serialization Methods
+### `JsonMap` and `JsonList`: New `toX()` Serialization Methods
The serialization helper methods on `JsonMap` and `JsonList` have been renamed from the `asX()` convention
to the `toX()` convention and extended with additional JSON-flavor methods.
@@ -1945,7 +1945,7 @@ The following `asX()` methods have been removed in favor of their `toX()` equiva
| `asReadableString()` *(JsonMap only)* | `toReadableJson5()` |
| `asString(WriterSerializer)` | `toString(WriterSerializer)` |
-#### `BasicBeanStore` precedence-aware affordances
+### `BasicBeanStore` precedence-aware affordances
`BasicBeanStore` (in `org.apache.juneau.cp`) gained two new affordances that power the 9.5 `RestContext` precedence flip (see *juneau-rest-server* below). Both are opt-in; existing call sites that use only `parent(...)` and local `addBean(...)` calls keep their current behavior.
@@ -1963,7 +1963,7 @@ overridingParent.getBeanSupplier(type, name) // outer scope (e.g. Spring)
`hasBean(...)` follows the same precedence; a new `hasDefaultSupplier(...)` accessor lets callers ask "is there a registered default for this type?" without forcing the supplier to fire.
-#### Removal of Legacy `cp` Injection Classes
+### Removal of Legacy `cp` Injection Classes
The following classes in `org.apache.juneau.cp` have been removed as part of the migration to the `org.apache.juneau.commons.inject` package:
@@ -1988,7 +1988,7 @@ The following classes in `org.apache.juneau.cp` have been removed as part of the
| `creator.orElse(default)` | `instantiator.asOptional().orElse(default)` |
| `new BeanCreateMethodFinder(type, obj, bs)` | `bs.createBeanFromMethod(type, obj, predicate)` |
-#### `BeanInstantiator` Static Convenience Methods
+### `BeanInstantiator` Static Convenience Methods
Three static factory helpers have been added to `BeanInstantiator` to eliminate verbose ternary patterns at common call sites:
@@ -2009,11 +2009,11 @@ listener = listenerCls == null ? null : BeanInstantiator.of(listenerCls).fallbac
listener = BeanInstantiator.createOrNull(ctx.getListener());
```
-#### `CreatableBeanStore` Removed
+### `CreatableBeanStore` Removed
`CreatableBeanStore` (in `org.apache.juneau.commons.inject`) has been removed. It was an unused internal interface with no production callers. `WritableBeanStore` serves as the write-capable interface for the inject package.
-#### `WritableBeanStore` → `BeanStore` in Builder Classes
+### `WritableBeanStore` → `BeanStore` in Builder Classes
The following builder-class constructors and fields have been narrowed from `WritableBeanStore` to `BeanStore` because they only perform read operations (bean lookup) on the store; they do not add beans:
@@ -2030,7 +2030,7 @@ The following builder-class constructors and fields have been narrowed from `Wri
Callers that previously passed a `WritableBeanStore` still compile without changes, since `WritableBeanStore` extends `BeanStore`.
-#### JSR-330 Alignment + Spring-Lite Additions in `commons.inject` (TODO-24)
+### JSR-330 Alignment + Spring-Lite Additions in `commons.inject` (TODO-24)
The `org.apache.juneau.commons.inject` package now presents a coherent injection story:
@@ -2099,7 +2099,7 @@ All JSR/Spring annotation recognition is **by fully qualified name** (FQN), so a
### juneau-marshall-rdf
-#### Upgraded Apache Jena to 5.6.0
+### Upgraded Apache Jena to 5.6.0
The Apache Jena dependency has been upgraded from 5.3.0 to 5.6.0. This is a drop-in upgrade with no API changes required in Juneau. The `juneau-marshall-rdf` pom has also been updated to reference the root `${jena.version}` property rather than a hardcoded version, keeping future upgrades centralized.
@@ -2107,7 +2107,7 @@ Note: Apache Jena 6.0 requires Java 21 and will be adopted when the project move
### juneau-core
-#### `BctConfiguration` defaults migrated to `@Value` (TODO-92)
+### `BctConfiguration` defaults migrated to `@Value` (TODO-92)
- `BctConfiguration` now exposes a static nested `Defaults` class whose two boolean fields
(`sortMaps`, `sortCollections`) are populated by concat-form `@Value` annotations:
@@ -2118,17 +2118,17 @@ Note: Apache Jena 6.0 requires Java 21 and will be adopted when the project move
have external production consumers and heavy Javadoc as part of the BCT public API. See
[@Value Framework-Internal Adoption](/docs/topics/ValueFrameworkInternal).
-#### ArrayUtils Deprecation
+### ArrayUtils Deprecation
`ArrayUtils` has been deprecated in favor of `CollectionUtils`. All array utility methods have been migrated to `CollectionUtils`, which now provides a single location for both array and collection operations. `ArrayUtils` methods delegate to their `CollectionUtils` counterparts and will remain available during the deprecation period.
**Migration**: Replace `ArrayUtils` usage with `CollectionUtils`. Methods such as `last()`, `append()`, `combine()`, `indexOf()`, `toList()`, `contains()`, and others are available in `CollectionUtils` with the same signatures.
-#### TupleXFunction Removed
+### TupleXFunction Removed
The `Tuple2Function`, `Tuple3Function`, `Tuple4Function`, and `Tuple5Function` classes have been removed. Use `Function2`, `Function3`, `Function4`, and `Function5` instead. The API is equivalent—replace `Tuple2Function` with `Function2`, and so on.
-#### ThrowableUtils Enhancements
+### ThrowableUtils Enhancements
New exception creation methods have been added to `ThrowableUtils`:
- `unsupportedOp(String msg, Object... args)` and overload with cause
@@ -2137,7 +2137,7 @@ New exception creation methods have been added to `ThrowableUtils`:
All methods support MessageFormat-style formatting. `BasicRuntimeException` has been retired in favor of `runtimeException()`.
-#### Value Class Enhancements
+### Value Class Enhancements
The `Value` family of classes has been expanded:
@@ -2146,23 +2146,23 @@ The `Value` family of classes has been expanded:
- **All Value classes**: New methods `orElse(X)`, `setIf(boolean, value)`, and `update(Function<V,V>)` for in-place modification.
- **`Value` base class**: Enhanced to mirror `Optional` with `empty()`, `filter(Predicate)`, `flatMap(Function)`, `ifPresent(Consumer)`, `map(Function)`, `orElseGet(Supplier)`, `orElseThrow(Supplier)`.
-#### Console.format Removed
+### Console.format Removed
`Console.format()` has been removed. It duplicated functionality already provided by `Utils.f()`. Use `Utils.f(String format, Object... args)` for MessageFormat-style formatting. `Console.err()` and `Console.out()` continue to work as before.
-#### `CollectionUtils.treeSet`
+### `CollectionUtils.treeSet`
**`CollectionUtils.treeSet(Comparator<? super E>, Collection<? extends E>)`** creates a modifiable **`TreeSet`** with the given comparator and adds all non-null elements from the collection (or none if the collection is **`null`**). Use with **`String.CASE_INSENSITIVE_ORDER`** for a case-insensitive sorted string set in one call.
-#### StringTokenSet
+### StringTokenSet
**`StringTokenSet`** (juneau-commons) builds an insertion-ordered unique set of string tokens. **`append(String...)`** splits each argument on commas with `StringUtils.split` escape rules, then applies mechanical rules (token starting with `-` and length > 1 removes the trimmed remainder; otherwise the token is added). **`appendAtomic(String...)`** applies one mechanical step per argument with no comma splitting. **`addAllPlain(Iterable)`** copies members without hyphen rules (used wh [...]
-#### `AnnotationInfo.getAnnotatable()`
+### `AnnotationInfo.getAnnotatable()`
**`AnnotationInfo.getAnnotatable()`** returns the **`Annotatable`** (class, method, field, …) where the annotation was found, for callers that need the annotation’s declaration site.
-#### Simple Variable Language (SVL) Moved to `juneau-commons` (TODO-14)
+### Simple Variable Language (SVL) Moved to `juneau-commons` (TODO-14)
The Simple Variable Language (SVL) engine — `VarResolver`, `VarResolverSession`, `Var`, and the bundled `vars/*` implementations — has been physically moved out of `juneau-marshall` into `juneau-commons` so that callers (including `juneau-config`, `juneau-microservice-core`, and downstream services) can depend on the variable-resolution engine without pulling in the full marshalling stack.
@@ -2223,7 +2223,7 @@ This lets each `VarResolver` instance carry its own per-resolver `Args` / `Manif
### juneau-bct
-#### BctAssertions API Changes
+### BctAssertions API Changes
The `AssertionArgs` class has been removed. Assertion methods now use a leading `Supplier<String>` parameter for custom messages. The default converter can be overridden and reset via `setConverter()` and `resetConverter()`:
@@ -2238,13 +2238,13 @@ The thread-local converter supplier defaults to `BasicBeanConverter.DEFAULT` and
### juneau-bean
-#### ParamInfo Replaced with ParameterInfo
+### ParamInfo Replaced with ParameterInfo
The legacy `ParamInfo` type in the Swagger v2 module has been fully replaced with `ParameterInfo`. All references have been migrated. If you have code that references `ParamInfo`, update it to use `ParameterInfo`.
### juneau-rest-common
-#### HTTP Annotations Moved from `juneau-marshall`
+### HTTP Annotations Moved from `juneau-marshall`
The HTTP parameter annotations (`@Header`, `@Query`, `@Path`, `@Content`, `@FormData`, `@Request`, `@Response`, `@StatusCode`, `@PathRemainder`, `@HasQuery`, `@HasFormData`, `@Contact`, `@License`, `@Tag`) along with the constant classes (`CollectionFormatType`, `FormatType`, `ParameterType`) and the `httppart.bean` package (`RequestBeanMeta`, `RequestBeanPropertyMeta`, `ResponseBeanMeta`, `ResponseBeanPropertyMeta`, `MethodInfoUtils`) have been moved from `juneau-marshall` to `juneau-re [...]
@@ -2272,13 +2272,13 @@ A new `@HttpPartMarshalling` annotation in `juneau-marshall` (`org.apache.juneau
String name
```
-#### `RestSharedConstants`
+### `RestSharedConstants`
- **`RestSharedConstants`** — Home for static literals shared across REST modules (server, client, mock) so wire names and similar strings stay aligned. Serializer/parser session option wire names are **`HEADER_JuneauSerializerOptions`**, **`HEADER_JuneauParserOptions`**, **`QUERY_juneauSerializerOptions`**, and **`QUERY_juneauParserOptions`**. Add more `public static final` fields when other cross-module constants are needed. (This supersedes the earlier `RestSessionOptionWire` type.)
### juneau-rest-server
-#### REST class family architecture — naming triad, `RestMixin`, op-mixins, flavor fill-in (TODO-145)
+### REST class family architecture — naming triad, `RestMixin`, op-mixins, flavor fill-in (TODO-145)
A coordinated, breaking restructuring of the `@Rest` resource family establishes one consistent
architecture across servlets, child resources, and mixins. All changes below are hard breaks with no
@@ -2366,7 +2366,7 @@ base) — a bare `@Rest` host with no serializers can no longer content-negotiat
former JSON-only op did not require them. The historical `/routes` alias remains reachable via
`-Djuneau.routeindex.path=routes`.
-#### Fluent programmatic builder API — `RestBuilder` / `AbstractRestBuilder` self-type CRTP (TODO-143)
+### Fluent programmatic builder API — `RestBuilder` / `AbstractRestBuilder` self-type CRTP (TODO-143)
A public, fluent builder surface lets a `@Rest` resource, child resource, or mixin be configured
**programmatically** — the primary use case being instantiating a configured resource bean in a Spring
@@ -2433,7 +2433,7 @@ type** (or a usable direct constructor) over one that only promises a supertype.
nested `Builder` therefore wins over the inherited generic `builder(Class)` (whose `build()` erases to a base
class), and a plain resource/mixin carrying only the inherited builder falls through to its no-arg constructor.
-#### Opt-in lazy `@Rest(children=...)` materialization (TODO-121)
+### Opt-in lazy `@Rest(children=...)` materialization (TODO-121)
Parent resources annotated with `@Rest(lazyChildren=true)` now defer the construction of each child
`RestContext` until the first HTTP request routed to that child. Default behavior (eager at startup)
@@ -2468,7 +2468,7 @@ public class ApiGroupResource extends BasicRestServletGroup {
}
```
-#### Outgoing-response W3C trace-context headers (TODO-114)
+### Outgoing-response W3C trace-context headers (TODO-114)
When a non-no-op `TracerHook` is active on a request, the server now writes the W3C `traceparent` — and, when present, the `tracestate` — header back onto the HTTP **response**, so a client calling the server can read the resulting trace id off the response and correlate against it. The emitted `traceparent` reflects the **server-started span's** context (a freshly-minted span id parented to the inbound trace), not the inbound header verbatim. `tracestate` is written **only when the acti [...]
@@ -2477,7 +2477,7 @@ When a non-no-op `TracerHook` is active on a request, the server now writes the
The companion OTel bridge change lives in `juneau-rest-server-tracing-otel`: `OtelTracerHook.startSpan(...)` now renders the W3C header values from the server-started span context at span-start time (the only point where it is reliably active) and stashes them as the request attributes the processor reads. See [REST Server — Observability](/docs/topics/RestServerObservability) for the full topic.
-#### Per-resource / per-method observability opt-in attributes (TODO-115)
+### Per-resource / per-method observability opt-in attributes (TODO-115)
`@Rest`, `@RestOp`, and all HTTP verb annotations (`@RestGet`, `@RestPost`, `@RestPut`, `@RestDelete`, `@RestPatch`, `@RestOptions`) now carry three new `String` members for observability control:
@@ -2511,7 +2511,7 @@ public class ApiResource extends RestServlet {
**Interaction with `TraceContextResponseProcessor` (TODO-114):** When `observability="false"` is effective for an op, `RestOpInvoker` skips the `TracerHook.startSpan(...)` call. Since `OtelTracerHook` stashes the `juneau.traceparent` / `juneau.tracestate` request attributes inside `startSpan(...)`, those attributes are never set, and `TraceContextResponseProcessor` naturally emits no trace-context response headers for that op — no additional wiring is needed.
-#### `View`-returning `@RestOp` methods now reach their renderer automatically (TODO-96)
+### `View`-returning `@RestOp` methods now reach their renderer automatically (TODO-96)
Response processors implementing the new `ViewRenderer` marker interface are automatically
positioned before catch-all processors (`CatchAllResponseProcessor`) in the
@@ -2548,7 +2548,7 @@ This is the foundational fix that unblocks the typed-handler View-return path fo
view modules — the per-engine typed-handler integration test matrices landed alongside
this change (see the `juneau-rest-server-view-*` entries below).
-#### Framework-internal `@Value` adoption (TODO-92)
+### Framework-internal `@Value` adoption (TODO-92)
Framework-internal config readers in `juneau-rest-server` now route through the `@Value`
seam introduced in TODO-79, replacing the hand-rolled `env(...)` / `System.getProperty(...)`
@@ -2580,7 +2580,7 @@ see [@Value Framework-Internal Adoption](/docs/topics/ValueFrameworkInternal) fo
mapping. The Javadoc cross-references that used to read `{@link CallLogger#SP_xxx "..."}`
have all been rewritten to plain `<js>"..."</js>` literal text.
-#### Per-`RestContext` `@Value` resolution against `@Rest(config=...)` Configs (TODO-95)
+### Per-`RestContext` `@Value` resolution against `@Rest(config=...)` Configs (TODO-95)
- `RestContext`'s constructor now installs a `PropertySource` named `"rest.config"` on the
resource's `BeanStore` — **not** on the process-wide `Settings.get()` singleton. The source
@@ -2608,7 +2608,7 @@ have all been rewritten to plain `<js>"..."</js>` literal text.
rebuilding the resource bean.
- Cross-link: [@Value Annotation Basics — Per-resource `@Rest(config=...)` integration](/docs/topics/ValueAnnotationBasics#per-resource-restconfig-integration).
-#### Rest Debug Rethink (TODO-20)
+### Rest Debug Rethink (TODO-20)
`juneau-rest-server` now resolves debug behavior through a single `DebugConfig` model and typed `@Debug` annotation slot, replacing the previous split model (`debug`, `debugDefault`, `debugEnablement`, `debugOn`) on `@Rest` / `@RestOp`.
@@ -2625,7 +2625,7 @@ have all been rewritten to plain `<js>"..."</js>` literal text.
**Migration note:** This is a hard-break change for annotation members. Replace any old debug attributes on `@Rest` / `@RestOp` with the typed `debug=@Debug(...)` form.
-#### Test-time Bean Injection (TODO-35)
+### Test-time Bean Injection (TODO-35)
A new JUnit 5 extension and `@TestBean` annotation enable Spring-style test-time bean substitution for `MockRestClient`, `Microservice`, `SerializerSet`, `ParserSet`, and `EncoderSet` — without CGLIB, AOT bytecode generation, or any Mockito dependency. See [REST Server — Test-time Bean Injection](/docs/topics/RestServerTestBeanInjection) for the full reference.
@@ -2638,7 +2638,7 @@ A new JUnit 5 extension and `@TestBean` annotation enable Spring-style test-time
- **Per-test and per-class scopes** via `@TestBean(scope = METHOD)` (default) and `@TestBean(scope = CLASS)` (must be on `static` members). Method-scope overlays chain on top of class-scope overlays.
- **Named-bean qualifier** via `@TestBean(name = "...")` matching the framework's existing `@Bean(name = "...")` parameter resolution.
-#### AuthN Guards — Bearer / API-Key / `@Auth Principal` (TODO-69)
+### AuthN Guards — Bearer / API-Key / `@Auth Principal` (TODO-69)
`juneau-rest-server` now ships two opt-in AuthN guards plus an `@Auth Principal` argument resolver. The core jar stays JWT-free — a separate `juneau-rest-server-auth-jwt` sub-module (see below) carries the nimbus-jose-jwt integration. See [REST Server — AuthN Guards](/docs/topics/RestServerAuthGuards) for the full reference.
@@ -2655,7 +2655,7 @@ A new JUnit 5 extension and `@TestBean` annotation enable Spring-style test-time
- **`AuthArg` registered in `DefaultConfig.restOpArgs`** so type-driven `Principal` injection works out of the box.
- **Composition with `BasicAdminResource`.** Swapping the mixin's default `DenyAllGuard` for a `BearerTokenGuard` is a zero-mixin-source-change migration — a single `@Bean RestGuardList adminGuards(...)` on the host wins via the existing guard-override seam (see `BasicAdminResource_AuthIntegration_Test`).
-#### Auth Filter Framework — Servlet-Layer AuthN (TODO-94a)
+### Auth Filter Framework — Servlet-Layer AuthN (TODO-94a)
`juneau-rest-server` now ships a pluggable servlet-filter authentication framework in the new `org.apache.juneau.rest.auth` package. Filters run at the **container layer** — before `RestServlet` routing — and expose the resolved identity via standard `HttpServletRequest` overrides so downstream `RoleBasedRestGuard` and `@Auth Principal` injection work with zero changes. See [AuthN Filter Framework](/docs/topics/AuthFilterFramework) for the full reference.
@@ -2669,7 +2669,7 @@ A new JUnit 5 extension and `@TestBean` annotation enable Spring-style test-time
- **`@Bean AuthFilterChain` auto-mount** — `JettyServerComponent.onStart(...)` scans the `BeanStore` for an `AuthFilterChain` bean and registers it at `/*` before any servlet is mounted. No explicit `addFilter(...)` call required for the common case.
- **Spring Boot note** — Spring Security's `SecurityFilterChain` is the recommended Spring path. `BearerTokenAuthFilter` / `ApiKeyAuthFilter` can be registered via `FilterRegistrationBean` if desired; the `@Bean` auto-mount is Jetty-only.
-#### Rate-Limit Guard + Request-Id Filter (TODO-66)
+### Rate-Limit Guard + Request-Id Filter (TODO-66)
`juneau-rest-server` now ships two opt-in operational primitives — both purely additive, both wired through existing `@Bean` / `@RestStartCall` extension points. See [REST Server — Rate-Limiting and Request-Id Propagation](/docs/topics/RestServerRateLimitAndRequestId) for the full reference.
@@ -2693,7 +2693,7 @@ A new JUnit 5 extension and `@TestBean` annotation enable Spring-style test-time
- **New constant.** `RestServerConstants.REQUEST_ID` (`"requestId"`) — the canonical request-attribute key used by `RequestIdFilter`.
-#### Observability — Micrometer + OpenTelemetry hooks (TODO-67)
+### Observability — Micrometer + OpenTelemetry hooks (TODO-67)
**Metrics and tracing are opt-in and disabled by default.** Same non-negotiable contract as Bean Validation (TODO-68): a fresh `RestContext` built with no `MetricsRecorder` / `TracerHook` bean registered never records a sample, never opens a span, and never adds a per-request cost — even when `io.micrometer:micrometer-core` and `io.opentelemetry:opentelemetry-api` are on the classpath. Opt in by registering a `@Bean MetricsRecorder` / `@Bean TracerHook` on the resource.
@@ -2731,7 +2731,7 @@ public class MyResource extends BasicRestServlet {
See [REST Server — Observability (Micrometer + OpenTelemetry)](/docs/topics/RestServerObservability) for the full topic.
-#### Async returns + virtual-thread dispatch (TODO-70)
+### Async returns + virtual-thread dispatch (TODO-70)
`@RestOp` handler methods may now return `CompletableFuture<T>` (or any `CompletionStage<T>`); the framework unwraps the value through the standard response-processor chain when the future resolves. A separate, opt-in `@Rest(virtualThreads=true)` flag dispatches handler invocation onto Java 21+ virtual threads with graceful degradation on Java 17. The two features compose: a `CompletableFuture` return on a `virtualThreads=true` resource gives you the high-throughput "no-thread-blocked" p [...]
@@ -2771,7 +2771,7 @@ Synchronous handlers (no `CompletableFuture`, no `virtualThreads=true`) have **z
See [REST Server — Async Returns + Virtual-Thread Dispatch](/docs/topics/RestServerAsyncDispatch) for the full reference.
-#### SLF4J MDC async propagation bridge (TODO-117)
+### SLF4J MDC async propagation bridge (TODO-117)
When a `@RestOp` handler returns a `CompletableFuture`, the `whenComplete` callback typically runs on a different thread (a virtual thread, pool thread, or fork-join worker). Log statements emitted inside that callback previously had no SLF4J MDC context — any `requestId`, `userId`, or trace-correlation keys set by an upstream filter were invisible to the logger running on the completion thread.
@@ -2801,7 +2801,7 @@ public CompletableFuture<Order> getOrder(@Path String id) {
- **`RestContext.isMdcAsyncPropagation()`** (new) — returns `true` when MDC propagation is enabled. Defaults to `true`; overridden by the `RestContext.mdcAsyncPropagation` env-driven property.
- **`RestContext.Builder.mdcAsyncPropagation(boolean)`** (new) — per-resource programmatic override.
-#### Per-resource async completion executor (TODO-118)
+### Per-resource async completion executor (TODO-118)
Production deployments need to isolate `CompletableFuture` completion callbacks on a dedicated thread pool — the future's natural completion thread is often an I/O-driver or virtual thread that should not be blocked by response-handler work. A new `asyncCompletionExecutor` attribute lets you route callbacks to any named `Executor` bean registered with the resource.
@@ -2840,7 +2840,7 @@ New API:
- **`RestOpContext.getAsyncCompletionExecutor()`** — op-level resolved executor with resource-level fallback.
- **`RestServerConstants.PROPERTY_asyncCompletionExecutor`** — annotation property key constant.
-#### Reactive-Streams return types — `Flow.Publisher` core + Reactor / RxJava bridge (TODO-119 + TODO-120)
+### Reactive-Streams return types — `Flow.Publisher` core + Reactor / RxJava bridge (TODO-119 + TODO-120)
`@RestOp` handlers may now return reactive-streams values. **The feature is fully opt-in by adding a module to the classpath** — a bare `juneau-rest-server` has zero reactive behavior and `DefaultConfig` wires no reactive processor. The JDK-native `java.util.concurrent.Flow.Publisher<T>` is supported by the new dependency-free, opt-in `juneau-rest-server-reactive` module; Project Reactor (`Mono` / `Flux`), RxJava 3 (`Single` / `Maybe` / `Completable` / `Flowable` / `Observable`), and the [...]
@@ -2899,7 +2899,7 @@ New API (all in the opt-in `juneau-rest-server-reactive` module):
See [Reactive-Streams Returns](/docs/topics/RestServerReactive) for the full topic.
-#### New module: `juneau-rest-server-reactive` (TODO-119/120 refactor)
+### New module: `juneau-rest-server-reactive` (TODO-119/120 refactor)
A new dependency-free, opt-in module that holds the JDK-native `Flow.Publisher` spine (`ReactiveResponseProcessor`), the `ReactiveStreamsAdapter` SPI, the `Adaptation` value type, and the `META-INF/services/...ResponseProcessor` auto-registration file. Adding it alone enables `Flow.Publisher<T>` returns with no third-party dependency. A bare `juneau-rest-server` without it has zero reactive behavior.
@@ -2911,7 +2911,7 @@ A new dependency-free, opt-in module that holds the JDK-native `Flow.Publisher`
</dependency>
```
-#### New module: `juneau-rest-server-reactive-reactor` (TODO-119)
+### New module: `juneau-rest-server-reactive-reactor` (TODO-119)
A further opt-in bridge module (depends on `juneau-rest-server-reactive`) providing `ReactiveStreamsAdapter` implementations for the popular reactive libraries. Server-side only — there is no client-side counterpart. All three backing libraries are `provided`-scope.
@@ -2937,7 +2937,7 @@ Maven coordinate:
</dependency>
```
-#### Health Probe SPI + Resource (TODO-65)
+### Health Probe SPI + Resource (TODO-65)
`juneau-rest-server` now includes a built-in probe SPI and aggregation resource under
`org.apache.juneau.rest.health`:
@@ -2952,7 +2952,7 @@ Maven coordinate:
- `HealthProbeSettings` introduces per-indicator timeout control (default `1s`); exceptions/timeouts
are converted to `DOWN` with `details.error`.
-#### `@Rest(mixins=...)` Composition + `@Rest(paths=...)` Multi-Mount
+### `@Rest(mixins=...)` Composition + `@Rest(paths=...)` Multi-Mount
See [REST Server — Mixins and Multi-Mount Paths](/docs/topics/RestServerCompositionMixinsAndPaths) for the full reference.
@@ -2970,7 +2970,7 @@ Users can now choose either:
- **Recommended**: `@Rest(mixins=BasicHealthResource.class)` on the root resource (single servlet).
- **Fallback**: standalone `HealthProbeConfiguration` auto-mount (separate servlet, explicit paths).
-#### Mixin Sub-Context Inheritance
+### Mixin Sub-Context Inheritance
`@Rest(mixins=…)` mixin classes are now each elevated into a dedicated `RestContext` sub-context
rather than being treated as bare method libraries grafted into the host's context. Each mixin
@@ -3009,7 +3009,7 @@ opt-out (semantics aligned with the rest of the framework).
mixin sub-context=`true`). No external callers exist; all internal call sites in
`juneau-rest-server`, `juneau-rest-mock`, and `juneau-commons` were updated.
-#### Runtime-Overridable `@Rest(paths=...)` Resolution Chain (TODO-73)
+### Runtime-Overridable `@Rest(paths=...)` Resolution Chain (TODO-73)
The `paths` array on `@Rest` is now a *default* in a three-rung **runtime-override resolution
chain**, walked once during `RestContext` construction and exposed via `RestContext.getPaths()`.
@@ -3064,7 +3064,7 @@ literals continue to behave exactly as they did under FINISHED-72 (the annotatio
on its own, element-for-element). Pre-9.5.0 users who already adopted `@Rest(paths=...)` see no
behavior change unless they introduce an SVL marker or an embedded comma in an element.
-#### SVL `${...}` resolution in `@RestOp(path)` / `@RestGet(path)` / `@RestOp(value)` (TODO-99)
+### SVL `${...}` resolution in `@RestOp(path)` / `@RestGet(path)` / `@RestOp(value)` (TODO-99)
SVL variables (`${var:default}`, `$S{key,default}`, `$E{NAME,default}`, `$C{key}`, etc.) are now
resolved in op-level path declarations — `@RestOp(path)`, `@RestGet(path)`, `@RestPost(path)`,
@@ -3100,7 +3100,7 @@ then fails predictably at routing time without crashing at startup.
This change is purely additive — annotation strings that contain no SVL markers are passed
through unchanged.
-#### Bundled mixin op-paths now SVL-configurable (TODO-101)
+### Bundled mixin op-paths now SVL-configurable (TODO-101)
Building on TODO-99 (SVL resolution in op-level `path` declarations), every Juneau-bundled
mixin resource whose mount path is a Juneau organizational/conventional default — not fixed by an
@@ -3161,7 +3161,7 @@ SVL resolution happens once at `RestContext` construction time (see TODO-99 abov
resolution chain). Each configurable mixin ships with a `*_SvlPathOverride_Test` in
`juneau-utest` that exercises the override end-to-end via `MockRestClient`.
-#### Mixin path overrides now accept liberal input forms (TODO-104)
+### Mixin path overrides now accept liberal input forms (TODO-104)
Building on TODO-101 (SVL-configurable mixin paths) and TODO-102 (`pathToken()` in the SVL
scripting catalog), all 10 SVL-configurable mixin op-paths now wrap their override token in
@@ -3190,7 +3190,7 @@ Each mixin's `*_SvlPathOverride_Test` has been extended with 5–6 new equivalen
(bare token, leading slash, trailing slash, both slashes, wildcard suffix, and multi-segment)
covering all input forms per class.
-#### OpenAPI 3.1 Emission + API-docs Mixin Pack (TODO-63 + TODO-74)
+### OpenAPI 3.1 Emission + API-docs Mixin Pack (TODO-63 + TODO-74)
`juneau-rest-server` now ships first-class OpenAPI 3.1 document generation alongside the existing Swagger v2 path, with the public surface composed via four small `@Rest(mixins=...)` mixins instead of a `apiFormat` string knob:
@@ -3265,7 +3265,7 @@ public class MyApi extends RestServlet implements BasicUniversalConfig { ... }
Apps that subclass `BasicRestServlet` / `BasicRestResource` without setting `apiFormat` or relying on the query mirrors get the new behavior (six api-docs URLs instead of one) automatically.
-#### Static-Files Mixin (TODO-75)
+### Static-Files Mixin (TODO-75)
`juneau-rest-server` now ships a `BasicStaticFilesResource` mixin in the new
`org.apache.juneau.rest.staticfile` package that wraps the existing `BasicStaticFiles` plumbing
@@ -3279,7 +3279,7 @@ roots flow through unchanged. See
multi-mount semantics, HEAD support, Cache-Control behavior, the OpenAPI-hidden mechanism, and
the path-override constraint documented in the topic page's *Path-override constraint* section.
-#### Convention-Endpoints Mixin Pack (TODO-76)
+### Convention-Endpoints Mixin Pack (TODO-76)
`juneau-rest-server` now ships a four-class **convention-endpoints mixin pack** in the new
`org.apache.juneau.rest.convention` package covering the de-facto-standard URLs every
@@ -3340,7 +3340,7 @@ methods on their hosts continue to instantiate via their builders unchanged.
any `@RestOp`-annotated handler that returns an `HttpResource`, not just the static-files
mixin.
-#### Ops / Introspection Mixin Pack (work item 77)
+### Ops / Introspection Mixin Pack (work item 77)
`juneau-rest-server` now ships a three-class **ops / introspection mixin pack** in the new
`org.apache.juneau.rest.ops` package covering the operational surface every long-running service
@@ -3391,7 +3391,7 @@ tests under both Jetty microservice and Spring Boot.
`@Rest(guards=...)` or `@RestOp(guards=...)` site that wants the same default-deny posture
with a `@Bean RestGuardList` override seam.
-#### `RateLimitGuard.Storage.snapshot()` SPI + `BasicAdminResource` enrichment (work item 89)
+### `RateLimitGuard.Storage.snapshot()` SPI + `BasicAdminResource` enrichment (work item 89)
`org.apache.juneau.rest.guard.RateLimitGuard.Storage` gained an optional read-side SPI for
operator-facing tooling, and `BasicAdminResource`'s `/admin/ratelimit` endpoint now uses it to
@@ -3434,7 +3434,7 @@ DynamoDB-backed, etc.) keep compiling unchanged.
rename to `snapshot` matches the SPI method name and is unlikely to affect any real
consumer.
-#### Server-side SSE Helpers (TODO-62)
+### Server-side SSE Helpers (TODO-62)
`juneau-rest-server` now includes an SSE helper layer for streaming endpoints:
@@ -3443,7 +3443,7 @@ DynamoDB-backed, etc.) keep compiling unchanged.
- `SseHeartbeat` provides optional scheduled `: ping` comments (when a `ScheduledExecutorService` bean is available).
- New `RestOpArg` resolvers allow direct `SseBroadcaster` and `SseSubscription` method-parameter injection in `@RestOp` handlers.
-#### Dynamic Child Resources (TODO-33)
+### Dynamic Child Resources (TODO-33)
Parent resources that extend `BasicRestServletGroup` or `BasicRestObjectGroup` can now mount and unmount children at runtime, in addition to declaring them statically via `@Rest(children=…)`.
@@ -3466,7 +3466,7 @@ The underlying state lives on `RestChildren`, which now holds children in a `vol
See [Child Resources](/docs/topics/ChildResources#dynamic-child-resources) for the full API and usage notes.
-#### `@RestInject` Renamed to `@Bean` (moved to `juneau-commons`)
+### `@RestInject` Renamed to `@Bean` (moved to `juneau-commons`)
`@RestInject` has been renamed to `@Bean` and moved from `org.apache.juneau.rest.annotation` to
`org.apache.juneau.commons.inject`. Update imports accordingly:
@@ -3485,22 +3485,22 @@ public EncoderSet myEncoders(BeanStore bs) { ... }
The semantics are identical; only the package and annotation name changed.
-#### `SpringBeanStore2` Renamed to `SpringBeanStore`
+### `SpringBeanStore2` Renamed to `SpringBeanStore`
`SpringBeanStore2` has been renamed to `SpringBeanStore` for consistency with the `BasicBeanStore2` → `BasicBeanStore` rename completed in this release. The old name `SpringBeanStore2` is removed; update any import or type reference to `org.apache.juneau.rest.springboot.SpringBeanStore`.
-#### `RestServerConstants`
+### `RestServerConstants`
- **`RestServerConstants`** — Central place for **juneau-rest-server** static literals, starting with `Settings` keys. Serializer/parser session-option settings (`juneau.rest.sessionOptions.*`) use fields such as **`SETTING_sessionOptions_rejectWhenAllowlistEmpty`** and **`SETTING_sessionOptions_failOnInvalidAllowlistEntry`**. HTTP wire names for those options are fields on **`RestSharedConstants`** in **juneau-rest-common**. This supersedes the **`RestSessionOptionsSettings`** type.
-#### `RestOpContext`: RestOp-group annotations
+### `RestOpContext`: RestOp-group annotations
- **`RestOpContext.getRestOpAnnotations()`** / **`findRestOpAnnotations()`** — Returns every annotation in the **`@RestOp` group** (including **`@RestGet`**, **`@RestPost`**, etc.) on the operation method and matching superclass/interface methods, in **child-to-parent** order; results are memoized until **`reset()`**. Typed **`AnnotationProvider.find(RestOp.class, MethodInfo)`** matches only a literal **`@RestOp`**, not grouped specializations such as **`@RestGet`**; use **`AnnotationInf [...]
- **`RestOpContext.getNoInheritKeys()`** / **`findNoInherit()`** — Aggregates non-empty **`noInherit`** tokens from **every** **`RestOp`-group** annotation on the override chain (after SVL resolution and comma expansion), not only the nearest declaration. **`isInherited(String)`** on **`RestOpContext`** uses this combined set when deciding whether to merge **`allowedParserOptions`** / **`allowedSerializerOptions`** keys from the enclosing **`RestContext`**.
- **`RestOpContext.getAllowedParserOptionsKeys()`** / **`findAllowedParserOptionsKeys()`** — Annotation-only parser allowlist keys: merges from **`RestContext`** when **`isInherited(PROPERTY_allowedParserOptions)`**, then aggregates **`allowedParserOptions`** from every **`RestOp`-group** annotation on the method override chain (parallel to **`RestContext`**, but **`RestContext`** uses only the nearest **`@Rest`**).
- **`RestOpContext.getAllowedSerializerOptionsKeys()`** / **`findAllowedSerializerOptionsKeys()`** — Same for serializer keys (**`allowedSerializerOptions`**, **`PROPERTY_allowedSerializerOptions`**).
-#### Request Attributes and Session Properties Separation
+### Request Attributes and Session Properties Separation
Request attributes and parser/serializer session properties are now completely separate concepts:
@@ -3556,7 +3556,7 @@ public class MyResource {
This separation provides clearer semantics: request attributes are metadata about the request, while session properties are configuration for parsers and serializers.
-#### Session option allowlists and `noInherit`
+### Session option allowlists and `noInherit`
Serializer and parser session-option allowlists are built from annotation contributions, merged with validation in **`RestSessionOptionAllowlistMerge`**, and exposed lazily via **`Memoizer`** on **`RestContext`** and **`RestOpContext`**. Effective keys are returned as unmodifiable **`SortedSet<String>`** (natural order). **`RestContext.reset()`** clears cached allowlists and cascades **`reset()`** to operation contexts.
@@ -3590,11 +3590,11 @@ This distinction allows fine-grained control: you can block class-level options
Programmatic **`RestContext.Builder`** / **`RestOpContext.Builder`** no longer expose public **`appendAllowed*`** or **`allowedParserOptions` / `allowedSerializerOptions`** list setters for these allowlists; framework code applies contributions through package-visible **`applyFramework*AllowlistContribution`** methods during annotation processing.
-#### Swagger: serializer/parser session option parameters
+### Swagger: serializer/parser session option parameters
Generated Swagger (OpenAPI 2) for REST operations now includes optional documentation parameters for Juneau serializer/parser session options on the wire: headers `X-Juneau-Serializer-Options` and `X-Juneau-Parser-Options` (JSON5 object strings) and query parameters `juneauSerializerOptions` / `juneauParserOptions` (UON-encoded maps). Canonical names are the `HEADER_*` / `QUERY_*` fields on `RestSharedConstants` in **juneau-rest-common**. Existing explicit parameters with the same `in` + [...]
-#### `RestContext.Builder` and `RestOpContext.Builder` removed
+### `RestContext.Builder` and `RestOpContext.Builder` removed
`RestContext.Builder` and `RestOpContext.Builder` are no longer part of the public API. All resource-level and operation-level configuration that was previously expressed through fluent builder calls now flows exclusively through `@Rest(...)` / `@RestOp(...)` annotation attributes or `@Bean`-annotated methods and fields.
@@ -3608,7 +3608,7 @@ Key changes:
See the [V10.0 Migration Guide](/docs/topics/V10MigrationGuide) for a per-setting replacement table.
-#### Bean precedence: Spring > `@Bean` (inject) > default (breaking)
+### Bean precedence: Spring > `@Bean` (inject) > default (breaking)
The precedence order used by `RestContext` to resolve framework-managed beans (`CallLogger`, `EncoderSet`, `SerializerSet`, `ParserSet`, `ThrownStore`, `Config`, `VarResolver`, `HttpPartSerializer`, `HttpPartParser`, `Messages`, `MethodExecStore`, `JsonSchemaGenerator`, `StaticFiles`, `DebugEnablement`, `SwaggerProvider`, `RestOperations`, `RestChildren`, named `HeaderList` / `NamedAttributeMap` slots, etc.) has been flipped:
@@ -3643,16 +3643,16 @@ If you previously relied on `@Bean` (inject) overriding a Spring `@Bean`, you ha
`SpringBeanStore` keeps backward-compatible behavior at the API level: as a `BasicBeanStore` subclass it picks up the new precedence model automatically when used through `RestContext`. Custom `BasicBeanStore` subclasses that want Spring-equivalent precedence can wire themselves in via `Builder.overridingParent(...)`; the existing `parent(...)` slot continues to behave as a regular fallback (consulted after local entries).
-#### `RestResponse.setSerializer(Serializer)`
+### `RestResponse.setSerializer(Serializer)`
- **`RestResponse.setSerializer(Serializer)`** — Forces the serializer used for the response body (via `setContent(Object)` or equivalent), bypassing `Accept` header negotiation. Pass `null` to clear the override. `Content-Type` is still set by the response processor from the serializer when appropriate; you can call `setContentType(String)` first if needed.
-#### Download / `Content-Disposition: attachment`
+### Download / `Content-Disposition: attachment`
- **`RestResponse.downloadAs(String filename)`** — Sets `Content-Disposition: attachment` with a quoted `filename` parameter so browsers typically download the response body (e.g. `res.downloadAs("example.pdf").setContent(bytes)`).
- **`ContentDisposition.attachment(String)`** and **`HttpHeaders.contentDispositionAttachment(String)`** (juneau-rest-common) — Build a safe header value (escapes `\` and `"` in the filename; rejects null/blank names and CR/LF). RFC 5987 `filename*` is not set; use a custom header value if you need full Unicode filenames.
-#### RFC 7807 / 9457 Problem-Details server-side wiring
+### RFC 7807 / 9457 Problem-Details server-side wiring
Juneau REST resources can now emit `application/problem+json` (RFC 7807 / 9457) responses end-to-end. The wiring complements the `juneau-bean-rfc7807` module shipped earlier in this release (the typed `Problem` bean) by adding a response processor, an opt-in annotation flag, a `ProblemException` throw seam, and a `ProblemMapper` SPI for custom exception-to-`Problem` translation.
@@ -3749,7 +3749,7 @@ public class AccountResource {
See [REST Server — RFC 7807 Problem Details](/docs/topics/RestServerProblemDetails) for the full topic, including worked examples for the resource-level opt-in, the per-op fanout, the `ProblemException` throw path, and `ProblemMapper` registration.
-#### Jakarta Bean Validation 3.x integration (TODO-68)
+### Jakarta Bean Validation 3.x integration (TODO-68)
**Validation is opt-in and disabled by default.** This is a non-negotiable contract: a fresh `RestContext` built with no validation-related markers anywhere on the resource never instantiates a `Validator`, never invokes a constraint check, and never adds a per-request cost — even when `jakarta.validation-api` and a concrete provider (e.g. Hibernate Validator) are on the classpath. Spring devs migrating in should be aware that, unlike Spring MVC where `@Valid` is automatic, Juneau requir [...]
@@ -3828,7 +3828,7 @@ The integration consults, in order:
See [REST Server — Jakarta Bean Validation](/docs/topics/RestServerValidation) for the full topic, including worked examples for the opt-in marker, the problem-details and non-problem-details response shapes, custom `Validator` registration, custom `Constraint` annotations, and the graceful-degradation contract.
-#### Conditional-GET / ETag helpers
+### Conditional-GET / ETag helpers
`juneau-rest-server` now ships an RFC 7232 conditional-request layer so handlers no longer need to hand-roll `ETag` / `Last-Modified` / `If-None-Match` / `If-Match` plumbing. The wiring is purely additive — existing handlers continue to work unchanged.
@@ -3875,7 +3875,7 @@ public Order get(@Path long id, RestRequest req, RestResponse res) {
See [REST Server — Conditional-GET / ETag Helpers](/docs/topics/RestServerConditionalGet) for the full topic, including the 16-cell precedence matrix, weak/strong ETag rules, and a worked round-trip example.
-#### Standalone servlet companions for dual-use resources
+### Standalone servlet companions for dual-use resources
The bundled `Basic*Resource` mixins are designed for composition into a host via `@Rest(mixins=...)`,
where each pins its operations at an op-level sub-path (e.g. `@RestGet(path="/jsp/*")`). That shape
@@ -3914,7 +3914,7 @@ sub-path behavior.
See [REST Server — Standalone vs Mixin Resources](/docs/topics/RestServerStandaloneVsMixin) for the
full convention.
-#### Servlet self-registration (top-level paths)
+### Servlet self-registration (top-level paths)
Three mechanisms register a servlet at the top-level paths it self-declares (`@Rest(paths)` /
`getPaths()`), all reading the same resolution chain via
@@ -3931,11 +3931,11 @@ See [REST Server — Self-Registration](/docs/topics/RestServerSelfRegistration)
### juneau-rest-client
-#### REST session option wire helpers
+### REST session option wire helpers
`RestClient.Builder` and `RestRequest` provide fluent helpers for serializer/parser session options using the same HTTP names as the server (`RestSharedConstants`): default and per-request headers (JSON5 strings or property maps via `Json5.of`), and default or per-request query parameters (UON strings or property maps via `Uon.of`). `MockRestClient.Builder` and `MockRestRequest` override these methods for fluent typing.
-#### Dynamic Root URL Support
+### Dynamic Root URL Support
- **`rootUrl(Supplier<String>)` overload**: `RestClient.Builder` now accepts a `Supplier<String>` for the root URL, allowing it to be computed dynamically at request time rather than fixed at build time.
@@ -3968,17 +3968,17 @@ See [REST Server — Self-Registration](/docs/topics/RestServerSelfRegistration)
The supplier is called at each read site (request creation, remote proxy invocation, RRPC path building), so URL changes are always reflected on the next request. No build-time URL validation is performed for the `Supplier<String>` overload; invalid values will surface as errors when requests are made.
-#### Bug Fixes
+### Bug Fixes
- **Fixed stream-closed exception when calling `RestResponse.getContent().asString()` after FULL request logging.** `RestResponse.close()` previously called `EntityUtils.consumeQuietly(...)` on the underlying HTTP entity *before* rendering FULL-detail log output. On real (non-mock) responses the consume step closes the network input stream, so the subsequent FULL-logging body read (and any later user call to `getContent().asString()`) failed with `IOException: Stream closed`, leaving `Re [...]
-#### Migration Notes
+### Migration Notes
- **RestClient `rootUrl`**: The `rootUrl` field is now stored as a `Supplier<String>` internally. Code that relies on reflection to access the private `rootUrl` field directly (unusual but possible) will now see a `Supplier<String>` instead of a `String`.
### juneau-microservice (formerly juneau-microservice-core)
-#### Per-microservice `Config` wired into `Settings` (TODO-79)
+### Per-microservice `Config` wired into `Settings` (TODO-79)
- `Microservice`'s constructor now installs a `ConfigPropertySource` for the microservice's own
`Config` onto `Settings.get()`, and `stop()` removes it. Any `@Value("${section/key}")`
@@ -3986,7 +3986,7 @@ See [REST Server — Self-Registration](/docs/topics/RestServerSelfRegistration)
bean built through `BeanInstantiator` — resolves against the microservice config without an
explicit lookup call.
-#### `juneau.workingDir` migrated to `@Value` (TODO-92)
+### `juneau.workingDir` migrated to `@Value` (TODO-92)
- The `juneau.workingDir` env-driven default on `Microservice.Builder` is now populated by an
`@Inject`-annotated initializer (`initWorkingDirFromEnv`) that takes a
@@ -3996,7 +3996,7 @@ See [REST Server — Self-Registration](/docs/topics/RestServerSelfRegistration)
only sets `workingDir` when it has not already been assigned. See
[@Value Framework-Internal Adoption](/docs/topics/ValueFrameworkInternal).
-#### Module Renamed (TODO-36)
+### Module Renamed (TODO-36)
The `juneau-microservice-core` Maven artifact has been **renamed** to `juneau-microservice`. The aggregator pom is now
`juneau-microservice-parent`. The Java package `org.apache.juneau.microservice` is unchanged. Update your `pom.xml`:
@@ -4017,7 +4017,7 @@ The `juneau-microservice-core` Maven artifact has been **renamed** to `juneau-mi
</dependency>
```
-#### `MicroserviceListener` Fan-Out (TODO-36)
+### `MicroserviceListener` Fan-Out (TODO-36)
`Microservice.start()` / `Microservice.stop()` / `Microservice.onConfigChange(...)` now invoke **every**
`MicroserviceListener` bean in the bean store, not just a single resolved primary listener.
@@ -4032,7 +4032,7 @@ fan-out always has at least one no-op participant. This change enables companion
`juneau-microservice-jetty`) to drive server lifecycles entirely through standard `MicroserviceListener` hooks,
without needing a `Microservice` subclass.
-#### Inject-Aware Microservice (TODO-31)
+### Inject-Aware Microservice (TODO-31)
`Microservice` is now inject-aware. Every microservice owns an internal `WritableBeanStore`
(from `juneau-commons`) populated from `@Configuration` classes registered on the builder.
@@ -4070,7 +4070,7 @@ microservices that never call `.configurations(...)` behave identically to pre-9
See <a href="/docs/topics/MicroserviceCoreInject">Inject-Aware Microservice</a> for the full guide.
-#### `View` interface — engine-agnostic server-side render contract
+### `View` interface — engine-agnostic server-side render contract
- New `org.apache.juneau.rest.view.View` interface. Carries the data a templating engine needs to render a response: `String getTemplateName()`, `Map<String, Object> getAttributes()`, and a `default Map<String, String> getResponseHeaders()` seam. Engine-agnostic — concrete implementations live in per-engine bridge modules (`juneau-rest-server-view-jsp`, `juneau-rest-server-view-thymeleaf`, `juneau-rest-server-view-mustache`, and `juneau-rest-server-view-freemarker` all ship in 9.5.0; Pha [...]
- Designed as the stable extension point for the new view-module family. New methods will be added as `default`-bodied where possible to preserve backward compatibility with downstream view impls.
@@ -4084,7 +4084,7 @@ public View hello(@Path String name) {
### juneau-rest-server-springboot
-#### Servlet self-registration (Spring Boot)
+### Servlet self-registration (Spring Boot)
Two Spring Boot mechanisms register a Juneau servlet at the top-level paths it self-declares
(`@Rest(paths)` / `getPaths()`), both deriving the mapping from
@@ -4105,7 +4105,7 @@ Two Spring Boot mechanisms register a Juneau servlet at the top-level paths it s
See [REST Server — Self-Registration](/docs/topics/RestServerSelfRegistration) for the full topic.
-#### Spring `Environment` bridge — `@Value` reads `application.yaml` (TODO-79)
+### Spring `Environment` bridge — `@Value` reads `application.yaml` (TODO-79)
- Added `org.apache.juneau.rest.springboot.SpringEnvironmentPropertySource` — a `PropertySource`
that reads from a Spring `Environment` so `@Value("${spring.app.key}")` injections on
@@ -4123,7 +4123,7 @@ See [REST Server — Self-Registration](/docs/topics/RestServerSelfRegistration)
### juneau-microservice-jetty
-#### `JettyServerComponent.addFilter(...)` + `AuthFilterChain` auto-mount (TODO-94a)
+### `JettyServerComponent.addFilter(...)` + `AuthFilterChain` auto-mount (TODO-94a)
`JettyServerComponent` now exposes two public filter-registration methods:
@@ -4136,7 +4136,7 @@ Both delegate to `ServletContextHandler.addFilter(FilterHolder, String, EnumSet<
`onStart(Microservice)` now scans the `BeanStore` for an `AuthFilterChain` bean and auto-registers it at `/*` before servlet discovery — no explicit `addFilter(...)` call is needed when the chain is declared as a `@Bean`.
-#### `JettyServerComponent` env reads migrated to `@Value` (TODO-92)
+### `JettyServerComponent` env reads migrated to `@Value` (TODO-92)
- `JettyServerComponent` previously called `env("availablePort")` and `env("juneau.serverPort")`
to skip an empty fallback during port resolution. These reads are now `@Value("${availablePort}")
@@ -4145,7 +4145,7 @@ Both delegate to `ServletContextHandler.addFilter(FilterHolder, String, EnumSet<
`onStart(Microservice)`. Behavior is unchanged. See
[@Value Framework-Internal Adoption](/docs/topics/ValueFrameworkInternal).
-#### `HealthProbeConfiguration` (TODO-65)
+### `HealthProbeConfiguration` (TODO-65)
`juneau-microservice-jetty` now ships `HealthProbeConfiguration`, an opt-in `@Configuration` module
that contributes:
@@ -4163,7 +4163,7 @@ Microservice.create()
.start();
```
-#### `JettyMicroservice` Replaced by `JettyConfiguration` (TODO-36, **BREAKING**)
+### `JettyMicroservice` Replaced by `JettyConfiguration` (TODO-36, **BREAKING**)
The `JettyMicroservice` subclass, `JettyMicroserviceListener` interface, and `BasicJettyMicroserviceListener`
adapter have been **deleted**. `juneau-microservice-jetty` now contributes a single
@@ -4229,7 +4229,7 @@ Juneau 9.5.0 introduces a new REST client and HTTP type stack that **decouples J
**Beta API**: The non-classic types in `org.apache.juneau.rest.client.*`, `org.apache.juneau.rest.mock.*`, and `org.apache.juneau.http.*` are beta and may change incompatibly in the next major release. The classic stack remains the binary-stable choice for the 9.x line.
-#### Canonical names (was `org.apache.juneau.ng.*`)
+### Canonical names (was `org.apache.juneau.ng.*`)
The 9.5 cut moves the canonical names off the `org.apache.juneau.ng.*` placeholder and frees up the historical `org.apache.juneau.*` namespace:
@@ -4244,7 +4244,7 @@ The 9.5 cut moves the canonical names off the `org.apache.juneau.ng.*` placehold
The pre-existing `org.apache.juneau.http.*` types (Apache HttpCore-based) and the legacy `RestClient` (Apache HttpClient 4.5-based) moved under `.classic` packages in their respective modules — see the next section.
-#### `org.apache.juneau.http` (in `juneau-rest-common`)
+### `org.apache.juneau.http` (in `juneau-rest-common`)
A JDK-native replacement for the Apache HttpCore-based types previously in this package. No `httpcore` dependency in the canonical types — all interfaces (`HttpHeader`, `HttpPart`, `HttpBody`, `HttpStatusLine`, `HttpResponseMessage`) use JDK types only.
@@ -4255,7 +4255,7 @@ A JDK-native replacement for the Apache HttpCore-based types previously in this
The Apache HttpCore-based legacy types (~170 classes) moved to `org.apache.juneau.http.classic.*` in the same module, so existing `juneau-rest-common` consumers only need an `import org.apache.juneau.http.classic.*;` adjustment.
-#### `org.apache.juneau.rest.client` (in `juneau-rest-client`)
+### `org.apache.juneau.rest.client` (in `juneau-rest-client`)
The transport abstraction and the new canonical `RestClient` / `RestRequest` / `RestResponse`. No `org.apache.http.*` dependency.
@@ -4271,7 +4271,7 @@ The transport abstraction and the new canonical `RestClient` / `RestRequest` / `
The legacy Apache HttpClient 4.5–based client moved to `org.apache.juneau.rest.client.classic.*` in the new `juneau-rest-client-classic` module — see "Classic Module Split" below.
-#### Transport Implementations
+### Transport Implementations
The JDK `HttpClient`–based `JavaHttpTransport` ships built into the canonical `juneau-rest-client` artifact and is the default — `RestClient.create()` works out of the box on Java 11+ with zero third-party dependencies (see TODO-41 below).
@@ -4286,7 +4286,7 @@ To swap in a different native HTTP client, add one of the optional transport mod
Each optional transport module ships `*Transport`, `*TransportBuilder` (with native client–specific configuration accessible via cast), and `*TransportProvider`. Common transport-builder configuration (`connectTimeout`, `readTimeout`, `sslContext`, `hostnameVerifier`, `proxy`, `maxConnections`, `maxConnectionsPerRoute`, `followRedirects`, …) lives on `HttpTransportBuilder` so most callers don't need to cast.
-#### `juneau-rest-mock` — `org.apache.juneau.rest.mock`
+### `juneau-rest-mock` — `org.apache.juneau.rest.mock`
The canonical mock client now matches the new `RestClient`:
@@ -4295,7 +4295,7 @@ The canonical mock client now matches the new `RestClient`:
The Apache HttpClient 4.5–implementing legacy `MockRestClient` moved to `org.apache.juneau.rest.mock.classic.*` alongside its `MockRestRequest`, `MockRestResponse`, `MockHttpClientConnectionManager`, `MockLogger`, and `MockConsole` helpers. The shared servlet-mock plumbing (`MockServletRequest`, `MockServletResponse`, `MockHttpSession`, `MockPathResolver`) stays at `org.apache.juneau.rest.mock.*` and is reused by both client flavors.
-#### Classic Module Split
+### Classic Module Split
The pre-existing Apache HttpClient 4.5–based REST client moved into a new sibling Maven module:
@@ -4323,7 +4323,7 @@ Mirroring the `juneau-rest-client` split above, the `juneau-rest-common` module
- `EntityTag` / `EntityTags` value types (no HC 4.5 dependency, despite the historical package) moved out of `classic.header` to `org.apache.juneau.http.header.EntityTag` / `EntityTags`. **This is a source-incompatible change** for any caller that imported them explicitly — see the v9.5 migration guide.
- `@Remote(headerList = ...)` annotation method changed from `Class<? extends HeaderList>` to `Class<?>`. Existing user annotations like `@Remote(headerList = MyHeaderList.class)` continue to work; the classic `RemoteMeta` performs an `instanceof HeaderList` check at runtime before invoking. The default sentinel changed from `HeaderList.Void.class` to `java.lang.Void.class`.
-#### Usage Examples
+### Usage Examples
```java
// Pre-built serializer/parser — configure marshalling externally
@@ -4363,7 +4363,7 @@ try (var req = client.multipartPost("/upload")
client.shutdown();
```
-#### Migration Path
+### Migration Path
The classic `RestClient` / `juneau-rest-common` APIs remain fully supported. Migration is **opt-in** and incremental:
@@ -4377,7 +4377,7 @@ The classic stack is **not** deprecated in 9.5; the canonical stack will graduat
Completes the HC 4.5 removal started by TODO-38 / TODO-42. `juneau-rest-server` is now genuinely transport-neutral — it neither imports `org.apache.http.*` nor depends on `juneau-rest-common-classic`, so `mvn -pl juneau-rest/juneau-rest-server dependency:tree | grep httpcomponents` returns nothing. Pulling `juneau-rest-server` no longer drags `org.apache.httpcomponents:httpcore:4.4.16` onto the consumer classpath.
-#### New transport-neutral types in `juneau-rest-common`
+### New transport-neutral types in `juneau-rest-common`
To give the server somewhere to migrate **to**, the following transport-neutral siblings of the classic HC 4.5 types were added in `org.apache.juneau.http.*`. They use only JDK types — no `org.apache.http.*` dependency.
@@ -4399,7 +4399,7 @@ To give the server somewhere to migrate **to**, the following transport-neutral
- `setContent(HttpBody)`, `setContent(String)`
- `setLocale(Locale)`, `setUnmodifiable()`
-#### Public API changes in `juneau-rest-server`
+### Public API changes in `juneau-rest-server`
The 9.5 release retypes the server-side public surface from `org.apache.http.*` onto the new transport-neutral types. The signature changes below are **source-incompatible** for any caller that imported the classic types directly:
@@ -4415,7 +4415,7 @@ The 9.5 release retypes the server-side public surface from `org.apache.http.*`
| `FluentProtocolVersionAssertion` | over `org.apache.http.ProtocolVersion` | over `HttpProtocolVersion` |
| `HttpStatusLine#getProtocolVersion()` | `String` | `HttpProtocolVersion` |
-#### Class renames in `juneau-rest-server`
+### Class renames in `juneau-rest-server`
The four request-side part-list classes were renamed for naming consistency with the new `HttpHeaderList` / `HttpPartList` siblings in `juneau-rest-common`. No backward-compatibility shims are kept — callers must update imports and references.
@@ -4428,15 +4428,15 @@ The four request-side part-list classes were renamed for naming consistency with
The argument resolvers and `RestPreCall` / `RestPostCall` lifecycle hooks were updated to recognize the new names; any user method signature that referenced the old names needs to be updated.
-#### Response processor rename
+### Response processor rename
`org.apache.juneau.rest.processor.HttpEntityProcessor` was renamed to `HttpBodyProcessor`. The class was already internally rewritten to operate on `HttpBody` instead of HC 4.5's `HttpEntity`, but the class name kept the legacy term until this release. The default response-processor chain registered by `DefaultConfig` was updated accordingly; any custom `RestContext.responseProcessors(...)` configuration that names `HttpEntityProcessor.class` needs to be updated to `HttpBodyProcessor.class`.
-#### Backward-compatibility shim for legacy return types
+### Backward-compatibility shim for legacy return types
A small reflective bridge — `org.apache.juneau.rest.processor.LegacyHttpResponseAdapter` — was added so user `@RestOp` methods that still return classic `org.apache.http.HttpResponse` / `org.apache.http.HttpEntity` / `org.apache.juneau.http.classic.resource.BasicResource` instances keep working when `juneau-rest-common-classic` is on the runtime classpath, even though `juneau-rest-server` itself no longer compiles against those types. The bridge is invoked by `HttpBodyProcessor` and `Htt [...]
-#### Verification
+### Verification
After this change:
@@ -4481,7 +4481,7 @@ RestClient client = RestClient.builder().transport(transport).build();
A new bean module, `juneau-bean-mcp`, models the [Model Context Protocol](https://modelcontextprotocol.io/) wire format as Juneau `@Bean` POJOs. The beans round-trip cleanly through any Juneau serializer/parser (JSON, JSON5, MessagePack, CBOR, YAML, etc.) and were the foundation for `juneau-rest-server-mcp`.
-#### Coverage
+### Coverage
- **JSON-RPC envelopes** — `JsonRpcRequest`, `JsonRpcResponse`, `JsonRpcError`, plus an `McpException` carrying JSON-RPC fields for handler-side propagation.
- **Initialization** — `InitializeRequest`, `InitializeResult`, `Implementation`, `ClientCapabilities`, `ServerCapabilities`, and the per-feature capability beans (`ToolCapability`, `PromptCapability`, `ResourceCapability`, `LoggingCapability`, `RootsCapability`).
@@ -4491,7 +4491,7 @@ A new bean module, `juneau-bean-mcp`, models the [Model Context Protocol](https:
- **Polymorphic content blocks** — `Content` interface with `TextContent`, `ImageContent`, `EmbeddedResourceContent` discriminated by a `type` property.
- **Constants** — `McpMethods` (JSON-RPC method names) and `McpProtocol` (version constants and `JSON_RPC_2_0` literal).
-#### Polymorphic Serialization
+### Polymorphic Serialization
`Content` and `ResourceContents` use `@Bean(typePropertyName="type", dictionary={...})` to discriminate at the wire level. Configure your serializer with `addBeanTypes()` to emit the discriminator on output:
@@ -4503,7 +4503,7 @@ JsonSerializer ser = JsonSerializer.create()
.build();
```
-#### Example
+### Example
```java
import org.apache.juneau.bean.mcp.*;
@@ -4522,7 +4522,7 @@ See [juneau-bean-mcp](/docs/topics/JuneauBeanMcp) for the full topic.
### juneau-rest-server-auth-jwt (new module)
-#### `jwksCacheTtl` migrated to `@Value` (TODO-92)
+### `jwksCacheTtl` migrated to `@Value` (TODO-92)
- `JwtTokenValidator.Builder` now resolves its default `jwksCacheTtl` (5 minutes) through
`@Value("${juneau.jwt.jwksCacheTtl:PT5M}") Duration jwksCacheTtl` instead of a hand-rolled
@@ -4535,19 +4535,19 @@ A new opt-in REST module, `juneau-rest-server-auth-jwt`, adds JWT bearer-token v
`mvn -pl juneau-rest/juneau-rest-server dependency:tree | grep -i nimbus` returns nothing — the containment requirement is verified at build time. See [REST Server — AuthN Guards § JWT verification](/docs/topics/RestServerAuthGuards) for the full reference.
-#### New Classes
+### New Classes
- **`org.apache.juneau.rest.auth.jwt.JwtTokenValidator`** — `TokenValidator` that fetches keys from a JWKS endpoint, verifies signatures, and enforces `iss` / `aud` / `exp` / `nbf` with secure defaults. Fluent builder: `jwksUrl(URI)` (or `jwkSource(JWKSource)`), `issuer(String)`, `audience(String)`, `algorithms(JWSAlgorithm...)` (default `[RS256, ES256]`), `clockSkew(Duration)` (default 60s, capped at 5m), `jwksCacheTtl(Duration)` (default 5m), `clock(Clock)` (test-time injection).
- **`org.apache.juneau.rest.auth.jwt.JwksCache`** (package-private) — Single-slot TTL cache wrapping any `JWKSource<SecurityContext>`. Continues serving the last-known-good key set when the upstream fetch fails past TTL, logging a `WARNING` so transient JWKS-endpoint outages don't cascade into correlated auth outages.
-#### Security defaults
+### Security defaults
- **`alg: none` is permanently rejected** — there is no opt-in. The builder also refuses `algorithms(JWSAlgorithm.NONE)`.
- **`HS256` is opt-in only** — defaults to `[RS256, ES256]`. Mixing HMAC and asymmetric algorithms in the same validator (the algorithm-confusion attack vector) is rejected by the allowlist check.
- **Mandatory claims** — `iss` / `aud` / `exp` / `nbf` are required by default. A token missing any of them is rejected.
- **Clock-skew cap** — the builder will refuse a `clockSkew(...)` value larger than 5 minutes (300s).
-#### JWKS-on-`kid`-miss eager refresh (behavior change — TODO-141)
+### JWKS-on-`kid`-miss eager refresh (behavior change — TODO-141)
**`JwksCache` now performs a single eager JWKS refresh when a fresh-cache key selection returns no matching keys.** This eliminates the rotation window where an IdP publishes a new signing key mid-TTL and clients receive spurious 401 responses for perfectly valid tokens (up to the full cache TTL — 5 minutes by default — under the old behavior).
@@ -4576,7 +4576,7 @@ New builder setters and `@Value` keys:
Applies only to `jwksUrl(...)`-backed caches. A caller-supplied `jwkSource(...)` is unaffected.
-#### Dependency
+### Dependency
```xml
<dependency>
@@ -4597,14 +4597,14 @@ A new opt-in REST module, `juneau-rest-server-auth-saml`, adds SAML 2.0 single-s
`mvn -pl juneau-rest/juneau-rest-server dependency:tree | grep -i opensaml` returns nothing — the containment requirement is verified at build time. See [REST Server — SAML AuthN Support](/docs/topics/SamlAuthSupport) for the full reference.
-#### New Classes
+### New Classes
- **`org.apache.juneau.rest.auth.saml.SamlAssertionValidator`** — Validates a SAML 2.0 `<samlp:Response>` document and returns a [`ClaimsPrincipal`](/docs/topics/RestServerAuthGuards) marked with `issuerType=SAML`. Builder: `spEntityId(String)`, `expectedIssuer(String)`, `metadataResolver(MetadataResolver)` or `signingCredential(Credential)` (mutually exclusive), `decryptionCredential(Credential)` (opt-in for encrypted assertions), `algorithms(String...)` (default `[rsa-sha256, ecd [...]
- **`org.apache.juneau.rest.auth.saml.SamlAuthFilter`** — `AuthFilter` that decodes the inbound `SAMLResponse` (base64 + DEFLATE for the Redirect binding) at a configurable consumer path and delegates validation. Builder: `validator(SamlAssertionValidator)`, `binding(SamlBinding)` (default `POST`), `consumerPath(String)` (default `/saml/acs`), `rolesClaim(String)` (default `"roles"`), `realm(String)` (default `"saml"`).
- **`org.apache.juneau.rest.auth.saml.SamlBinding`** — Enum of supported HTTP bindings (`POST`, `REDIRECT`). Artifact + SOAP bindings deferred to a future iteration.
- **`org.apache.juneau.rest.auth.saml.SamlMetadataResolvers`** — Convenience factories `file(File|Path)` and `url(String)` that produce initialized `MetadataResolver` instances ready to hand to `SamlAssertionValidator.Builder.metadataResolver(...)`. No bundled default singleton.
-#### Security defaults
+### Security defaults
- **Strict signature-algorithm allowlist** — only `http://www.w3.org/2001/04/xmldsig-more#rsa-sha256` and `http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256` are accepted by default. SHA-1-based algorithms are permanently rejected; the builder will refuse a `algorithms(...)` value containing any SHA-1 URI.
- **Mandatory signature on every assertion** — unsigned assertions are rejected.
@@ -4613,7 +4613,7 @@ A new opt-in REST module, `juneau-rest-server-auth-saml`, adds SAML 2.0 single-s
- **Clock-skew cap** — the builder refuses a `clockSkew(...)` value larger than 5 minutes (300s).
- **Encrypted assertions are explicit** — a response carrying `<EncryptedAssertion>` is rejected with a `decryption_required` challenge when no `decryptionCredential(...)` is configured; a wrong key yields `decryption_failed` (never a bogus principal).
-#### Marker claim
+### Marker claim
The returned `ClaimsPrincipal` carries `issuerType=SAML`, so downstream code can distinguish SAML-derived principals from JWT-derived principals without a subclass:
@@ -4623,11 +4623,11 @@ if ("SAML".equals(principal.getClaim("issuerType", String.class).orElse(null)))
}
```
-#### Maven note
+### Maven note
OpenSAML 5.x is published to the [Shibboleth Maven repository](https://build.shibboleth.net/maven/releases/) rather than Maven Central. The `juneau-rest-server-auth-saml` POM declares that repository locally so consumers don't need to configure it in their own settings. Pin the version via the `<opensaml.version>` POM property (default `5.2.2`; do not use `5.0.0`).
-#### Dependency
+### Dependency
```xml
<dependency>
@@ -4648,7 +4648,7 @@ A new opt-in REST module, `juneau-rest-server-auth-oauth`, adds OAuth 2.0 / OIDC
`mvn -pl juneau-rest/juneau-rest-server dependency:tree | grep -iE "(nimbusds|oauth2-oidc)"` returns nothing — the containment requirement is verified at build time. See [REST Server — OAuth AuthN Support](/docs/topics/OAuthAuthSupport) for the full reference.
-#### New Classes
+### New Classes
- **`org.apache.juneau.rest.auth.oauth.OAuthIntrospectionValidator`** — `TokenValidator` that validates opaque OAuth 2.0 tokens via RFC 7662 introspection. Wraps Nimbus's `TokenIntrospectionRequest` + `TokenIntrospectionResponse`. Builder: `introspectionEndpoint(URI)`, `clientId(String)`, `clientSecret(String)` / `clientSecretSupplier(Supplier<String>)`, `requiredScopes(String...)`, `tokenCache(TokenCache)` (default `BoundedLruTokenCache`), `cacheTtl(Duration)` (default 5m, capped [...]
- **`org.apache.juneau.rest.auth.oauth.OAuthFilter`** — `AuthFilter` that authenticates RFC 6750 `Bearer` tokens, delegating to any `TokenValidator` (e.g. `OAuthIntrospectionValidator` for opaque tokens or `JwtTokenValidator` from `juneau-rest-server-auth-jwt` for JWT access tokens). Extracts roles from a configurable claim (default `"scope"`, split on whitespace per RFC 6749 §3.3).
@@ -4660,20 +4660,20 @@ A new opt-in REST module, `juneau-rest-server-auth-oauth`, adds OAuth 2.0 / OIDC
- **`org.apache.juneau.rest.auth.oauth.flow.OAuthResourceOwnerFlow`** — Wraps Nimbus's `ResourceOwnerPasswordCredentialsGrant` (RFC 6749 §4.3). **Filed `@Deprecated(since = "9.5.0")` from day-1** — the resource-owner password-credentials grant was removed from OAuth 2.1 due to long-standing security concerns; prefer `OAuthAuthorizationCodeFlow` (with PKCE).
- **`org.apache.juneau.rest.auth.oauth.oidc.OidcDiscoveryClient`** + **`OidcMetadata`** — OIDC `.well-known/openid-configuration` discovery via Nimbus's `OIDCProviderMetadata.resolve(Issuer)`. Returns a Juneau-native immutable record.
-#### Security defaults
+### Security defaults
- **`requiredScopes` enforcement lives on the validator,** not on the filter (per OQA Q6) — centralizes "what the caller is allowed to do" with the introspection result.
- **Token cache** defaults — 5-minute TTL, capped at 1 hour, 1000-entry LRU eviction (per OQA Q1).
- **PKCE is mandatory** on `OAuthAuthorizationCodeFlow` — the builder does not expose a "PKCE off" toggle.
- **OAuth flow errors are mapped to `OAuthFlowException`** (unchecked); the offending Nimbus error code is preserved on the cause chain.
-#### Deferred
+### Deferred
- **OIDC Relying Party login flow** — now shipped as the `juneau-rest-server-auth-oidc-rp` module (see below); the discovery client + auth-code helper here are the building blocks it composes on top of.
- **Device-code grant** (RFC 8628) — deferred to a follow-on TODO if/when needed.
- **JWKS-on-`kid`-miss eager refresh** — now shipped; see the `juneau-rest-server-auth-jwt` section below.
-#### Dependency
+### Dependency
```xml
<dependency>
@@ -4694,7 +4694,7 @@ A new opt-in REST module, `juneau-rest-server-auth-oidc-rp`, turns a Juneau REST
`mvn -pl juneau-rest/juneau-rest-server dependency:tree | grep -iE "(nimbusds|oauth2-oidc)"` returns nothing — the containment requirement is verified at build time. See [REST Server — OIDC Relying Party Login](/docs/topics/OidcRelyingParty) for the full reference.
-#### New Classes
+### New Classes
- **`org.apache.juneau.rest.auth.oidc.rp.OidcRelyingParty`** — Builder + facade the application's `@Rest` resource calls: `startLogin` (generate + store `state`/`nonce`/PKCE verifier, 302 → IdP), `completeLogin` (parse callback, single-use-consume `state`, exchange code, validate ID token, create session, 302 → app), `logout` (invalidate session + clear cookie + redirect through the IdP `end_session_endpoint`), `refresh` (rotating-refresh-token grant), and `backChannelLogout` (IdP- [...]
- **`org.apache.juneau.rest.auth.oidc.rp.SessionStore`** + **`OidcSession`** — Pluggable session-persistence SPI and the immutable session record (principal + roles + tokens + `sub`/`sid` + expiry). The SPI exposes `supportsServerSideRevocation()` / `invalidateBySubject(String)` / `invalidateBySessionId(String)` so a server-side-indexed store can satisfy back-channel logout.
@@ -4704,11 +4704,11 @@ A new opt-in REST module, `juneau-rest-server-auth-oidc-rp`, turns a Juneau REST
- **`org.apache.juneau.rest.auth.oidc.rp.OidcSessionAuthFilter`** — `AuthFilter` (FINISHED-94a) that resolves the session cookie into a `ClaimsPrincipal` on each request; fail-open to unauthenticated. Roles come from a configurable claim (default `"scope"`), matching `OAuthFilter`'s convention.
- **`org.apache.juneau.rest.auth.oidc.rp.IdTokenValidatorAdapter`** — Wraps Nimbus's `IDTokenValidator` for full OIDC ID-token validation (signature vs JWKS, `iss`, `aud`/`azp`, `exp`/`iat`, `nonce`) with a strict algorithm allowlist (default `[RS256, ES256]`; `none` rejected) and configurable JWKS source (URI / `JWKSet` / `JWKSource`).
-#### Building-block extension (`juneau-rest-server-auth-oauth`)
+### Building-block extension (`juneau-rest-server-auth-oauth`)
- **`OAuthAuthorizationCodeFlow.buildAuthenticationUrl(state, codeChallenge, nonce, customizer)`** — new method emitting an OIDC `AuthenticationRequest` (carrying the `nonce`) alongside the existing plain-OAuth `buildAuthorizationUrl(...)`. Required so the relying party can bind a `nonce` into the authorization request and verify it on the returned ID token.
-#### Security defaults
+### Security defaults
- **`state` and `nonce` are single-use** (atomically consumed on the callback) and TTL-bounded; a missing / replayed value fails the callback.
- **PKCE S256 mandatory** end-to-end; **strict ID-token validation** (`iss` exact, `aud` contains client id, `azp` on multi-audience, `nonce` match, `none`/SHA-1 rejected).
@@ -4716,7 +4716,7 @@ A new opt-in REST module, `juneau-rest-server-auth-oidc-rp`, turns a Juneau REST
- **Session cookie** is `HttpOnly` + `Secure` + `SameSite=Lax` by default; the post-login `redirect` parameter is restricted to safe app-relative paths (open-redirect defense).
- **Back-channel logout** requires a server-side-revocable store; the stateless `SignedCookieSessionStore` throws rather than silently no-op'ing.
-#### Dependency
+### Dependency
```xml
<dependency>
@@ -4735,7 +4735,7 @@ A new opt-in REST module, `juneau-rest-server-auth-oidc-rp`, turns a Juneau REST
A new REST module, `juneau-rest-server-mcp`, exposes a stateless MCP JSON-RPC endpoint built on `juneau-rest-server` and the `juneau-bean-mcp` wire beans. The implementation is transport-agnostic at its core (a pure dispatcher seam) with two REST adapters: a drop-in servlet, and an interface mixin that mounts the endpoint on any existing `@Rest` resource.
-#### New Classes
+### New Classes
- **`McpDispatcher`** - Transport-agnostic JSON-RPC dispatcher. Routes every MCP method (`initialize`, `ping`, `tools/list|call`, `prompts/list|get`, `resources/list|read`), maps `McpException` to JSON-RPC errors, and silently suppresses responses for notifications (`id == null`).
- **`McpServerConfig`** - Aggregate registry of tools, prompts, resources, server identity, protocol version, instructions, capabilities, and pagination strategy. Typically registered as a bean in your `RestContext` bean store.
@@ -4746,7 +4746,7 @@ A new REST module, `juneau-rest-server-mcp`, exposes a stateless MCP JSON-RPC en
- **`McpTypedToolHandler<A,R>`**, **`McpTypedPromptHandler<A>`**, **`McpTypedHandlers`** - Optional sugar layer for binding incoming arguments into Juneau beans and wrapping non-`CallToolResult` returns as a single-`TextContent` result.
- **`McpCursor`**, **`McpPage<T>`** - Pagination strategy seam. Built-in implementations: `McpCursor.SINGLE_PAGE` (default, returns everything in one page) and `McpCursor.fixedSize(n)` (opaque integer-offset paging).
-#### Drop-in servlet
+### Drop-in servlet
```java
@Rest(path="/mcp")
@@ -4760,7 +4760,7 @@ public class MyMcpServlet extends McpRestServlet {
}
```
-#### Mixin on an existing resource
+### Mixin on an existing resource
```java
@Rest(path="/api")
@@ -4772,7 +4772,7 @@ public class MyResource extends BasicRestServlet implements McpEndpoint {
}
```
-#### Typed handlers
+### Typed handlers
```java
public class WeatherArgs { String city; String unit; /* getters/setters */ }
@@ -4787,7 +4787,7 @@ McpTypedToolHandler<WeatherArgs, WeatherResult> typed = new McpTypedToolHandler<
config.addTool(McpTypedHandlers.adaptTool(typed));
```
-#### Pagination
+### Pagination
```java
config.setCursor(McpCursor.fixedSize(50));
@@ -4795,7 +4795,7 @@ config.setCursor(McpCursor.fixedSize(50));
The cursor receives the full descriptor list and the inbound cursor token, and returns an `McpPage<T>` containing the slice plus an opaque `nextCursor`. Custom strategies plug in via the `McpCursor` functional interface.
-#### Notifications
+### Notifications
Requests without an `id` are treated as JSON-RPC notifications: handlers run, exceptions are swallowed, and the dispatcher returns `null`. The REST servlet writes an empty body so transports can map this to `204 No Content`.
@@ -4807,15 +4807,15 @@ A new opt-in REST module, `juneau-rest-server-metrics-micrometer`, bridges the n
`mvn -pl juneau-rest/juneau-rest-server dependency:tree | grep -i micrometer` returns nothing — the containment requirement is verified at build time.
-#### New Classes
+### New Classes
- **`org.apache.juneau.rest.metrics.micrometer.MicrometerMetricsRecorder`** — `MetricsRecorder` implementation. Builds a Micrometer `Timer` named `http.server.requests` (overridable via the two-arg constructor) with four tags per Spring Boot's `WebMvcMetricsFilter` convention: `method` (uppercased HTTP method), `uri` (the `@RestOp` path template — bounded cardinality), `status` (HTTP response status), `exception` (the thrown exception's simple-name, or `None` on the happy path). Records [...]
-#### Naming convention
+### Naming convention
Spring Boot's `http.server.requests` + `{method, uri, status, exception}` was chosen (TODO-67 resolved decision #2) over the OTel-native `http.server.duration` shape because the wider Prometheus / Grafana scrape-config and dashboard ecosystem already standardizes on it. The OTel-native attribute names live in the sibling `juneau-rest-server-tracing-otel` module (see below).
-#### Wiring
+### Wiring
```java
@Configuration
@@ -4825,7 +4825,7 @@ public class ObservabilityConfig {
}
```
-#### Dependency
+### Dependency
```xml
<dependency>
@@ -4848,16 +4848,16 @@ A new opt-in REST module, `juneau-rest-server-tracing-otel`, bridges the new `Tr
`mvn -pl juneau-rest/juneau-rest-server dependency:tree | grep -i opentelemetry` returns nothing — the containment requirement is verified at build time.
-#### New Classes
+### New Classes
- **`org.apache.juneau.rest.tracing.otel.OtelTracerHook`** — `TracerHook` implementation. Each request becomes a single `SpanKind.SERVER` span named after the HTTP method (`GET`, `POST`, …) per the OpenTelemetry HTTP semantic conventions, with attributes `http.request.method`, `http.response.status_code`, and `http.route` (the `@RestOp` path template, bounded cardinality). On the exception path, the throwable is recorded via `Span.recordException(...)`, the span status is set to `StatusC [...]
- **`org.apache.juneau.rest.tracing.otel.RestRequestTextMapGetter`** — `TextMapGetter<RestRequest>` for OpenTelemetry context extraction. Reads the standard W3C `traceparent` / `tracestate` headers (and any other propagator-defined headers, e.g. baggage) from the incoming request so the server span is created as a child of the caller's trace.
-#### Attribute naming convention
+### Attribute naming convention
OpenTelemetry HTTP semantic conventions (`http.request.method`, `http.response.status_code`, `http.route`) were chosen (TODO-67 resolved decision #2) for the tracer hook to keep the spans interoperable with any OTel collector / backend. The Spring-Boot-style `http.server.requests` metric shape lives in the sibling `juneau-rest-server-metrics-micrometer` module (see above).
-#### Wiring
+### Wiring
```java
@Configuration
@@ -4871,13 +4871,13 @@ public class ObservabilityConfig {
}
```
-#### W3C trace-context propagation
+### W3C trace-context propagation
Incoming `traceparent` / `tracestate` request headers are extracted via the configured `TextMapPropagator` (default: `W3CTraceContextPropagator`) so the server span continues a caller-supplied distributed trace. Downstream HTTP calls made from inside the handler pick up the active span's context automatically when the outbound HTTP client honors the OTel `Context.current()` (the standard OTel client instrumentations do).
On the **outgoing** side (TODO-114), `OtelTracerHook.startSpan(...)` now also renders the W3C `traceparent` / `tracestate` values from the server-started span context at span-start time and stashes them as request attributes (`juneau.traceparent` / `juneau.tracestate`). The new `TraceContextResponseProcessor` in `juneau-rest-server` writes those onto the HTTP response so callers can read the resulting trace id back — see the [juneau-rest-server](#juneau-rest-server) entry above.
-#### Dependency
+### Dependency
```xml
<dependency>
@@ -4894,7 +4894,7 @@ On the **outgoing** side (TODO-114), `OtelTracerHook.startSpan(...)` now also re
See [REST Server — Observability (Micrometer + OpenTelemetry)](/docs/topics/RestServerObservability) for the full topic.
-#### Security
+### Security
- Bumped `io.opentelemetry:opentelemetry-api` from `1.43.0` to `1.62.0` (TODO-111). Closes Dependabot alerts #28 and #29 (CVE-2026-45292 / GHSA-rcgg-9c38-7xpx — "OpenTelemetry Java SDK has Unbounded Memory Allocation in W3C Baggage Propagation"; affected range `<= 1.61.0`). The bridge's API surface (`Tracer` / `Span` / `Context` / `Scope` / `TextMapGetter`) is stable across the 1.x line; no consumer-visible behavior change.
@@ -4902,13 +4902,13 @@ See [REST Server — Observability (Micrometer + OpenTelemetry)](/docs/topics/Re
A new opt-in REST module, `juneau-rest-server-view-jsp`, adds JSP view-rendering to `juneau-rest-server` without bleeding the JSP-engine dependency (Apache Jasper) into the core. The new `View` interface (see [juneau-rest-server](#juneau-rest-server)) lives in core; this module ships the JSP-specific implementation. Engine-agnostic POM stance: the bridge module declares the JSP API + JSTL impl in `provided` scope only — consumers add the engine matching their container (Jetty 12 EE11's ` [...]
-#### New Classes
+### New Classes
- **`org.apache.juneau.rest.view.jsp.BasicJspResource`** — REST mixin attachable via `@Rest(mixins=BasicJspResource.class)`. Adds a default `/jsp/*` mount that forwards raw `.jsp` requests to the container's JSP engine, and contributes `JspViewRenderer` to the mixin's response-processor chain. Builder API: `BasicJspResource.create().basePath("/WEB-INF/views/").build()`.
- **`org.apache.juneau.rest.view.jsp.JspView`** — `View` implementation. Immutable value class; fluent builder: `JspView.of("hello.jsp").attr("name", name).header("Cache-Control", "no-store")`. `attr(...)` rejects `null` values because Servlet-spec `setAttribute(name, null)` deletes the binding rather than setting it.
- **`org.apache.juneau.rest.view.jsp.JspViewRenderer`** — `ResponseProcessor` that detects `JspView`-typed return values and dispatches via `ServletContext.getRequestDispatcher(...).forward(...)`. When no JSP engine is on the classpath, surfaces `NO_ENGINE_DIAGNOSTIC` naming the missing dependency.
-#### Dependency
+### Dependency
```xml
<dependency>
@@ -4930,7 +4930,7 @@ A new opt-in REST module, `juneau-rest-server-view-jsp`, adds JSP view-rendering
</dependency>
```
-#### Composition example
+### Composition example
```java
@Rest(path="/app", mixins=BasicJspResource.class)
@@ -4950,7 +4950,7 @@ public class AppResource extends RestServlet {
}
```
-#### Typed-handler View-return integration (`JspView_TypedHandler_Test`)
+### Typed-handler View-return integration (`JspView_TypedHandler_Test`)
`@RestGet` methods returning `JspView` now reach `JspViewRenderer` rather than being
bean-serialized, thanks to the `ResponseProcessorList` partition pass. To use `JspView`
@@ -4978,13 +4978,13 @@ A new opt-in REST module, `juneau-rest-server-view-thymeleaf`, adds [Thymeleaf](
Unlike JSP, Thymeleaf's core engine has zero servlet-container dependencies — it renders directly to a `java.io.Writer`. The raw-template mount under `/thymeleaf/*` works fully under MockRest, Jetty microservices, and Spring Boot uniformly. The bridge picks up a Spring-autoconfigured `SpringTemplateEngine` automatically via `BeanStore.getBean(TemplateEngine.class)`; when no engine bean is registered the bridge constructs a default `TemplateEngine` with a single `ClassLoaderTemplateResolv [...]
-#### New Classes
+### New Classes
- **`org.apache.juneau.rest.view.thymeleaf.BasicThymeleafResource`** — REST mixin attachable via `@Rest(mixins=BasicThymeleafResource.class)`. Adds a default `/thymeleaf/*` mount that renders raw `.html` templates under the configured base path, and contributes `ThymeleafViewRenderer` to the mixin's response-processor chain. Builder API: `BasicThymeleafResource.create().basePath("/templates/").cacheTemplates(false).templateMode(TemplateMode.HTML).build()`. Configurable mount path via SVL [...]
- **`org.apache.juneau.rest.view.thymeleaf.ThymeleafView`** — `View` implementation. Immutable value class; fluent builder: `ThymeleafView.of("hello").attr("name", name).header("Cache-Control", "no-store")`. `attr(...)` rejects `null` values because a Thymeleaf `Context` silently drops `null`-valued bindings, which masks caller bugs.
- **`org.apache.juneau.rest.view.thymeleaf.ThymeleafViewRenderer`** — `ResponseProcessor` that detects `ThymeleafView`-typed return values and asks the configured `org.thymeleaf.TemplateEngine` to render them directly onto the response writer. When no Thymeleaf engine is on the classpath, surfaces `NO_ENGINE_DIAGNOSTIC` naming the missing dependency.
-#### Dependency
+### Dependency
```xml
<dependency>
@@ -5006,7 +5006,7 @@ Unlike JSP, Thymeleaf's core engine has zero servlet-container dependencies —
</dependency>
```
-#### Composition example
+### Composition example
```java
@Rest(path="/app", mixins=BasicThymeleafResource.class)
@@ -5026,7 +5026,7 @@ public class AppResource extends RestServlet {
}
```
-#### Typed-handler View-return integration (`ThymeleafView_TypedHandler_Test`)
+### Typed-handler View-return integration (`ThymeleafView_TypedHandler_Test`)
`@RestGet` methods returning `ThymeleafView` now reach `ThymeleafViewRenderer` rather than
being bean-serialized. Because Thymeleaf renders directly to a `Writer` with no
@@ -5036,7 +5036,7 @@ fully assertable under MockRest. Add `ThymeleafViewRenderer.class` to the host'
See [Thymeleaf View Support](/docs/topics/ThymeleafViewSupport) for the full topic — engine-selection matrix, Spring Boot integration notes, path-traversal hardening, and known limitations.
-#### Security
+### Security
- Bumped `org.thymeleaf:thymeleaf` from `3.1.3.RELEASE` to `3.1.5.RELEASE` (TODO-110). Closes Dependabot alerts #24, #25, #26, and #27 — CVE-2026-40477 / GHSA-r4v4-5mwr-2fwr (improper restriction of accessible-object scope), CVE-2026-40478 / GHSA-xjw8-8c5c-9r79 (unauthorized expression syntax), and CVE-2026-41901 / GHSA-c9ph-gxww-7744 (sandboxed-expression syntax-recognition bypass). All four are sandbox-scope vulnerabilities; the Juneau bridge does not enable sandboxed expressions expli [...]
@@ -5046,13 +5046,13 @@ A new opt-in REST module, `juneau-rest-server-view-mustache`, adds [Mustache](ht
Mustache's core engine has zero servlet-container dependencies — it compiles to bytecode and renders directly to a `java.io.Writer`. The raw-template mount under `/mustache/*` works fully under MockRest, Jetty microservices, and Spring Boot uniformly. The bridge picks up a user-supplied `MustacheFactory` automatically via `BeanStore.getBean(MustacheFactory.class)`; when no factory bean is registered the bridge constructs a default `DefaultMustacheFactory` anchored on the classpath direct [...]
-#### New Classes
+### New Classes
- **`org.apache.juneau.rest.view.mustache.BasicMustacheResource`** — REST mixin attachable via `@Rest(mixins=BasicMustacheResource.class)`. Adds a default `/mustache/*` mount that renders raw `.mustache` templates under the configured base path, and contributes `MustacheViewRenderer` to the mixin's response-processor chain. Builder API: `BasicMustacheResource.create().basePath("/templates/").templateSuffix(".mustache").build()`. Configurable mount path via SVL `${juneau.mustache.path:mus [...]
- **`org.apache.juneau.rest.view.mustache.MustacheView`** — `View` implementation. Immutable value class; fluent builder: `MustacheView.of("hello").attr("name", name).header("Cache-Control", "no-store")`. `attr(...)` rejects `null` values to surface caller bugs early.
- **`org.apache.juneau.rest.view.mustache.MustacheViewRenderer`** — `ResponseProcessor` that detects `MustacheView`-typed return values and asks the configured `com.github.mustachejava.MustacheFactory` to compile and execute them directly onto the response writer. When no Mustache engine is on the classpath, surfaces `NO_ENGINE_DIAGNOSTIC` naming the missing dependency.
-#### Dependency
+### Dependency
```xml
<dependency>
@@ -5068,7 +5068,7 @@ Mustache's core engine has zero servlet-container dependencies — it compiles t
</dependency>
```
-#### Composition example
+### Composition example
```java
@Rest(path="/app", mixins=BasicMustacheResource.class)
@@ -5088,7 +5088,7 @@ public class AppResource extends RestServlet {
}
```
-#### Typed-handler View-return integration (`MustacheView_TypedHandler_Test`)
+### Typed-handler View-return integration (`MustacheView_TypedHandler_Test`)
`@RestGet` methods returning `MustacheView` now reach `MustacheViewRenderer` rather than
being bean-serialized. mustache.java renders directly to a `Writer` with no
@@ -5104,13 +5104,13 @@ A new opt-in REST module, `juneau-rest-server-view-freemarker`, adds [Apache Fre
FreeMarker is the engine behind countless admin consoles, code generators, email templates, and reporting tools — Apache-family alignment (ASF-maintained engine, same license as Juneau itself), richer expression syntax than logic-less Mustache, and native HTML auto-escaping via the `.ftlh` template flavor. The core engine has zero servlet-container dependencies; it asks `freemarker.template.Configuration` for a `Template` and `template.process(dataModel, writer)` streams the rendered out [...]
-#### New Classes
+### New Classes
- **`org.apache.juneau.rest.view.freemarker.BasicFreemarkerResource`** — REST mixin attachable via `@Rest(mixins=BasicFreemarkerResource.class)`. Adds a default `/freemarker/*` mount that renders raw `.ftl` / `.ftlh` templates under the configured base path, and contributes `FreemarkerViewRenderer` to the mixin's response-processor chain. Builder API: `BasicFreemarkerResource.create().basePath("/templates/").templateSuffix(".ftlh").cacheTemplates(true).build()`. Configurable mount path v [...]
- **`org.apache.juneau.rest.view.freemarker.FreemarkerView`** — `View` implementation. Immutable value class; fluent builder: `FreemarkerView.of("hello.ftlh").attr("name", name).header("Cache-Control", "no-store")`. `attr(...)` rejects `null` values to surface caller bugs early.
- **`org.apache.juneau.rest.view.freemarker.FreemarkerViewRenderer`** — `ResponseProcessor` that detects `FreemarkerView`-typed return values and asks the configured `freemarker.template.Configuration` to `getTemplate(name).process(dataModel, writer)` directly onto the response writer. When no FreeMarker engine is on the classpath, surfaces `NO_ENGINE_DIAGNOSTIC` naming the missing dependency (with a pointer to `spring-boot-starter-freemarker` for Spring Boot apps).
-#### Dependency
+### Dependency
```xml
<dependency>
@@ -5126,7 +5126,7 @@ FreeMarker is the engine behind countless admin consoles, code generators, email
</dependency>
```
-#### Composition example
+### Composition example
```java
@Rest(path="/app", mixins=BasicFreemarkerResource.class)
@@ -5147,7 +5147,7 @@ public class AppResource extends RestServlet {
}
```
-#### Typed-handler View-return integration (`FreemarkerView_TypedHandler_Test`)
+### Typed-handler View-return integration (`FreemarkerView_TypedHandler_Test`)
`@RestGet` methods returning `FreemarkerView` now reach `FreemarkerViewRenderer` rather than
being bean-serialized. FreeMarker renders directly to a `Writer` with no servlet-container
@@ -5165,7 +5165,7 @@ A new bean module, `juneau-bean-rfc7807`, provides typed beans for [RFC 7807 —
The module ships a single `Problem` bean covering the five canonical members defined in §3.1 (`type`, `title`, `status`, `detail`, `instance`) plus an open-ended extension-member fan-out per §3.2. Only depends on `juneau-marshall`.
-#### Bean shape
+### Bean shape
- `URI type` — nullable. `getType()` returns the raw value; `getTypeOrDefault()` returns `URI.create("about:blank")` per §3.1 when unset (without mutating the field).
- `String title` — short human-readable summary of the problem type.
@@ -5182,7 +5182,7 @@ Problem.fromStatus(e.getStatusCode(), e.getStatusLine().getReasonPhrase(), e.get
The bean does not eagerly default the `type` field, so a fresh `new Problem()` round-trips without a synthetic `"type":"about:blank"` on the wire.
-#### Example
+### Example
```java
import org.apache.juneau.bean.rfc7807.*;
@@ -5203,7 +5203,7 @@ Problem back = JsonParser.DEFAULT.parse(json, Problem.class);
The matching `Content-Type` constants (`ContentType.APPLICATION_PROBLEM_JSON` and `ContentType.APPLICATION_PROBLEM_XML`) have shipped in `juneau-rest-common` since 9.2.x; this module closes the loop by adding the typed wire bean.
-#### Throw + map SPIs
+### Throw + map SPIs
The module also ships the seams used by the new `juneau-rest-server` problem-details wiring (see [RFC 7807 / 9457 Problem-Details server-side wiring](#rfc-7807--9457-problem-details-server-side-wiring) above):
@@ -5218,7 +5218,7 @@ See [juneau-bean-rfc7807](/docs/topics/JuneauBeanRfc7807) for the full topic.
A new bean module, `juneau-bean-hal`, models the [HAL (Hypertext Application Language)](https://stateless.group/hal_specification.html) hypermedia format ([draft-kelly-json-hal-08](https://datatracker.ietf.org/doc/html/draft-kelly-json-hal-08)) as Juneau `@Marshalled` POJOs. The beans round-trip cleanly through the default `JsonSerializer` / `JsonParser` for `application/hal+json` payloads — no custom marshaller required. Only depends on `juneau-marshall`. The matching `Content-Type` con [...]
-#### Bean shape
+### Bean shape
- **`HalResource`** — top-level HAL resource carrying the reserved `_links` map (`Map<String,Object>` whose values are single `HalLink` or `HalLinkArray`), the reserved `_embedded` map (`Map<String,Object>` whose values are single `HalResource` or `HalResourceArray`), and an open-ended payload via the `@BeanProp("*")` extra-properties triplet (`extraKeys()` / `get(String)` / `set(String, Object)`).
- **`HalLink`** — all eight Link Object fields per draft-kelly-json-hal-08: `href` (required URI/URI-template), `templated`, `type`, `deprecation`, `name`, `profile`, `title`, `hreflang`.
@@ -5228,7 +5228,7 @@ A new bean module, `juneau-bean-hal`, models the [HAL (Hypertext Application Lan
Convenience methods on `HalResource` make the spec's single-or-array shapes ergonomic: `addLink(rel, link)` sets a single-link value; `addLinks(rel, links...)` promotes the entry to a `HalLinkArray` (creating one or appending to an existing array as needed). The same pattern is mirrored for `_embedded` via `addEmbedded(rel, res)` / `addEmbedded(rel, res...)`.
-#### Example
+### Example
```java
import org.apache.juneau.bean.hal.*;
@@ -5255,7 +5255,7 @@ See [juneau-bean-hal](/docs/topics/JuneauBeanHal) for the full topic.
A new bean module, `juneau-bean-jsonapi`, models the [JSON:API v1.1](https://jsonapi.org/format/) wire format (`application/vnd.api+json`) as Juneau `@Marshalled` POJOs. The beans round-trip cleanly through the default `JsonSerializer` / `JsonParser` — no custom marshaller required. Only depends on `juneau-marshall`. The matching `Content-Type` constant (`ContentType.APPLICATION_VND_API_JSON`) has shipped in `juneau-rest-common` since 9.2.x.
-#### Bean shape
+### Bean shape
- **`JsonApiDocument`** — top-level container with `data`, `errors`, `meta`, `jsonapi`, `links`, `included`. Includes a `validate()` helper that enforces the document-level invariants: at least one of `data` / `errors` / `meta` must be present, and `data` and `errors` MUST NOT coexist.
- **`JsonApiResource`** — resource object with `type`, `id`, `attributes`, `relationships`, `links`, `meta`. `type` is modeled as a plain `String` (and **not** as a `@Marshalled(typePropertyName="type", dictionary=...)` discriminator) because JSON:API `type` is an open-ended entity-type name chosen by the API; turning it into a Juneau dispatch discriminator would break round-tripping of unknown values and force every API to enumerate its resource types in a Java dictionary up front.
@@ -5266,7 +5266,7 @@ A new bean module, `juneau-bean-jsonapi`, models the [JSON:API v1.1](https://jso
- **`JsonApiVersion`** — the `jsonapi` member (`version`, `meta`).
- **`JsonApiLinkOrStringSwap`** — per-property `ObjectSwap` applied to every `links` map (on `JsonApiDocument`, `JsonApiResource`, `JsonApiRelationship`, `JsonApiError`) so that each map entry round-trips as either a JSON string URL or a `JsonApiLink` JSON object per the spec.
-#### Example
+### Example
```java
import org.apache.juneau.bean.jsonapi.*;
@@ -5291,13 +5291,13 @@ See [juneau-bean-jsonapi](/docs/topics/JuneauBeanJsonApi) for the full topic.
A new bean module, `juneau-bean-jsonpatch`, models [JSON Patch (RFC 6902)](https://datatracker.ietf.org/doc/html/rfc6902) operation documents (`application/json-patch+json`) as Juneau `@Marshalled` POJOs with polymorphic dispatch on the `op` discriminator. Only depends on `juneau-marshall`. The matching `Content-Type` constant (`ContentType.APPLICATION_JSON_PATCH`) has shipped in `juneau-rest-common` since 9.2.x.
-#### Bean shape
+### Bean shape
- **`JsonPatchOperation`** — abstract base carrying the shared `path` (JSON Pointer / RFC 6901) field. Annotated `@Marshalled(typePropertyName="op", dictionary={AddOp, RemoveOp, ReplaceOp, MoveOp, CopyOp, TestOp})` so the parser materializes the correct concrete subclass keyed off the `op` member. Kept open (not `sealed`) so downstream callers can extend the dictionary with custom ops.
- **`AddOp`**, **`RemoveOp`**, **`ReplaceOp`**, **`MoveOp`**, **`CopyOp`**, **`TestOp`** — the six standard operations from §4. `add`/`replace`/`test` carry a `value` payload (`Object`); `move`/`copy` carry a `from` JSON Pointer; `remove` has no extra members.
- **`JsonPatch`** — `LinkedList<JsonPatchOperation>` representing a JSON Patch document, which serializes as a top-level JSON array per the RFC. Mirrors the `JsonSchemaArray` top-level-array pattern (rather than `@Json(wrapperAttr=...)`).
-#### Polymorphic Serialization
+### Polymorphic Serialization
`JsonPatchOperation` uses `@Marshalled(typePropertyName="op", dictionary={...})` to discriminate at the wire level. Configure your serializer with `addBeanTypes()` to emit the discriminator on output:
@@ -5312,7 +5312,7 @@ JsonParser par = JsonParser.create()
.build();
```
-#### Example
+### Example
```java
import org.apache.juneau.bean.jsonpatch.*;
@@ -5333,7 +5333,7 @@ See [juneau-bean-jsonpatch](/docs/topics/JuneauBeanJsonPatch) for the full topic
### Tooling
-#### `/sonarqube` Cursor command + `scripts/sonarqube.py` + `eclipse-warnings` skill (TODO-39)
+### `/sonarqube` Cursor command + `scripts/sonarqube.py` + `eclipse-warnings` skill (TODO-39)
Added a paired terminal/chat workflow for triaging SonarCloud findings on a source file, package, or Maven module — symmetric with the existing `/coverage` + `scripts/coverage.py` flow.
@@ -5345,7 +5345,7 @@ Added a paired terminal/chat workflow for triaging SonarCloud findings on a sour
See `.cursor/commands/sonarqube.md` and the `5.2. SonarQube Script` section in `AGENTS.md` for the full reference.
-#### JMH micro-benchmark: observability NoOp zero-allocation gate (TODO-116)
+### JMH micro-benchmark: observability NoOp zero-allocation gate (TODO-116)
Added a JMH micro-benchmark harness and wrapper script asserting the `RestOpInvoker` observability hot path allocates **zero objects per invocation** when both `MetricsRecorder` and `TracerHook` resolve to their NoOp singletons.
@@ -5357,11 +5357,11 @@ Added a JMH micro-benchmark harness and wrapper script asserting the `RestOpInvo
The benchmark confirms FINISHED-67's zero-allocation promise for the NoOp short-circuit; the TODO-139 CI gate follow-on can wire this result into a hard-fail check.
-#### Docs push-time smoke check (TODO-130)
+### Docs push-time smoke check (TODO-130)
`scripts/push.py` now runs a Docusaurus build smoke check (`build-docs.py --skip-maven`) before pushing `juneau-docs` changes. When `push.py` detects pending commits in the sibling `juneau-docs` repo, it runs `python3 scripts/build-docs.py --skip-maven` first; a non-zero exit aborts the push with a clear error message (`❌ Docs smoke check failed — fix the Docusaurus build before pushing juneau-docs.`). This catches broken admonitions, malformed MDX, or bad plugin config before the commit [...]
-#### Doc-site local build/publish flow + Docusaurus search swap (TODO-71)
+### Doc-site local build/publish flow + Docusaurus search swap (TODO-71)
Two paired changes that retire the push-triggered GitHub Action for the docs site in favor of explicit local scripts, and replace the Algolia DocSearch integration with a self-contained client-side search index.
diff --git a/pages/topics/01.01.01.Commons.md b/pages/topics/01.01.01.Commons.md
new file mode 100644
index 0000000000..6c120a7711
--- /dev/null
+++ b/pages/topics/01.01.01.Commons.md
@@ -0,0 +1,269 @@
+---
+title: "Commons"
+slug: Commons
+---
+
+# Commons
+
+The [juneau-commons](/docs/topics/JuneauCommonsBasics) module is the foundational layer of the Juneau ecosystem.
+It has no framework dependencies — just Java — and provides the low-level utilities, collections, I/O helpers,
+reflection tools, settings management, and dependency-injection support that all other Juneau modules build on top of.
+Because every other Juneau module depends on it transitively, its classes are always on the classpath whenever you
+use Juneau.
+
+### String & General Utilities
+
+[org.apache.juneau.commons.utils](https://juneau.apache.org/site/apidocs/current/index.html?org/apache/juneau/commons/utils/package-summary.html) contains the most frequently used utility classes in the codebase.
+
+<java-class><a href="/site/apidocs/org/apache/juneau/commons/utils/StringUtils.html" target="_blank">StringUtils</a></java-class>
+provides a large collection of static string-manipulation helpers:
+
+```java
+import static org.apache.juneau.commons.utils.StringUtils.*;
+
+// Formatting (supports both MessageFormat and printf styles)
+String s = format("Hello {0}, you have {1} items", "Alice", 5);
+String t = format("Hello %s, you have %d items", "Alice", 5);
+
+// Null/empty checks
+isEmpty(null); // true
+isEmpty(""); // true
+isNotEmpty("hi"); // true
+
+// Abbreviation, padding, camel-casing
+abbreviate("Hello World", 8); // "Hello..."
+camelToKebab("fooBarBaz"); // "foo-bar-baz"
+```
+
+<java-class><a href="/site/apidocs/org/apache/juneau/commons/utils/Utils.html" target="_blank">Utils</a></java-class>
+is the general-purpose utility class imported statically across the codebase:
+
+```java
+import static org.apache.juneau.commons.utils.Utils.*;
+
+// Concise collection literals
+List<String> list = l("a", "b", "c");
+String[] arr = a("a", "b", "c");
+
+// Null/empty tests
+nn(obj); // true if obj != null
+n(obj); // true if obj == null
+ne(str); // true if string is non-null and non-empty
+
+// Stable hash across multiple values
+int hash = h("key", 42, true);
+
+// Memoized supplier (computed once, then cached)
+NullableSupplier<String> lazy = memoize(() -> expensiveCall());
+```
+
+<java-class><a href="/site/apidocs/org/apache/juneau/commons/utils/DateUtils.html" target="_blank">DateUtils</a></java-class>
+offers lightweight date/time formatting and parsing helpers without requiring a full date-parsing library.
+
+### Collections
+
+[org.apache.juneau.commons.collections](https://juneau.apache.org/site/apidocs/current/index.html?org/apache/juneau/commons/collections/package-summary.html) provides fluent wrappers, filtered views, multi-value maps, and
+thread-safe caches on top of the standard Java Collections Framework.
+
+```java
+// Fluent collections — mutable wrappers with builder-style add/remove
+FluentList<String> list = new FluentList<String>()
+ .a("foo", "bar")
+ .a("baz");
+
+FluentMap<String, Integer> map = new FluentMap<String, Integer>()
+ .a("one", 1)
+ .a("two", 2);
+
+// Multi-value map (one key → many values)
+MultiMap<String, String> mm = new MultiMap<>();
+mm.put("colors", "red");
+mm.put("colors", "blue");
+List<String> colors = mm.get("colors"); // ["red", "blue"]
+
+// Thread-safe, size-bounded cache (LRU eviction)
+Cache<String, MyBean> cache = Cache.of(1000);
+MyBean bean = cache.get("key", k -> loadBean(k));
+
+// Filtered/reversed views
+FilteredList<String> view = new FilteredList<>(source, s -> s.startsWith("A"));
+ReversedList<String> reversed = new ReversedList<>(source);
+```
+
+### I/O Utilities
+
+[org.apache.juneau.commons.io](https://juneau.apache.org/site/apidocs/current/index.html?org/apache/juneau/commons/io/package-summary.html) provides file and stream helpers that complement the standard `java.io` API.
+
+```java
+// LocalFile — a rich File wrapper
+LocalFile f = LocalFile.of("config/app.properties");
+String text = f.readText();
+byte[] bytes = f.readBytes();
+f.writeText("updated content");
+
+// LocalDir — directory navigation and listing
+LocalDir dir = LocalDir.of("src/main/resources");
+List<LocalFile> files = dir.files("*.json");
+
+// Charset-safe file readers/writers
+Reader r = FileReaderBuilder.of("data.txt").charset("UTF-8").build();
+
+// Decorators
+InputStream noClose = new NoCloseOutputStream(out); // ignores close()
+```
+
+### Reflection Utilities
+
+[org.apache.juneau.commons.reflect](https://juneau.apache.org/site/apidocs/current/index.html?org/apache/juneau/commons/reflect/package-summary.html) provides a rich, cached wrapper layer over the standard Java reflection API.
+
+```java
+// ClassInfo — cached wrapper for Class<?>
+ClassInfo ci = ClassInfo.of(MyBean.class);
+MethodInfo mi = ci.getMethod("setName", String.class);
+FieldInfo fi = ci.getField("value");
+
+// Annotation traversal across class hierarchies
+ci.getAnnotations(MyAnnotation.class).forEach(a -> { /* ... */ });
+
+// Check assignability, interfaces, etc.
+ci.isAssignableTo(Serializable.class);
+ci.isPublic();
+ci.isAbstract();
+```
+
+### Settings & Property Sources
+
+[org.apache.juneau.commons.settings](https://juneau.apache.org/site/apidocs/current/index.html?org/apache/juneau/commons/settings/package-summary.html) provides layered property lookup with support for system properties,
+environment variables, `.env` files, manifest entries, command-line arguments, and custom sources.
+
+```java
+// Look up a property with automatic type conversion
+StringSetting jvmVendor = Settings.get().get("java.vendor");
+String vendor = jvmVendor.get();
+
+Setting<Integer> timeout = Settings.get().get("app.timeout").asInteger();
+int ms = timeout.orElse(5000);
+
+// Thread-local override (handy in tests)
+Settings.get().setLocal("app.timeout", "999");
+// ... exercise the code under test ...
+Settings.get().clearLocal();
+
+// Composable property store: args → env → system props → defaults
+PropertyStore store = PropertyStore.of(
+ new ArgsPropertySource(argv),
+ new SystemEnvPropertySource(),
+ new SystemPropertyPropertySource()
+);
+String dbUrl = store.get("DB_URL").orElse("jdbc:h2:mem:");
+```
+
+### Dependency Injection
+
+[org.apache.juneau.commons.inject](https://juneau.apache.org/site/apidocs/current/index.html?org/apache/juneau/commons/inject/package-summary.html) is a lightweight, JSR-330–compatible dependency-injection framework
+used internally by Juneau's REST server, microservice, and config modules.
+It supports `@Inject`, `@Named`, `@Singleton`, `@Primary`, `@Order`, `@Bean`, `@Configuration`,
+`@Conditional`, `@PostConstruct`, and `@PreDestroy` without compile-time dependencies on
+`jakarta.inject-api` or `jakarta.annotation-api`.
+
+```java
+// Build a bean store and add beans directly
+BeanStore store = BeanStore.create()
+ .bean(DataSource.class, myDataSource)
+ .bean(String.class, "jdbc:h2:mem:", "dbUrl")
+ .build();
+
+// Retrieve beans by type (and optional name)
+DataSource ds = store.getBean(DataSource.class).orElseThrow();
+
+// Wire a class whose constructor is annotated with @Inject
+MyService svc = store.createBean(MyService.class);
+```
+
+### Runtime Utilities
+
+[org.apache.juneau.commons.runtime](https://juneau.apache.org/site/apidocs/current/index.html?org/apache/juneau/commons/runtime/package-summary.html) provides helpers for working with the JVM runtime environment.
+
+<java-class><a href="/site/apidocs/org/apache/juneau/commons/runtime/Args.html" target="_blank">Args</a></java-class>
+parses command-line arguments into a structured, queryable object:
+
+```java
+Args args = new Args(argv);
+
+// Positional arguments
+String first = args.get(0).orElse(null);
+
+// Named options: -key value or --key value
+String host = args.get("host").orElse("localhost");
+int port = Integer.parseInt(args.get("port").orElse("8080"));
+
+// Boolean flags: -verbose
+boolean verbose = args.has("verbose");
+```
+
+<java-class><a href="/site/apidocs/org/apache/juneau/commons/runtime/ManifestFile.html" target="_blank">ManifestFile</a></java-class>
+reads entries from `META-INF/MANIFEST.MF`:
+
+```java
+ManifestFile mf = ManifestFile.get(); // From system class-loader
+String version = mf.get("Implementation-Version").orElse("dev");
+```
+
+### Logging
+
+[org.apache.juneau.commons.logging](https://juneau.apache.org/site/apidocs/current/index.html?org/apache/juneau/commons/logging/package-summary.html) provides a thin, JUL-based logging abstraction used across the Juneau codebase.
+
+<java-class><a href="/site/apidocs/org/apache/juneau/commons/logging/Logger.html" target="_blank">Logger</a></java-class>
+wraps `java.util.logging.Logger` with printf-style formatting and fluent convenience methods.
+<java-class><a href="/site/apidocs/org/apache/juneau/commons/logging/LogRecordCapture.html" target="_blank">LogRecordCapture</a></java-class>
+lets tests intercept and assert on log output:
+
+```java
+try (LogRecordCapture capture = LogRecordCapture.install(MyService.class)) {
+ myService.doSomething();
+ List<LogRecord> records = capture.getRecords();
+ // assert on records...
+}
+```
+
+### Functional Utilities
+
+[org.apache.juneau.commons.function](https://juneau.apache.org/site/apidocs/current/index.html?org/apache/juneau/commons/function/package-summary.html) extends `java.util.function` with multi-argument and throwing variants:
+
+```java
+// Functions with up to 5 arguments
+Function2<String, Integer, String> f2 = (s, i) -> s.repeat(i);
+Function3<String, Integer, Boolean, String> f3 = (s, i, b) -> b ? s.repeat(i) : s;
+
+// Throwing variants (no need to catch checked exceptions inline)
+ThrowingFunction<String, MyObj> parse = MyObj::parse;
+ThrowingSupplier<Config> loader = Config::loadDefault;
+
+// Memoizer — computed once, resettable
+Memoizer<String> memo = memoizer(() -> expensiveComputation());
+String val = memo.get(); // computed
+memo.reset(); // force recomputation next call
+```
+
+### Simple Variable Language
+
+[org.apache.juneau.commons.svl](https://juneau.apache.org/site/apidocs/current/index.html?org/apache/juneau/commons/svl/package-summary.html) implements the Simple Variable Language (SVL) engine — a lightweight
+template language that resolves `$Var{...}` expressions at runtime.
+SVL is used throughout Juneau's configuration, microservice, and REST layers to inject dynamic values
+into strings.
+
+See [Simple Variable Language](/docs/topics/SimpleVariableLanguageBasics).
+
+### Other Notable Packages
+
+| Package | Highlights |
+|---------|-----------|
+| `lang` | Value-holder primitives (`IntegerHolder`, `BooleanHolder`, `Flag`), `Version`, `VersionRange`, `TriState`, `HashCode`, `StringFormat` |
+| `concurrent` | `SimpleLock`, `SimpleReadWriteLock`, `NullableReference` |
+| `time` | `GranularZonedDateTime` — a `ZonedDateTime` rounded to configurable granularity |
+| `conversion` | Type-conversion utilities used by settings and the inject layer |
+| `bean` (root) | `AnnotationUtils`, `AnnotationObject`, annotation-group wrappers used by the reflection layer |
+
+---
+
+For a full package-by-package reference see [juneau-commons Basics](/docs/topics/JuneauCommonsBasics).
diff --git a/pages/topics/01.01.JuneauEcosystemOverview.md b/pages/topics/01.01.JuneauEcosystemOverview.md
index a2052ec7a9..9cd00d3c4c 100644
--- a/pages/topics/01.01.JuneauEcosystemOverview.md
+++ b/pages/topics/01.01.JuneauEcosystemOverview.md
@@ -3,12 +3,12 @@ title: "Juneau Ecosystem Overview"
slug: JuneauEcosystemOverview
---
-#### About
+### About
Apache Juneau™ is a single cohesive Java ecosystem for marshalling Java objects to a wide variety of language types and
creating annotation-based REST end-to-end server and client APIs.
-#### Ecosystem
+### Ecosystem
The Juneau ecosystem consists of the following parts:
@@ -16,10 +16,8 @@ The Juneau ecosystem consists of the following parts:
|-----------------|-------------|---------------|
| **juneau-core** | | |
| [juneau‑commons](/docs/topics/JuneauCommonsBasics) | Common utilities and APIs used across the Juneau ecosystem (collections, I/O, reflection, settings, SVL, etc.) | • *None* |
-| [juneau‑assertions](/docs/topics/JuneauAssertionBasics) | Fluent-style assertions API | • *None* |
-| [juneau‑bct](/docs/topics/JuneauBctBasics) | Bean-Centric Testing framework | • JUnit 5 |
+| [juneau‑test](/docs/topics/JuneauAssertionBasics) | Fluent-style assertions, Bean-Centric Testing, and JUnit 5 extensions / test-time bean injection | • JUnit 5 |
| [juneau‑config](/docs/topics/JuneauConfigBasics) | Configuration File API | • *None* |
-| [juneau‑junit5](https://github.com/apache/juneau/tree/master/juneau-core/juneau-junit5) | JUnit 5 extensions and test-time bean injection | • JUnit 5 |
| [juneau‑marshall](/docs/topics/JuneauMarshallBasics) | Serializers and parsers for JSON (various flavors), XML, HTML, URL-Encoding, UON, OpenAPI, PlainText, CSV, SOAP, and MessagePack | • *None* |
| [juneau‑marshall‑rdf](/docs/topics/JuneauMarshallRdfOverview) | Serializers and parsers for RDF/XML (various flavors), N3, NTriple, and Turtle | • Apache Jena 5.x |
| [juneau‑test‑utils](https://github.com/apache/juneau/tree/master/juneau-core/juneau-test-utils) | Shared test infrastructure (commons-level; no juneau-marshall dependency) | • *None* |
diff --git a/pages/topics/01.02.01.SimpleVariableLanguage.md b/pages/topics/01.02.01.SimpleVariableLanguage.md
new file mode 100644
index 0000000000..89b608a1f4
--- /dev/null
+++ b/pages/topics/01.02.01.SimpleVariableLanguage.md
@@ -0,0 +1,95 @@
+---
+title: "Simple Variable Language"
+slug: SimpleVariableLanguage
+---
+
+# Simple Variable Language
+
+The <a href="/site/apidocs/org/apache/juneau/commons/svl/package-summary.html" target="_blank">org.apache.juneau.commons.svl</a> package defines an API for a language called "Simple Variable
+Language" (SVL) — text that contains variables of the form `$varName{varKey}`.
+Variables can be recursively nested and can return values that themselves contain more variables.
+
+`VarResolver.DEFAULT` ships the following built-in source variables:
+
+| Variable | Description |
+|---|---|
+| `$S{key[,default]}` | Java system property (`System.getProperty`). |
+| `$E{key[,default]}` | OS environment variable (`System.getenv`). |
+| `$EF{key[,default]}` | Key from a `.env`-style env file on the filesystem. |
+| `$DE{key[,default]}` | Key from a `.env` dotenv file (same format, alternative naming). |
+| `$A{key[,default]}` | Command-line argument passed to the JVM. |
+| `$MF{key[,default]}` | Entry from the classpath `META-INF/MANIFEST.MF`. |
+| `$P{key[,default]}` | Unified `Settings` source stack — consults system properties, env vars, classpath `juneau.cfg`, per-microservice Config, Spring `Environment`, and more in priority order. |
+| `${key:default}` | Shorthand for `$P{key,default}`. The Spring-style `:` default separator is rewritten to `,` before delegation. |
+
+:::tip Example
+```java
+// Resolve a system-property variable.
+String home = VarResolver.DEFAULT.resolve("Java home: $S{java.home}");
+
+// Nested fallback chain: env var → system property → literal default.
+String val = VarResolver.DEFAULT.resolve("$E{MY_VAR,$S{my.var,not found}}");
+
+// Spring-style ${...} shorthand against the unified Settings stack.
+String title = VarResolver.DEFAULT.resolve("${myapp.title:Untitled}");
+```
+:::
+
+## `#{...}` Function-call Syntax
+
+Alongside `$Var{...}` style variables, SVL supports a `#{name(args...)}` function-call syntax backed by a catalog of ~68 built-in functions across 10 categories:
+
+| Category | Example functions |
+|---|---|
+| String | `upper`, `lower`, `trim`, `substring`, `split`, `join`, `format`, `pathToken` |
+| Type conversion | `toInt`, `toLong`, `toDouble`, `toBoolean`, `toString` |
+| Arithmetic | `add`, `sub`, `mul`, `div`, `mod`, `min`, `max`, `abs`, `round` |
+| Boolean | `not`, `and`, `or`, `eq`, `ne` |
+| Conditional | `if`, `switch`, `coalesce`, `notEmpty`, `case` |
+| Regex | `matches`, `replace`, `extract` |
+| Encoding | `urlEncode`, `urlDecode`, `base64Encode`, `base64Decode`, `htmlEscape` |
+| Date/time | `now`, `today`, `formatDate`, `parseDate` |
+| Random/UUID | `uuid`, `randomInt`, `randomString` |
+| JSON navigation | `jsonPath`, `get`, `keys`, `values`, `size` |
+
+This syntax replaces 11 dedicated transformation `Var` classes (`$UC{}`, `$IF{}`, `$SW{}`, etc.) that were removed in 10.0 in favor of the unified function library.
+
+:::tip Example
+```java
+VarResolver.DEFAULT.resolve("#{upper(hello world)}"); // → "HELLO WORLD"
+VarResolver.DEFAULT.resolve("#{if(${prod:false}, prod-key, dev-key)}"); // → "dev-key"
+VarResolver.DEFAULT.resolve("#{switch(${tier:bronze}, gold:1.0, *:0)}"); // → "0"
+VarResolver.DEFAULT.resolve("#{uuid()}"); // → a random UUID
+```
+:::
+
+User code can add custom functions via `VarResolver.create().functions(MyFunction.class).build()`
+or via `ServiceLoader` discovery in `META-INF/services/org.apache.juneau.commons.svl.VarFunction`.
+
+## `VarTemplate` Compiled-Template API
+
+`VarResolver.compile(input)` tokenizes a template once and returns a reusable
+<a href="/site/apidocs/org/apache/juneau/commons/svl/VarTemplate.html" target="_blank">VarTemplate</a>.
+This skips re-tokenization on every resolve call — useful at framework injection sites or anywhere
+the same template is resolved repeatedly.
+
+```java
+// Compile once (e.g. at startup or in framework metadata).
+VarTemplate tpl = VarResolver.DEFAULT.compile("hello ${user.name:guest}");
+
+// Resolve many times without re-parsing.
+String s = tpl.resolve(VarResolver.DEFAULT.createSession());
+```
+
+`VarResolver.resolveSupplier(input)` wraps this into a thread-safe `Supplier<String>` that opens a
+fresh session on every `.get()`, which pairs naturally with `@Value Supplier<String>` field injection
+for live-reload patterns.
+
+SVL variables are used widely throughout Juneau annotations, allowing many features to be configured
+from external sources such as configuration files, environment variables, or system properties.
+
+:::info See Also
+
+- [Simple Variable Language Basics](/docs/topics/SimpleVariableLanguageBasics) for the full SVL reference including variable nesting, stable-value folding, `Supplier<String>` field semantics, and the complete function catalog.
+
+:::
diff --git a/pages/topics/01.02.02.BeanContextOverview.md b/pages/topics/01.02.02.BeanContextOverview.md
new file mode 100644
index 0000000000..3a078f0fa7
--- /dev/null
+++ b/pages/topics/01.02.02.BeanContextOverview.md
@@ -0,0 +1,298 @@
+---
+title: "Bean Context"
+slug: BeanContextOverview
+---
+
+# Bean Context
+
+The **Bean Context** (BCT — _Bean Context Type_) is Juneau's core bean-introspection framework.
+It provides a unified, highly configurable view of Java beans that all serializers, parsers, and
+other framework components share.
+
+Every marshaller in Juneau extends `MarshallingContext`, which means a single set of bean-modeling
+settings controls how beans are discovered, read, and written across all formats — JSON, XML, YAML,
+CSV, MessagePack, and the rest — with no per-format configuration duplication.
+
+The framework splits into two layers:
+
+| Layer | Location | Responsibility |
+|---|---|---|
+| Bean modeling | `juneau-commons` | Introspect classes, discover properties, apply `@BeanType`/`@BeanProp`/`@BeanIgnore`/`@BeanCtor` |
+| Marshalling | `juneau-marshall` | Extend the bean model with `ClassMeta`, type swaps, bean dictionaries, format-specific options |
+
+---
+
+## `MarshallingContext` — the Configuration Context
+
+<a href="/site/apidocs/org/apache/juneau/MarshallingContext.html" target="_blank">`MarshallingContext`</a>
+is the root configuration object for bean introspection and marshalling.
+Instances are:
+
+- **Immutable** — constructed once via a fluent builder and never changed thereafter.
+- **Thread-safe** — freely shared across serializers and threads.
+- **Cache-sharing** — contexts with the same settings reuse the same `ClassMeta` cache, so
+ expensive reflective analysis of a given class happens only once.
+
+All serializer and parser classes extend `MarshallingContext`, so they inherit every builder
+method on the context directly.
+
+```java
+// Create a standalone context (useful for programmatic bean introspection
+// without going through a full serializer).
+MarshallingContext ctx = MarshallingContext
+ .create()
+ .beansRequireDefaultConstructor() // Tighten bean detection
+ .beanFieldVisibility(Visibility.ANY) // Include private fields
+ .notBeanClasses(MyRawType.class) // Exclude this class from bean treatment
+ .build();
+```
+
+The static constant `MarshallingContext.DEFAULT` provides a pre-built, zero-config context for
+quick use.
+
+---
+
+## `MarshallingSession` — the Per-Operation Session
+
+<a href="/site/apidocs/org/apache/juneau/MarshallingSession.html" target="_blank">`MarshallingSession`</a>
+is an ephemeral, per-operation companion to `MarshallingContext`.
+Sessions hold request-scoped state such as locale, time zone, active view, and media type.
+They are lightweight to create and are typically not shared across threads.
+
+```java
+// Open a session for the DEFAULT context.
+MarshallingSession session = MarshallingContext.DEFAULT_SESSION; // singleton no-op session
+
+// Or create one with per-call settings.
+MarshallingSession session = MarshallingContext.DEFAULT.createSession();
+```
+
+Sessions are the entry point for creating `BeanMap` instances (see below).
+
+---
+
+## `BeanMap` — Beans as Maps
+
+<a href="/site/apidocs/org/apache/juneau/commons/bean/BeanMap.html" target="_blank">`BeanMap`</a>
+wraps a Java bean inside a `Map<String, Object>` interface, letting properties be read and written
+via the standard `get`/`put` methods. All serializers use `BeanMap` internally to traverse a
+bean's properties without generating intermediate structures.
+
+```java
+public class Person {
+ public String name = "John Smith";
+ public int age = 21;
+}
+
+// Wrap an existing bean.
+BeanMap<Person> bm = MarshallingContext.DEFAULT_SESSION.toBeanMap(new Person());
+bm.put("name", "Jane Doe");
+String name = (String) bm.get("name"); // "Jane Doe"
+
+// Create a new bean through the map.
+BeanMap<Person> bm2 = MarshallingContext.DEFAULT_SESSION.newBeanMap(Person.class);
+bm2.put("name", "Alice");
+bm2.put("age", 30);
+Person p = bm2.getBean();
+```
+
+`BeanMap` iteration follows a deterministic property order:
+explicit `@BeanType(properties=...)` list → alphabetical (default) → natural reflection order
+when `@BeanType(unsorted=true)` is set.
+
+---
+
+## `BeanMeta` — Bean Class Metadata
+
+<a href="/site/apidocs/org/apache/juneau/commons/bean/BeanMeta.html" target="_blank">`BeanMeta`</a>
+is the compiled introspection record for a single bean class.
+It holds the complete, resolved list of
+<a href="/site/apidocs/org/apache/juneau/commons/bean/BeanPropertyMeta.html" target="_blank">`BeanPropertyMeta`</a>
+entries — one per logical property — including the underlying field or getter/setter pair, resolved
+generic types, and any applied annotations.
+
+Instances are built once and cached by the context. Retrieve one via:
+
+```java
+BeanMeta<Person> meta = MarshallingContext.DEFAULT_SESSION.getBeanMeta(Person.class);
+for (BeanPropertyMeta prop : meta) {
+ System.out.println(prop.getName() + " : " + prop.getClassMeta().getInnerClass());
+}
+```
+
+---
+
+## `ClassMeta` — Type Metadata Cache
+
+<a href="/site/apidocs/org/apache/juneau/ClassMeta.html" target="_blank">`ClassMeta`</a>
+extends `BeanMeta` with marshalling-layer knowledge: whether a class is a bean, a collection,
+a map, a primitive, an enum, or something else (the `Category` enum covers ~20 categories).
+It also records the active object swaps and format overrides for that type.
+
+```java
+ClassMeta<Person> cm = MarshallingContext.DEFAULT.getClassMeta(Person.class);
+cm.isBean(); // true
+cm.isMap(); // false
+cm.getCategory(); // ClassMeta.Category.BEAN
+```
+
+---
+
+## Core Annotations
+
+The bean-modeling layer lives in `juneau-commons` and uses a trio of annotations that are
+independent of any marshalling concern. The marshalling layer in `juneau-marshall` extends each
+one with a sibling that carries format-specific attributes.
+
+### `@BeanType` — class-level control
+
+Applied to a class to declare the canonical property list, sorting, excluded properties, stop
+class, and more. The marshalling-layer sibling is `@Marshalled`.
+
+```java
+// Keep only "id" and "name"; expose them in that exact order.
+@BeanType(properties = "id,name")
+public class Person {
+ public int id;
+ public String name;
+ public String internalToken; // excluded — not in properties list
+}
+```
+
+```java
+// Exclude a property by name (useful when you cannot edit the class).
+@BeanType(excludeProperties = "password")
+public class Account { ... }
+```
+
+### `@BeanProp` — property-level control
+
+Applied to a field, getter, setter, or constructor parameter to rename a property, mark it
+read-only/write-only, specify a concrete type, or supply a factory.
+The marshalling-layer sibling is `@MarshalledProp`.
+
+```java
+public class Contact {
+
+ // Rename the serialized property key.
+ @BeanProp("full_name")
+ public String fullName;
+
+ // Read-only — serialized but ignored on parse.
+ @BeanProp(ro = true)
+ public String getCreatedAt() { ... }
+
+ // Write-only — accepted on parse but not serialized.
+ @BeanProp(wo = true)
+ public void setPassword(String pw) { ... }
+}
+```
+
+### `@BeanIgnore` — exclusion
+
+Applied to a class, field, method, or constructor to exclude it from bean introspection.
+On a class, marks it as _not a bean_ (the marshaller falls back to `toString()` or a registered
+swap). On a member, removes it from the property set.
+
+```java
+// Entire class: never treated as a bean.
+@BeanIgnore
+public class RawToken { ... }
+
+// Individual member: hidden from serialization and parsing.
+public class Order {
+ public String orderId;
+
+ @BeanIgnore
+ public String getDebugString() { ... } // excluded from marshalling
+}
+```
+
+### `@BeanCtor` — constructor-based deserialization
+
+Applied to a constructor to map its parameters onto the bean's logical property names.
+Required when a bean is read-only (no setters) and must be instantiated during parsing.
+Java Records detect their canonical constructor automatically, so `@BeanCtor` is optional there.
+
+```java
+public class Point {
+ public final int x, y;
+
+ @BeanCtor({"x","y"})
+ public Point(int x, int y) {
+ this.x = x; this.y = y;
+ }
+}
+
+// Parser can now reconstruct Point from {"x":1,"y":2}.
+Point p = Json.to("{x:1,y:2}", Point.class);
+```
+
+---
+
+## Swaps and Filters
+
+When a class cannot be introspected as a bean (or needs a different wire representation), the
+bean context delegates to _object swaps_ — pluggable converters registered on the context builder:
+
+```java
+MarshallingContext ctx = MarshallingContext
+ .create()
+ .swaps(TemporalCalendarSwap.IsoInstant.class) // Instant → ISO-8601 string
+ .build();
+```
+
+The `MarshalledFilter` class (implements `BeanFilter`) is the programmatic API for applying
+bean-level overrides such as additional include/exclude lists or property namers without touching
+the annotated source class — useful for third-party types.
+
+:::info See Also
+
+- [Swap Basics](/docs/topics/SwapBasics) for the full object-swap reference.
+- [Bean Dictionary Basics](/docs/topics/BeanDictionaryBasics) for polymorphic type resolution.
+
+:::
+
+---
+
+## Builder Configuration
+
+Every marshaller builder inherits the full set of `MarshallingContext.Builder` settings.
+Common properties include:
+
+| Builder method | Effect |
+|---|---|
+| `beanFieldVisibility(Visibility)` | Include `PRIVATE`, `PROTECTED`, or `PUBLIC` fields as properties |
+| `beanMethodVisibility(Visibility)` | Visibility threshold for getter/setter discovery |
+| `beansRequireDefaultConstructor()` | Only treat classes with a public no-arg constructor as beans |
+| `beansRequireSerializable()` | Only treat `Serializable` classes as beans |
+| `notBeanClasses(Class...)` | Exclude specific classes from bean treatment |
+| `notBeanPackages(String...)` | Exclude entire packages from bean treatment |
+| `sortProperties()` | Force alphabetical property order globally |
+| `ignoreUnknownBeanProperties()` | Silently skip unrecognized keys during parsing |
+| `swaps(Class...)` | Register object-swap converters |
+| `beanDictionary(Class...)` | Register types for polymorphic `_type` resolution |
+
+Any setting that can be applied via a builder can equally be applied via a `@MarshalledConfig`
+config annotation, allowing serializer settings to live on an annotated class and be applied
+via `builder.applyAnnotations(MyAnnotatedClass.class)`.
+
+```java
+// Config annotation on a class — useful in REST servlet hierarchies.
+@MarshalledConfig(sortProperties = "true", ignoreUnknownBeanProperties = "true")
+public class MyApiResource { ... }
+
+// Apply the annotations to a serializer at build time.
+JsonSerializer s = JsonSerializer.create()
+ .applyAnnotations(MyApiResource.class)
+ .build();
+```
+
+:::info See Also
+
+- [Marshalling Context Basics](/docs/topics/BeanContextBasics) for the full builder API.
+- [Java Beans Support](/docs/topics/JavaBeansSupport) for property-detection rules and examples.
+- [Java Records Support](/docs/topics/JavaRecordsSupport) for record-specific behavior.
+- [Context Annotations](/docs/topics/ContextAnnotations) for the config-annotation reference.
+
+:::
diff --git a/pages/topics/01.02.Marshalling.md b/pages/topics/01.02.Marshalling.md
index 1e9f3db037..36833b86b8 100644
--- a/pages/topics/01.02.Marshalling.md
+++ b/pages/topics/01.02.Marshalling.md
@@ -98,7 +98,7 @@ Marshalling support is provided for a wide variety of POJO types including:
:::
-#### Token and Record Streaming
+### Token and Record Streaming
For large datasets, the marshalling API supports O(1)-memory streaming via `RecordReader` and `RecordWriter` cursors.
Records are produced or consumed one at a time without buffering the entire document.
@@ -130,7 +130,7 @@ transformation pipelines, and custom serialization logic.
:::
-#### Serializer/Parser Builders
+### Serializer/Parser Builders
Marshallers like the one shown above are pairings of serializers and parsers.
@@ -178,7 +178,7 @@ By default, various instance and static methods and constructors on POJO classes
supported for marshalling a POJO to and from a string.
-#### Bean Annotations
+### Bean Annotations
Beans and POJO classes, methods, fields, and constructors can also be annotated with a variety of annotations to
customize how they are marshalled:
@@ -203,7 +203,7 @@ This allows the marshallers to be used equivalently on either your own code that
:::
-#### Configuration Annotations
+### Configuration Annotations
Serializers and parsers can also be configured using annotations.
@@ -247,7 +247,7 @@ public class MyAnnotatedClass {...}
:::
-#### OpenAPI Marshalling
+### OpenAPI Marshalling
The Marshalling API also supports schema-based OpenAPI serialization.
It allows HTTP parts to be marshalled to-and-from POJOs based on OpenAPI schema definitions.
@@ -287,7 +287,7 @@ public void doGet(
:::
-#### Bean Property Schema Validation
+### Bean Property Schema Validation
Parsers and serializers can also enforce JSON-Schema constraints declared via
<a href="/site/apidocs/org/apache/juneau/commons/annotation/Schema.html" target="_blank">`@Schema`</a>
@@ -318,7 +318,7 @@ the flag becomes a silent no-op.
:::
-#### JsonMap/JsonList
+### JsonMap/JsonList
The <a href="/site/apidocs/org/apache/juneau/collections/JsonMap.html" target="_blank">JsonMap</a> and <a href="/site/apidocs/org/apache/juneau/collections/JsonList.html" target="_blank">JsonList</a> collections classes allow you to programmatically build generic JSON data structures.
They are similar in concept to `JSONObject` and `JSONArray` that you find in other JSON marshalling APIs but can be used
@@ -347,7 +347,7 @@ These classes provide lots of convenience methods including:
:::
-#### Serializer and Parser Sets
+### Serializer and Parser Sets
<a href="/site/apidocs/org/apache/juneau/marshall/serializer/SerializerSet.html" target="_blank">SerializerSet</a> and <a href="/site/apidocs/org/apache/juneau/marshall/parser/ParserSet.html" target="_blank">ParserSet</a> classes allow serializers and parsers to be retrieved by W3C-compliant HTTP Accept and Content-Type values:
@@ -388,93 +388,11 @@ Person person = parserSet
:::
-#### SVL Variables
+### SVL Variables
-The <a href="/site/apidocs/org/apache/juneau/commons/svl/package-summary.html" target="_blank">org.apache.juneau.commons.svl</a> package defines an API for a language called "Simple Variable
-Language" (SVL) — text that contains variables of the form `$varName{varKey}`.
-Variables can be recursively nested and can return values that themselves contain more variables.
+Juneau includes built-in support for Simple Variable Language (SVL) — a text-template engine that resolves variables of
+the form `$varName{varKey}` against sources such as system properties, environment variables, config files, and more.
+SVL is used widely throughout Juneau annotations and configuration settings.
-`VarResolver.DEFAULT` ships the following built-in source variables:
-
-| Variable | Description |
-|---|---|
-| `$S{key[,default]}` | Java system property (`System.getProperty`). |
-| `$E{key[,default]}` | OS environment variable (`System.getenv`). |
-| `$EF{key[,default]}` | Key from a `.env`-style env file on the filesystem. |
-| `$DE{key[,default]}` | Key from a `.env` dotenv file (same format, alternative naming). |
-| `$A{key[,default]}` | Command-line argument passed to the JVM. |
-| `$MF{key[,default]}` | Entry from the classpath `META-INF/MANIFEST.MF`. |
-| `$P{key[,default]}` | Unified `Settings` source stack — consults system properties, env vars, classpath `juneau.cfg`, per-microservice Config, Spring `Environment`, and more in priority order. |
-| `${key:default}` | Shorthand for `$P{key,default}`. The Spring-style `:` default separator is rewritten to `,` before delegation. |
-
-:::tip Example
-```java
-// Resolve a system-property variable.
-String home = VarResolver.DEFAULT.resolve("Java home: $S{java.home}");
-
-// Nested fallback chain: env var → system property → literal default.
-String val = VarResolver.DEFAULT.resolve("$E{MY_VAR,$S{my.var,not found}}");
-
-// Spring-style ${...} shorthand against the unified Settings stack.
-String title = VarResolver.DEFAULT.resolve("${myapp.title:Untitled}");
-```
-:::
-
-#### `#{...}` Function-call Syntax
-
-Alongside `$Var{...}` style variables, SVL supports a `#{name(args...)}` function-call syntax backed by a catalog of ~68 built-in functions across 10 categories:
-
-| Category | Example functions |
-|---|---|
-| String | `upper`, `lower`, `trim`, `substring`, `split`, `join`, `format`, `pathToken` |
-| Type conversion | `toInt`, `toLong`, `toDouble`, `toBoolean`, `toString` |
-| Arithmetic | `add`, `sub`, `mul`, `div`, `mod`, `min`, `max`, `abs`, `round` |
-| Boolean | `not`, `and`, `or`, `eq`, `ne` |
-| Conditional | `if`, `switch`, `coalesce`, `notEmpty`, `case` |
-| Regex | `matches`, `replace`, `extract` |
-| Encoding | `urlEncode`, `urlDecode`, `base64Encode`, `base64Decode`, `htmlEscape` |
-| Date/time | `now`, `today`, `formatDate`, `parseDate` |
-| Random/UUID | `uuid`, `randomInt`, `randomString` |
-| JSON navigation | `jsonPath`, `get`, `keys`, `values`, `size` |
-
-This syntax replaces 11 dedicated transformation `Var` classes (`$UC{}`, `$IF{}`, `$SW{}`, etc.) that were removed in 10.0 in favor of the unified function library.
-
-:::tip Example
-```java
-VarResolver.DEFAULT.resolve("#{upper(hello world)}"); // → "HELLO WORLD"
-VarResolver.DEFAULT.resolve("#{if(${prod:false}, prod-key, dev-key)}"); // → "dev-key"
-VarResolver.DEFAULT.resolve("#{switch(${tier:bronze}, gold:1.0, *:0)}"); // → "0"
-VarResolver.DEFAULT.resolve("#{uuid()}"); // → a random UUID
-```
-:::
-
-User code can add custom functions via `VarResolver.create().functions(MyFunction.class).build()`
-or via `ServiceLoader` discovery in `META-INF/services/org.apache.juneau.commons.svl.VarFunction`.
-
-#### `VarTemplate` Compiled-Template API
-
-`VarResolver.compile(input)` tokenizes a template once and returns a reusable
-<a href="/site/apidocs/org/apache/juneau/commons/svl/VarTemplate.html" target="_blank">VarTemplate</a>.
-This skips re-tokenization on every resolve call — useful at framework injection sites or anywhere
-the same template is resolved repeatedly.
-
-```java
-// Compile once (e.g. at startup or in framework metadata).
-VarTemplate tpl = VarResolver.DEFAULT.compile("hello ${user.name:guest}");
-
-// Resolve many times without re-parsing.
-String s = tpl.resolve(VarResolver.DEFAULT.createSession());
-```
-
-`VarResolver.resolveSupplier(input)` wraps this into a thread-safe `Supplier<String>` that opens a
-fresh session on every `.get()`, which pairs naturally with `@Value Supplier<String>` field injection
-for live-reload patterns.
-
-SVL variables are used widely throughout Juneau annotations, allowing many features to be configured
-from external sources such as configuration files, environment variables, or system properties.
-
-:::info See Also
-
-- [Simple Variable Language](/docs/topics/SimpleVariableLanguageBasics) for the full SVL reference including variable nesting, stable-value folding, `Supplier<String>` field semantics, and the complete function catalog.
-
-:::
\ No newline at end of file
+See [Simple Variable Language](/docs/topics/SimpleVariableLanguage) for the built-in variable reference,
+`#{...}` function-call syntax, compiled-template API, and more.
diff --git a/pages/topics/01.04.RestServer.md b/pages/topics/01.04.RestServer.md
index 9398e7b71e..ffc96edb54 100644
--- a/pages/topics/01.04.RestServer.md
+++ b/pages/topics/01.04.RestServer.md
@@ -3,7 +3,7 @@ title: "REST Server"
slug: RestServer
---
-#### `@Rest`-Annotated Resources
+### `@Rest`-Annotated Resources
A REST resource is simply a Java class annotated with <a href="/site/apidocs/org/apache/juneau/rest/server/Rest.html" target="_blank">Rest</a>.
The most common case is a class that extends <a href="/site/apidocs/org/apache/juneau/rest/server/servlet/BasicRestServlet.html" target="_blank">BasicRestServlet</a>, which itself is simply an extension of <a href="https://jakarta.ee/specifications/servlet/6.0/apidocs/jakarta/servlet/http/HttpServlet.html" target="_blank">HttpServlet</a> which allows it to be deployed as a servlet.
@@ -52,7 +52,7 @@ as `@HtmlConfig` and `@MarshalledConfig` shown above).
- Annotations such as the title, summary, and descriptions shown above are used for auto-generated Swagger UI pages (described later).
-#### REST Children
+### REST Children
Child Resources are REST servlets or objects that are linked to parent resources through the <a href="/site/apidocs/org/apache/juneau/rest/server/Rest.html#children()" target="_blank">@Rest(children)</a> annotation.
@@ -89,7 +89,7 @@ Initialization of and access to the child resources occurs through the parent re
Children can be nested arbitrary deep to create complex REST interfaces with a single top-level REST servlet.
-#### Predefined Configuration Interfaces
+### Predefined Configuration Interfaces
The servlets in the previous section implemented the <a href="/site/apidocs/org/apache/juneau/rest/server/config/BasicUniversalConfig.html" target="_blank">BasicUniversalConfig</a> which simply defines a preconfigured set of annotations that get inherited by the child classes:
@@ -293,7 +293,7 @@ The <a href="/site/apidocs/org/apache/juneau/rest/server/config/package-summary.
Annotations are aggregated from child-to-parent order allowing for these basic configurations to be extended and
modified, or you can create your own annotations from scratch.
-#### REST Group Pages
+### REST Group Pages
The <a href="/site/apidocs/org/apache/juneau/rest/server/servlet/BasicRestServletGroup.html" target="_blank">BasicRestServletGroup</a> class provides a
default "router" page for child resources when a parent resource is nothing more than a grouping of child resources.
@@ -330,7 +330,7 @@ http://localhost:10000
-#### REST Resource Methods
+### REST Resource Methods
The real power behind the REST server API is the ability to define Java methods as REST endpoints.
@@ -391,7 +391,7 @@ The various parts require their own topics to fully appreciate the scope of abil
- Can define your own <a href="/site/apidocs/org/apache/juneau/http/Response.html" target="_blank">@Response</a>-annotated throwables.
- Anything else gets converted to an <a href="/site/apidocs/org/apache/juneau/http/response/InternalServerError.html" target="_blank">InternalServerError</a>.
-#### Deploying as a Servlet
+### Deploying as a Servlet
The <a href="/site/apidocs/org/apache/juneau/rest/server/servlet/BasicRestServlet.html" target="_blank">BasicRestServlet</a> class is the entry point for
your REST resources.
@@ -404,7 +404,7 @@ the configuration information about your resource in a read-only object.
Most developers are not going to be using the RestServlet class itself, and instead will extend from one of the
preconfigured default servlets such as <a href="/site/apidocs/org/apache/juneau/rest/server/servlet/BasicRestServlet.html" target="_blank">BasicRestServlet</a> and <a href="/site/apidocs/org/apache/juneau/rest/server/servlet/BasicRestServletGroup.html" target="_blank">BasicRestServletGroup</a> which provides universal language support, basic instrumentation, and auto-generated Swagger UI.
-#### Deploying in Spring Boot
+### Deploying in Spring Boot
The <a href="/site/apidocs/org/apache/juneau/rest/server/springboot/BasicSpringRestServlet.html" target="_blank">BasicSpringRestServlet</a> class is
typically entry point for your REST resources when working within a Spring Boot environment.
diff --git a/pages/topics/01.05.RestClient.md b/pages/topics/01.05.RestClient.md
index cc3177a883..5a6a9d1116 100644
--- a/pages/topics/01.05.RestClient.md
+++ b/pages/topics/01.05.RestClient.md
@@ -24,7 +24,7 @@ MyBean bean = RestClient.create()
```
:::
-#### REST Testing Framework
+### REST Testing Framework
The <a href="/site/apidocs/org/apache/juneau/rest/mock/classic/MockRestClient.html" target="_blank">MockRestClient</a> class is used for performing
serverless unit testing of <a href="/site/apidocs/org/apache/juneau/rest/server/Rest.html" target="_blank">@Rest</a>-annotated and <a href="/site/apidocs/org/apache/juneau/http/remote/Remote.html" target="_blank">@Remote</a>-annotated classes.
diff --git a/pages/topics/01.06.DtoBeans.md b/pages/topics/01.06.DtoBeans.md
index 063826ecfa..02a165451a 100644
--- a/pages/topics/01.06.DtoBeans.md
+++ b/pages/topics/01.06.DtoBeans.md
@@ -6,7 +6,7 @@ slug: DtoBeans
The [juneau-bean](/docs/topics/JuneauBeanBasics) libraries contain several predefined POJOs for generating commonly-used document types that are designed
to be used with the Juneau Marshaller APIs for both serializing and parsing.
-#### HTML5
+### HTML5
The Juneau HTML5 DTO beans are simply beans with fluent-style setters that allow you to quickly construct HTML fragments as
Java objects.
@@ -54,7 +54,7 @@ String html = Html.of(mytable);
[HTML5](/docs/topics/JuneauBeanHtml5) for more information.
:::
-#### ATOM
+### ATOM
The Juneau ATOM feed DTO beans are simply beans with fluent-style setters.
The following code shows a feed being created programmatically using the <a href="/site/apidocs/org/apache/juneau/bean/atom/AtomBuilder.html" target="_blank">AtomBuilder</a> class.
@@ -107,7 +107,7 @@ String atomXml = serializer.serialize(feed);
[Atom](/docs/topics/JuneauBeanAtom) for more information.
:::
-#### Swagger
+### Swagger
The Juneau Swagger DTO beans are simply beans with fluent-style setters that allow you to quickly construct Swagger documents
as Java objects.
@@ -168,7 +168,7 @@ swaggerJson = swagger.asJson();
[Swagger](/docs/topics/SwaggerBasics) for more information.
:::
-#### SwaggerUI
+### SwaggerUI
The <a href="/site/apidocs/org/apache/juneau/bean/swagger/ui/SwaggerUI.html" target="_blank">SwaggerUI</a> class is a DTO bean class for generating
Swagger user interfaces from <a href="/site/apidocs/org/apache/juneau/bean/swagger/Swagger.html" target="_blank">Swagger</a> beans.
diff --git a/pages/topics/01.08.FluentAssertions.md b/pages/topics/01.08.FluentAssertions.md
index 0a8e3c64ce..a34ee6cbc9 100644
--- a/pages/topics/01.08.FluentAssertions.md
+++ b/pages/topics/01.08.FluentAssertions.md
@@ -3,7 +3,7 @@ title: "Fluent Assertions"
slug: FluentAssertions
---
-The juneau-assertions module in Juneau is a powerful API for performing fluent style assertions.
+The juneau-test module in Juneau is a powerful API for performing fluent style assertions.
Fluent assertions have two types of methods:
@@ -14,8 +14,8 @@ Multiple transformations and assertions can be performed per statement.
:::tip Examples
```java
-import static org.apache.juneau.assertions.Assertions.*;
-import static org.apache.juneau.assertions.AssertionPredicates.*;
+import static org.apache.juneau.test.assertions.Assertions.*;
+import static org.apache.juneau.test.assertions.AssertionPredicates.*;
// Check the contents of a string.
assertString("foo, bar")
@@ -24,10 +24,13 @@ assertString("foo, bar")
.is("foo", "bar");
// Extract a subset of properties from a list of beans and compare using JSON5.
+// (asJson() was removed from the assertions API; use a marshall serializer explicitly.)
+import org.apache.juneau.marshall.json5.Json5Serializer;
+
List myListOfBeans = ...;
assertBeanList(myListOfBeans)
.asPropertyMaps("a,b")
- .asJson().is("[{a:1,b:'foo'}]");
+ .asString(Json5Serializer.DEFAULT.asFunction()).is("[{a:1,b:'foo'}]");
// Perform an arbitrary Predicate check against a bean.
MyBean myBean = ...;
@@ -69,5 +72,5 @@ MyBean bean = RestClient.create()
:::
:::info See Also
-See the <a href="/site/apidocs/org/apache/juneau/assertions/package-summary.html" target="_blank">org.apache.juneau.assertions</a> package Javadoc for the full assertion class reference.
+See the <a href="/site/apidocs/org/apache/juneau/test/assertions/package-summary.html" target="_blank">org.apache.juneau.test.assertions</a> package Javadoc for the full assertion class reference.
:::
\ No newline at end of file
diff --git a/pages/topics/02.01.JuneauMarshallBasics.md b/pages/topics/02.01.JuneauMarshallBasics.md
index 4ecb516fd0..3b48bf881a 100644
--- a/pages/topics/02.01.JuneauMarshallBasics.md
+++ b/pages/topics/02.01.JuneauMarshallBasics.md
@@ -3,7 +3,7 @@ title: "juneau-marshall Basics"
slug: JuneauMarshallBasics
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
@@ -13,19 +13,19 @@ slug: JuneauMarshallBasics
</dependency>
```
-#### Java Library
+### Java Library
```text
juneau-marshall-0.0.0.jar
```
-#### OSGi Module
+### OSGi Module
```text
org.apache.juneau.marshall_0.0.0.jar
```
-#### Contents/Features
+### Contents/Features
- Foundation for all serializers and parsers.
- Implementations for all serializers and parsers except RDF languages.
diff --git a/pages/topics/02.03.SerializersAndParsers.md b/pages/topics/02.03.SerializersAndParsers.md
index e0ce3d7b65..36ef99b5cf 100644
--- a/pages/topics/02.03.SerializersAndParsers.md
+++ b/pages/topics/02.03.SerializersAndParsers.md
@@ -238,7 +238,7 @@ These properties apply to all parsers:
### Format-Specific Session Properties
-#### JSON / JSON5
+### JSON / JSON5
| Property | Type | Session Class | Description |
|---|---|---|---|
@@ -262,7 +262,7 @@ JsonParser.DEFAULT
.parse("{\"a\":1}", JsonMap.class); // ok
```
-#### UON (URL-Encoded Object Notation)
+### UON (URL-Encoded Object Notation)
| Property | Type | Session Class | Description |
|---|---|---|---|
@@ -280,7 +280,7 @@ String uon = UonSerializer.DEFAULT
// Produces: hello world
```
-#### URL Encoding
+### URL Encoding
| Property | Type | Session Class | Description |
|---|---|---|---|
@@ -296,7 +296,7 @@ String urlencoded = UrlEncodingSerializer.DEFAULT
.serialize(JsonMap.of("a", new int[]{1, 2, 3}));
```
-#### XML
+### XML
| Property | Type | Session Class | Description |
|---|---|---|---|
@@ -318,7 +318,7 @@ JsonMap result = XmlParser.DEFAULT
// result = {"root": {"a": "1"}}
```
-#### HTML
+### HTML
| Property | Type | Session Class | Description |
|---|---|---|---|
@@ -346,7 +346,7 @@ String html2 = HtmlSerializer.DEFAULT
// Produces plain text, not an <a> tag
```
-#### CSV
+### CSV
| Property | Type | Session Class | Description |
|---|---|---|---|
@@ -384,7 +384,7 @@ public void put(RestRequest req, @Body MyBean body) {
}
```
-#### HTTP-Based Session Options
+### HTTP-Based Session Options
Clients can also pass session properties via HTTP headers or query parameters when the server has enabled them. The server controls which properties are allowed using `@Rest(allowedSerializerOptions, allowedParserOptions)` or `@RestOp(allowedSerializerOptions, allowedParserOptions)`:
diff --git a/pages/topics/02.08.01.MarshalledNodeAndJsonPointer.md b/pages/topics/02.08.01.MarshalledNodeAndJsonPointer.md
index 60de65fd4b..5e3ed30059 100644
--- a/pages/topics/02.08.01.MarshalledNodeAndJsonPointer.md
+++ b/pages/topics/02.08.01.MarshalledNodeAndJsonPointer.md
@@ -25,7 +25,7 @@ The underlying representation is still plain `MarshalledMap`/`MarshalledList` (o
`ArrayNode` / `TextNode` class tree to learn — `MarshalledNode` is the single façade type for every node kind.
:::
-#### Creating nodes
+### Creating nodes
Use the static factories to wrap an existing value or to start a fresh tree:
@@ -49,7 +49,7 @@ JsonMap doc = Json.to("{foo:{bar:['x','y']}}", JsonMap.class);
MarshalledNode n = doc.at("/foo/bar/1");
```
-#### Node-type introspection
+### Node-type introspection
Four predicates report the kind of value a node wraps:
@@ -60,7 +60,7 @@ Four predicates report the kind of value a node wraps:
<node-0><java-class><a href="/site/apidocs/org/apache/juneau/marshall/collections/MarshalledNode.html#isNull()" target="_blank">isNull()</a></java-class> — wraps <code>null</code>.</node-0>
</tree>
-#### Typed accessors
+### Typed accessors
Value nodes can be read in a target type. The scalar accessors return `null` when the node is not a value node or the value
cannot be converted (rather than throwing):
@@ -85,7 +85,7 @@ Address addr = node.get("address").as(Address.class);
Object raw = node.value();
```
-#### Navigation
+### Navigation
Navigate into children by key (object nodes) or index (array nodes). Both `get(...)` forms return `null` on a miss (absent
key, out-of-range index, or wrong node kind), and <a href="/site/apidocs/org/apache/juneau/marshall/collections/MarshalledNode.html#size()" target="_blank">size()</a>
@@ -97,7 +97,7 @@ MarshalledNode first = node.get("phones").get(0); // by index
int count = node.get("phones").size();
```
-#### Fluent tree building
+### Fluent tree building
The <a href="/site/apidocs/org/apache/juneau/marshall/collections/MarshalledNode.html#put(java.lang.String,java.lang.Object)" target="_blank">put(String,Object)</a>
(object nodes) and <a href="/site/apidocs/org/apache/juneau/marshall/collections/MarshalledNode.html#add(java.lang.Object)" target="_blank">add(Object)</a>
@@ -121,7 +121,7 @@ String x = node.get("b").get(0).asString(); // "x"
`put(...)` on a non-object node and `add(...)` on a non-array node both throw `IllegalStateException`.
-#### Live view vs. `copy()` snapshot
+### Live view vs. `copy()` snapshot
Because a node is a live view, building or mutating through it changes the shared backing container:
@@ -141,7 +141,7 @@ MarshalledNode snapshot = node.copy();
snapshot.put("x", 999); // does not affect the original 'node'.
```
-#### RFC 6901 JSON-Pointer addressing
+### RFC 6901 JSON-Pointer addressing
`MarshalledNode` exposes the full <a href="https://datatracker.ietf.org/doc/html/rfc6901" target="_blank">RFC 6901</a> pointer surface relative to its
backing value:
@@ -177,7 +177,7 @@ A read-miss (missing key, out-of-range index, or type mismatch) resolves to `nul
addresses the whole backing document; on a node, `set("", …)` is rejected with `IllegalArgumentException` because the backing
value cannot be replaced in place — set against a non-empty pointer instead.
-#### The `JsonPointer` helper
+### The `JsonPointer` helper
For pointer operations against an arbitrary `Map`/`List` root (not just through a node), use the standalone
<a href="/site/apidocs/org/apache/juneau/marshall/collections/JsonPointer.html" target="_blank">JsonPointer</a> class directly. A pointer is a string of
diff --git a/pages/topics/02.21.PojoCategories.md b/pages/topics/02.21.PojoCategories.md
index 36a2ab5801..397bd7e5e4 100644
--- a/pages/topics/02.21.PojoCategories.md
+++ b/pages/topics/02.21.PojoCategories.md
@@ -7,7 +7,7 @@ In general, Juneau allows for marshalling for a wide variety of POJO types inclu
The following chart shows POJOs categorized into groups and whether they can be serialized or parsed:
-#### General POJO serialization/parsing support
+### General POJO serialization/parsing support
<table className="styled w800" style={{borderCollapse: 'collapse'}}>
<tr>
@@ -308,7 +308,7 @@ There is a serializer setting `detectRecursions` to look for and handle these ki
references to `null`) but it is not enabled by default since it introduces a moderate performance penalty.
:::
-#### POJOs convertible to/from Strings
+### POJOs convertible to/from Strings
A separate category exists for POJOs that can be converted to and from Strings.
These are used in places such as:
@@ -345,7 +345,7 @@ Exceptions exist for the following classes:
<node-0>Primitives (except for `void.class`) - Uses the primitive wrapper classes for instantiating from `Strings`.</node-0>
</tree>
-#### POJOs convertible to/from other types
+### POJOs convertible to/from other types
POJOs are also converted to various other types in places such as the Open-API serializers and parsers.
In this section, the type being converted to will be referred to as `X`.
diff --git a/pages/topics/02.23.Encoders.md b/pages/topics/02.23.Encoders.md
index f19dcd65f7..5ea8698315 100644
--- a/pages/topics/02.23.Encoders.md
+++ b/pages/topics/02.23.Encoders.md
@@ -15,14 +15,14 @@ It consists of the following classes:
<node-1><java-class><a href="/site/apidocs/org/apache/juneau/encoders/GzipEncoder.html" target="_blank">GzipEncoder</a></java-class></node-1>
</tree>
-#### EncoderSet
+### EncoderSet
The <a href="/site/apidocs/org/apache/juneau/encoders/EncoderSet.html" target="_blank">EncoderSet</a> class represents the set of <a href="/site/apidocs/org/apache/juneau/encoders/Encoder.html" target="_blank">org.apache.juneau.encoders</a> keyed by codings.
It maintains a set of encoders and the codings that they can handle.
The <a href="/site/apidocs/org/apache/juneau/encoders/EncoderSet.html#getEncoderMatch(java.lang.String)" target="_blank">getEncoderMatch(String)</a> and <a href="/site/apidocs/org/apache/juneau/encoders/EncoderSet.html#getEncoder(java.lang.String)" target="_blank">EncoderSet.getEncoder(String)</a> methods are then used to find appropriate encoders for specific `Accept-Encoding` and `Content-Encoding` header values.
-#### Match ordering
+### Match ordering
Encoders are tried in the order they appear in the set.
The <a href="/site/apidocs/org/apache/juneau/encoders/EncoderSet.Builder.html#add(java.lang.Class...)" target="_blank">EncoderSet.Builder.add(Class...)</a> / <a href="/site/apidocs/org/apache/juneau/encoders/EncoderSet.Builder.html#add(org.apache.juneau.encoders.Encoder...)" target="_blank">EncoderSet.Builder.add(Encoder...)</a> methods prepend the values to the list to allow them the opportunity to override encoders already in the list.
@@ -45,7 +45,7 @@ Encoder encoder = encoders.getEncoder(matchedCoding);
```
:::
-#### Encoder API
+### Encoder API
The <a href="/site/apidocs/org/apache/juneau/encoders/Encoder.html" target="_blank">Encoder</a> interface is used for enabling decompression on
requests and compression on responses, such as support for GZIP compression.
diff --git a/pages/topics/02.24.ObjectTools.md b/pages/topics/02.24.ObjectTools.md
index e964ab79de..9c2c914864 100644
--- a/pages/topics/02.24.ObjectTools.md
+++ b/pages/topics/02.24.ObjectTools.md
@@ -17,7 +17,7 @@ It consists of the following classes:
<node-0><java-class><a href="/site/apidocs/org/apache/juneau/objecttools/ObjectMerger.html" target="_blank">ObjectMerger</a></java-class></node-0>
</tree>
-#### ObjectRest (Removed in 10.0)
+### ObjectRest (Removed in 10.0)
:::warning Removed
The public `ObjectRest` class was **removed** in Juneau 10.0. Its URL-addressed GET/PUT/POST/DELETE traversal engine survives
@@ -63,7 +63,7 @@ capability. The companion exception was renamed to
<a href="/site/apidocs/org/apache/juneau/rest/server/converter/Traversable.html" target="_blank">Traversable</a> REST response
converter is unaffected.
-#### ObjectSearcher
+### ObjectSearcher
The <a href="/site/apidocs/org/apache/juneau/objecttools/ObjectSearcher.html" target="_blank">ObjectSearcher</a> class is designed to provide
searches across arrays and `Collections` of `Maps` or beans.
@@ -134,7 +134,7 @@ This class is used in the <a href="/site/apidocs/org/apache/juneau/rest/server/c
converter.
:::
-#### ObjectSorter
+### ObjectSorter
The <a href="/site/apidocs/org/apache/juneau/objecttools/ObjectSorter.html" target="_blank">ObjectSorter</a> class is designed to sort arrays and
collections of maps or beans.
@@ -161,7 +161,7 @@ This class is used in the <a href="/site/apidocs/org/apache/juneau/rest/server/c
converter.
:::
-#### ObjectViewer
+### ObjectViewer
The <a href="/site/apidocs/org/apache/juneau/objecttools/ObjectViewer.html" target="_blank">ObjectViewer</a> class is designed to extract properties
from `Collections` of `Maps` or beans.
@@ -185,7 +185,7 @@ This class is used in the <a href="/site/apidocs/org/apache/juneau/rest/server/c
converter.
:::
-#### ObjectPaginator
+### ObjectPaginator
The <a href="/site/apidocs/org/apache/juneau/objecttools/ObjectPaginator.html" target="_blank">ObjectPaginator</a> class is designed to extract
sublists from arrays/collections of maps or beans.
@@ -209,7 +209,7 @@ This class is used in the <a href="/site/apidocs/org/apache/juneau/rest/server/c
converter.
:::
-#### ObjectIntrospector
+### ObjectIntrospector
The <a href="/site/apidocs/org/apache/juneau/objecttools/ObjectIntrospector.html" target="_blank">ObjectIntrospector</a> class is used to invoke
methods on `Objects` using arguments in serialized form.
@@ -237,7 +237,7 @@ This is an extremely powerful but potentially dangerous tool.
Use wisely.
:::
-#### ObjectMerger
+### ObjectMerger
The <a href="/site/apidocs/org/apache/juneau/objecttools/ObjectMerger.html" target="_blank">ObjectMerger</a> class is used for merging POJOs behind
a single interface.
diff --git a/pages/topics/02.30.02.UonMethodology.md b/pages/topics/02.30.02.UonMethodology.md
index 177373cb9e..e1b6397a63 100644
--- a/pages/topics/02.30.02.UonMethodology.md
+++ b/pages/topics/02.30.02.UonMethodology.md
@@ -3,7 +3,7 @@ title: "UON Methodology"
slug: UonMethodology
---
-#### General methodology:
+### General methodology:
<table class="code-table">
<tr>
diff --git a/pages/topics/02.31.02.UrlEncMethodology.md b/pages/topics/02.31.02.UrlEncMethodology.md
index 46c4fb7123..ec63a8f113 100644
--- a/pages/topics/02.31.02.UrlEncMethodology.md
+++ b/pages/topics/02.31.02.UrlEncMethodology.md
@@ -3,7 +3,7 @@ title: "URL-Encoding Methodology"
slug: UrlEncMethodology
---
-#### General methodology:
+### General methodology:
<table class="code-table">
<tr>
diff --git a/pages/topics/03.01.JuneauMarshallRdfOverview.md b/pages/topics/03.01.JuneauMarshallRdfOverview.md
index 3677e1820e..5159358a72 100644
--- a/pages/topics/03.01.JuneauMarshallRdfOverview.md
+++ b/pages/topics/03.01.JuneauMarshallRdfOverview.md
@@ -3,7 +3,7 @@ title: "juneau-marshall-rdf"
slug: JuneauMarshallRdfOverview
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
@@ -13,19 +13,19 @@ slug: JuneauMarshallRdfOverview
</dependency>
```
-#### Java Library
+### Java Library
```text
juneau-marshall-rdf-0.0.0.jar
```
-#### OSGi Module
+### OSGi Module
```text
org.apache.juneau.marshall.marshaller.rdf_0.0.0.jar
```
-#### Contents/Features
+### Contents/Features
The `juneau-marshall-rdf` library provides additional serializers and parsers for RDF.
These rely on the Apache Jena library to provide support for the following formats:
diff --git a/pages/topics/04.01.JuneauBeanBasics.md b/pages/topics/04.01.JuneauBeanBasics.md
index d253a654b7..b3e7176a12 100644
--- a/pages/topics/04.01.JuneauBeanBasics.md
+++ b/pages/topics/04.01.JuneauBeanBasics.md
@@ -3,7 +3,7 @@ title: "juneau-bean Basics"
slug: JuneauBeanBasics
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
@@ -13,17 +13,17 @@ slug: JuneauBeanBasics
</dependency>
```
-#### Java Library
+### Java Library
```text
juneau-bean-0.0.0.jar
```
-#### OSGi Module
+### OSGi Module
```text
org.apache.juneau.bean_0.0.0.jar
```
-#### Contents/Features
+### Contents/Features
- Predefined POJOs for generating commonly-used document types.
diff --git a/pages/topics/04.03.JuneauBeanAtom.md b/pages/topics/04.03.JuneauBeanAtom.md
index 32ba862db0..0b70d410c8 100644
--- a/pages/topics/04.03.JuneauBeanAtom.md
+++ b/pages/topics/04.03.JuneauBeanAtom.md
@@ -55,7 +55,7 @@ XmlSerializer serializer = XmlSerializer.create().sq().ws().build();
String atomXml = serializer.serialize(feed);
```
-#### Results
+### Results
```xml
<feed>
diff --git a/pages/topics/05.01.JuneauConfigBasics.md b/pages/topics/05.01.JuneauConfigBasics.md
index 16f8c386ba..920327908e 100644
--- a/pages/topics/05.01.JuneauConfigBasics.md
+++ b/pages/topics/05.01.JuneauConfigBasics.md
@@ -3,7 +3,7 @@ title: "juneau-config Basics"
slug: JuneauConfigBasics
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
@@ -13,19 +13,19 @@ slug: JuneauConfigBasics
</dependency>
```
-#### Java Library
+### Java Library
```text
juneau-config-0.0.0.jar
```
-#### OSGi Module
+### OSGi Module
```text
org.apache.juneau.config_0.0.0.jar
```
-#### Contents/Features
+### Contents/Features
The `juneau-config` library contains a powerful API for creating and using INI-style config files.
diff --git a/pages/topics/06.01.JuneauCommonsBasics.md b/pages/topics/06.01.JuneauCommonsBasics.md
index d90d1644b5..31e7ddef13 100644
--- a/pages/topics/06.01.JuneauCommonsBasics.md
+++ b/pages/topics/06.01.JuneauCommonsBasics.md
@@ -4,7 +4,7 @@ title: "juneau-commons Basics"
slug: JuneauCommonsBasics
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
@@ -14,19 +14,19 @@ slug: JuneauCommonsBasics
</dependency>
```
-#### Java Library
+### Java Library
```text
juneau-commons-0.0.0.jar
```
-#### OSGi Module
+### OSGi Module
```text
org.apache.juneau.common_0.0.0.jar
```
-#### Contents/Features
+### Contents/Features
The `juneau-commons` module provides common utilities and APIs used across the Juneau ecosystem.
diff --git a/pages/topics/06.02.01.JuneauCommonsCollections.md b/pages/topics/06.02.01.JuneauCommonsCollections.md
index a5861e9354..b4b73f9645 100644
--- a/pages/topics/06.02.01.JuneauCommonsCollections.md
+++ b/pages/topics/06.02.01.JuneauCommonsCollections.md
@@ -9,7 +9,7 @@ The `org.apache.juneau.commons.collections` package provides enhanced collection
### Collection Builders
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/Lists.html" target="_blank">Lists</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/Lists.html" target="_blank">Lists</a></java-class>
Fluent builder for constructing `List` instances with various configuration options.
```java
@@ -39,7 +39,7 @@ List<String> immutable = listb(String.class)
.build();
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/Maps.html" target="_blank">Maps</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/Maps.html" target="_blank">Maps</a></java-class>
Fluent builder for constructing `Map` instances.
```java
@@ -66,7 +66,7 @@ Map<String, Integer> sorted = mapb(String.class, Integer.class)
.build();
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/Sets.html" target="_blank">Sets</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/Sets.html" target="_blank">Sets</a></java-class>
Fluent builder for constructing `Set` instances with automatic deduplication.
```java
@@ -85,7 +85,7 @@ Set<Integer> unique = setb(Integer.class)
### Fluent Collections
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/FluentMap.html" target="_blank">FluentMap</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/FluentMap.html" target="_blank">FluentMap</a></java-class>
A fluent wrapper around an arbitrary map that provides convenient methods for adding entries.
```java
@@ -102,7 +102,7 @@ Map<String, String> other = Map.of("key5", "value5", "key6", "value6");
map.aa(other);
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/FluentList.html" target="_blank">FluentList</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/FluentList.html" target="_blank">FluentList</a></java-class>
A fluent wrapper around a list for convenient element addition.
```java
@@ -115,7 +115,7 @@ list
.ai(false, "item4"); // Not added
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/FluentSet.html" target="_blank">FluentSet</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/FluentSet.html" target="_blank">FluentSet</a></java-class>
A fluent wrapper around a set for convenient element addition.
```java
@@ -129,7 +129,7 @@ set
### Specialized Collections
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/MultiMap.html" target="_blank">MultiMap</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/MultiMap.html" target="_blank">MultiMap</a></java-class>
A composite map that presents multiple maps as a single unified map.
```java
@@ -145,7 +145,7 @@ multiMap.get("key2"); // Returns "value2" from map1 (first match wins)
multiMap.get("key3"); // Returns "value3" from map2
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/MultiList.html" target="_blank">MultiList</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/MultiList.html" target="_blank">MultiList</a></java-class>
A composite list that presents multiple lists as a single unified list.
```java
@@ -161,7 +161,7 @@ multiList.get(3); // Returns "d" from list2
multiList.size(); // Returns 8 (total elements)
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/MultiSet.html" target="_blank">MultiSet</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/MultiSet.html" target="_blank">MultiSet</a></java-class>
A composite set that presents multiple sets as a single unified set.
```java
@@ -176,7 +176,7 @@ multiSet.contains("c"); // Returns true
multiSet.size(); // Returns 7 (unique elements: a, b, c, d, e, f, g)
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/BidiMap.html" target="_blank">BidiMap</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/BidiMap.html" target="_blank">BidiMap</a></java-class>
A bidirectional map that allows lookup by both key and value.
```java
@@ -196,7 +196,7 @@ bidiMap.getKey(2); // Returns "two"
### Filtered Collections
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/FilteredMap.html" target="_blank">FilteredMap</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/FilteredMap.html" target="_blank">FilteredMap</a></java-class>
A map that filters entries based on a predicate.
```java
@@ -210,7 +210,7 @@ filtered.put("b", -1); // Filtered out
filtered.put("c", 10); // Added
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/FilteredList.html" target="_blank">FilteredList</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/FilteredList.html" target="_blank">FilteredList</a></java-class>
A list that filters elements based on a predicate.
```java
@@ -224,7 +224,7 @@ filtered.add(-1); // Filtered out
filtered.add(10); // Added
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/FilteredSet.html" target="_blank">FilteredSet</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/FilteredSet.html" target="_blank">FilteredSet</a></java-class>
A set that filters elements based on a predicate.
```java
@@ -240,7 +240,7 @@ filtered.add(10); // Added
### Caching
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/Cache.html" target="_blank">Cache</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/Cache.html" target="_blank">Cache</a></java-class>
Simple in-memory cache for storing and retrieving objects by key.
```java
@@ -259,7 +259,7 @@ Pattern pattern2 = patternCache.get("[0-9]+",
() -> Pattern.compile("[0-9]+", Pattern.CASE_INSENSITIVE));
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/HashKey.html" target="_blank">HashKey</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/HashKey.html" target="_blank">HashKey</a></java-class>
A composite key composed of multiple values, suitable for use as a key in hash-based collections.
```java
@@ -282,7 +282,7 @@ MyObject cached = cache.get(lookupKey); // Returns myObject
### Other Utilities
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/SortedArrayList.html" target="_blank">SortedArrayList</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/SortedArrayList.html" target="_blank">SortedArrayList</a></java-class>
An `ArrayList` that maintains elements in sorted order.
```java
@@ -296,7 +296,7 @@ sorted.add("banana");
// Contains: ["apple", "banana", "zebra"]
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/SortedLinkedList.html" target="_blank">SortedLinkedList</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/SortedLinkedList.html" target="_blank">SortedLinkedList</a></java-class>
A `LinkedList` that maintains elements in sorted order.
```java
@@ -310,7 +310,7 @@ sorted.add(4);
// Contains: [1, 3, 4]
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/ReversedList.html" target="_blank">ReversedList</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/collections/ReversedList.html" target="_blank">ReversedList</a></java-class>
A list that presents a reversed view of another list.
```java
diff --git a/pages/topics/06.02.02.JuneauCommonsUtils.md b/pages/topics/06.02.02.JuneauCommonsUtils.md
index 8fa76adb9f..8026988006 100644
--- a/pages/topics/06.02.02.JuneauCommonsUtils.md
+++ b/pages/topics/06.02.02.JuneauCommonsUtils.md
@@ -229,7 +229,7 @@ String trace = getStackTrace(throwable);
ThrowableUtils.printStackTrace(e, 100);
```
-#### `juneau.enableVerboseExceptions` Setting
+### `juneau.enableVerboseExceptions` Setting
When set to `true`, every exception created via a `ThrowableUtils` factory method immediately prints its stack trace to stderr at the point of creation — even if the exception is later caught and swallowed:
diff --git a/pages/topics/06.02.05.JuneauCommonsLang.md b/pages/topics/06.02.05.JuneauCommonsLang.md
index b89ce669f9..3b745d566f 100644
--- a/pages/topics/06.02.05.JuneauCommonsLang.md
+++ b/pages/topics/06.02.05.JuneauCommonsLang.md
@@ -40,7 +40,7 @@ monitored.set("updated"); // Triggers listener
### Specialized Value Classes
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/lang/IntegerValue.html" target="_blank">IntegerValue</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/lang/IntegerValue.html" target="_blank">IntegerValue</a></java-class>
Mutable integer with additional convenience methods.
```java
@@ -50,7 +50,7 @@ counter.decrement(); // 0
int value = counter.getAndIncrement(); // Returns 0, then sets to 1
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/lang/LongValue.html" target="_blank">LongValue</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/lang/LongValue.html" target="_blank">LongValue</a></java-class>
Mutable long with additional convenience methods.
```java
@@ -60,7 +60,7 @@ counter.decrement(); // 0L
long value = counter.getAndIncrement(); // Returns 0L, then sets to 1L
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/lang/BooleanValue.html" target="_blank">BooleanValue</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/lang/BooleanValue.html" target="_blank">BooleanValue</a></java-class>
Nullable boolean with convenience methods.
```java
@@ -73,7 +73,7 @@ nullable.isTrue(); // false (null is not true)
nullable.isNotTrue(); // true (null is not true)
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/lang/Flag.html" target="_blank">Flag</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/lang/Flag.html" target="_blank">Flag</a></java-class>
Non-nullable boolean flag (true/false only, no null state).
```java
@@ -83,7 +83,7 @@ flag.isFalse(); // false
flag.toggle(); // Switches to false
```
-#### <java-class><a href="/site/apidocs/org/apache/juneau/commons/lang/StringValue.html" target="_blank">StringValue</a></java-class>
+### <java-class><a href="/site/apidocs/org/apache/juneau/commons/lang/StringValue.html" target="_blank">StringValue</a></java-class>
Mutable string with convenience methods for equality testing.
```java
diff --git a/pages/topics/07.01.JuneauAssertionBasics.md b/pages/topics/07.01.JuneauAssertionBasics.md
index 5c63eadfd3..b295f28fd7 100644
--- a/pages/topics/07.01.JuneauAssertionBasics.md
+++ b/pages/topics/07.01.JuneauAssertionBasics.md
@@ -1,33 +1,33 @@
---
-title: "juneau-assertions Basics"
+title: "juneau-test Basics"
slug: JuneauAssertionBasics
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-assertions</artifactId>
+ <artifactId>juneau-test</artifactId>
<version>${juneau.version}</version>
</dependency>
```
-#### Java Library
+### Java Library
```text
-juneau-assertions-0.0.0.jar
+juneau-test-0.0.0.jar
```
-#### OSGi Module
+### OSGi Module
```text
-org.apache.juneau.assertions_0.0.0.jar
+org.apache.juneau.test_0.0.0.jar
```
-#### Contents/Features
+### Contents/Features
-The <a href="/site/apidocs/org/apache/juneau/assertions/package-summary.html" target="_blank">org.apache.juneau.assertions</a> package in Juneau is a powerful API for performing
+The <a href="/site/apidocs/org/apache/juneau/test/assertions/package-summary.html" target="_blank">org.apache.juneau.test.assertions</a> package in Juneau is a powerful API for performing
fluent style assertions.
It is used to implement built-in assertion methods on both the server and client side APIs.
But it can also be used standalone for testing.
diff --git a/pages/topics/07.02.AssertionsOverview.md b/pages/topics/07.02.AssertionsOverview.md
index dd78e8858d..fba152f693 100644
--- a/pages/topics/07.02.AssertionsOverview.md
+++ b/pages/topics/07.02.AssertionsOverview.md
@@ -3,7 +3,7 @@ title: "Assertions Overview"
slug: AssertionsOverview
---
-The <a href="/site/apidocs/org/apache/juneau/assertions/package-summary.html" target="_blank">org.apache.juneau.assertions</a> package in Juneau is a powerful API for performing
+The <a href="/site/apidocs/org/apache/juneau/test/assertions/package-summary.html" target="_blank">org.apache.juneau.test.assertions</a> package in Juneau is a powerful API for performing
fluent style assertions.
It is used throughout the REST client and server APIs for performing inline assertions on REST requests and responses.
@@ -30,11 +30,11 @@ The REST API is described later in the documentation.
The assertions API is designed to be used in both code (as it's done in the REST APIs) or for standalone use in unit
tests.
-The <a href="/site/apidocs/org/apache/juneau/assertions/Assertions.html" target="_blank">Assertions</a> class provides various static methods for
+The <a href="/site/apidocs/org/apache/juneau/test/assertions/Assertions.html" target="_blank">Assertions</a> class provides various static methods for
invoking assertions on a variety of object types for simplified unit testing.
<tree>
-<node-0><javac-class><a href="/site/apidocs/org/apache/juneau/assertions/Assertions.html" target="_blank">Assertions</a></javac-class> <javac-method><a href="/site/apidocs/org/apache/juneau/assertions/Assertions.html#assertAny(T)" target="_blank">assertAny(T)</a></javac-method> <javac-method><a href="/site/apidocs/org/apache/juneau/assertions/Assertions.html#assertArray(E[])" target="_blank">assertArray(Object[])</a></javac-method> <javac-method><a href="/site/apidocs/org/apache/juneau/a [...]
+<node-0><javac-class><a href="/site/apidocs/org/apache/juneau/test/assertions/Assertions.html" target="_blank">Assertions</a></javac-class> <javac-method><a href="/site/apidocs/org/apache/juneau/test/assertions/Assertions.html#assertAny(T)" target="_blank">assertAny(T)</a></javac-method> <javac-method><a href="/site/apidocs/org/apache/juneau/test/assertions/Assertions.html#assertArray(E[])" target="_blank">assertArray(Object[])</a></javac-method> <javac-method><a href="/site/apidocs/org/ [...]
</tree>
Assertions have 3 categories of methods:
@@ -45,8 +45,8 @@ Assertions have 3 categories of methods:
:::tip Examples
```java
-import static org.apache.juneau.assertions.Assertions.*;
-import static org.apache.juneau.assertions.AssertionPredicates.*;
+import static org.apache.juneau.test.assertions.Assertions.*;
+import static org.apache.juneau.test.assertions.AssertionPredicates.*;
// Check the contents of a string.
assertString("foo, bar")
@@ -55,10 +55,13 @@ assertString("foo, bar")
.isHas("foo", "bar");
// Extract a subset of properties from a list of beans and compare using JSON5.
+// (asJson() was removed from the assertions API; use a marshall serializer explicitly.)
+import org.apache.juneau.marshall.json5.Json5Serializer;
+
List myListOfBeans = ...;
assertBeanList(myListOfBeans)
.asPropertyMaps("a,b")
- .asJson().is("[{a:1,b:'foo'}]");
+ .asString(Json5Serializer.DEFAULT.asFunction()).is("[{a:1,b:'foo'}]");
// Perform an arbitrary Predicate check against a bean.
MyBean myBeans = ...;
@@ -125,22 +128,22 @@ assertString(myString)
```
:::
-The following shows the class hierarchy for the <a href="/site/apidocs/org/apache/juneau/assertions/IntegerAssertion.html" target="_blank">IntegerAssertion</a> class showing the general design pattern for assertion classes:
+The following shows the class hierarchy for the <a href="/site/apidocs/org/apache/juneau/test/assertions/IntegerAssertion.html" target="_blank">IntegerAssertion</a> class showing the general design pattern for assertion classes:
<tree>
-<node-0><java-class><a href="/site/apidocs/org/apache/juneau/assertions/Assertion.html" target="_blank">Assertion</a></java-class> - Base class for all assertion objects containing common configuration methods.</node-0>
-<node-1><java-class><a href="/site/apidocs/org/apache/juneau/assertions/FluentAssertion.html" target="_blank">FluentAssertion</a></java-class> - Parent class for all fluent assertions.</node-1>
-<node-2><java-class><a href="/site/apidocs/org/apache/juneau/assertions/FluentObjectAssertion.html" target="_blank">FluentObjectAssertion</a></java-class> - Tests and transforms for general POJOs.</node-2>
-<node-3><java-class><a href="/site/apidocs/org/apache/juneau/assertions/FluentComparableAssertion.html" target="_blank">FluentComparableAssertion<T extends Comparable,R></a></java-class> - Tests and transforms for Comparables.</node-3>
-<node-4><java-class><a href="/site/apidocs/org/apache/juneau/assertions/FluentIntegerAssertion.html" target="_blank">FluentIntegerAssertion</a></java-class> - Tests and transforms for Integers.</node-4>
-<node-5><java-class><a href="/site/apidocs/org/apache/juneau/assertions/IntegerAssertion.html" target="_blank">IntegerAssertion</a></java-class> - Assertion that returns itself.</node-5>
+<node-0><java-class><a href="/site/apidocs/org/apache/juneau/test/assertions/Assertion.html" target="_blank">Assertion</a></java-class> - Base class for all assertion objects containing common configuration methods.</node-0>
+<node-1><java-class><a href="/site/apidocs/org/apache/juneau/test/assertions/FluentAssertion.html" target="_blank">FluentAssertion</a></java-class> - Parent class for all fluent assertions.</node-1>
+<node-2><java-class><a href="/site/apidocs/org/apache/juneau/test/assertions/FluentObjectAssertion.html" target="_blank">FluentObjectAssertion</a></java-class> - Tests and transforms for general POJOs.</node-2>
+<node-3><java-class><a href="/site/apidocs/org/apache/juneau/test/assertions/FluentComparableAssertion.html" target="_blank">FluentComparableAssertion<T extends Comparable,R></a></java-class> - Tests and transforms for Comparables.</node-3>
+<node-4><java-class><a href="/site/apidocs/org/apache/juneau/test/assertions/FluentIntegerAssertion.html" target="_blank">FluentIntegerAssertion</a></java-class> - Tests and transforms for Integers.</node-4>
+<node-5><java-class><a href="/site/apidocs/org/apache/juneau/test/assertions/IntegerAssertion.html" target="_blank">IntegerAssertion</a></java-class> - Assertion that returns itself.</node-5>
</tree>
-In the design, the "Fluent" classes (e.g. <a href="/site/apidocs/org/apache/juneau/assertions/FluentIntegerAssertion.html" target="_blank">FluentIntegerAssertion</a>) allow you to specify the object that gets returned when the test method is executed.
+In the design, the "Fluent" classes (e.g. <a href="/site/apidocs/org/apache/juneau/test/assertions/FluentIntegerAssertion.html" target="_blank">FluentIntegerAssertion</a>) allow you to specify the object that gets returned when the test method is executed.
When used in the `RestClient` class for example, the return object is the <a href="/site/apidocs/org/apache/juneau/rest/client/RestResponse.html" target="_blank">RestResponse</a> object so that you can perform multiple fluent operations against that object.
-The "Normal" classes (e.g. <a href="/site/apidocs/org/apache/juneau/assertions/IntegerAssertion.html" target="_blank">IntegerAssertion</a>) are
+The "Normal" classes (e.g. <a href="/site/apidocs/org/apache/juneau/test/assertions/IntegerAssertion.html" target="_blank">IntegerAssertion</a>) are
simply subclasses of the fluent equivalent which return the assertion itself, meaning the test method returns the
-original <a href="/site/apidocs/org/apache/juneau/assertions/IntegerAssertion.html" target="_blank">IntegerAssertion</a> so that multiple tests can
+original <a href="/site/apidocs/org/apache/juneau/test/assertions/IntegerAssertion.html" target="_blank">IntegerAssertion</a> so that multiple tests can
be performed per assertion.
-For more information about the capabilities of the Assertions API, refer to the methods on the <a href="/site/apidocs/org/apache/juneau/assertions/Assertions.html" target="_blank">Assertions</a> methods above.
+For more information about the capabilities of the Assertions API, refer to the methods on the <a href="/site/apidocs/org/apache/juneau/test/assertions/Assertions.html" target="_blank">Assertions</a> methods above.
diff --git a/pages/topics/08.01.JuneauBctBasics.md b/pages/topics/08.01.JuneauBctBasics.md
index e6aacb4f9f..d1ff077c13 100644
--- a/pages/topics/08.01.JuneauBctBasics.md
+++ b/pages/topics/08.01.JuneauBctBasics.md
@@ -1,5 +1,5 @@
---
-title: "juneau-bct Basics"
+title: "Bean-Centric Testing Basics"
slug: JuneauBctBasics
---
@@ -76,7 +76,7 @@ assertBean(user, "name,age,active,address{street,city}",
### 1. Import Static Methods
```java
-import static org.apache.juneau.junit.bct.BctAssertions.*;
+import static org.apache.juneau.test.junit.bct.BctAssertions.*;
```
### 2. Basic Object Testing
@@ -131,13 +131,13 @@ void testList() {
## Core Assertion Methods
-#### [assertBean(Object, String, String)](pathname:///site/apidocs/org/apache/juneau/junit/bct/BctAssertions.html#assertBean(java.lang.Object,java.lang.String,java.lang.String))
+### [assertBean(Object, String, String)](pathname:///site/apidocs/org/apache/juneau/test/junit/bct/BctAssertions.html#assertBean(java.lang.Object,java.lang.String,java.lang.String))
Tests properties of a single object using a flexible property syntax with powerful nested access capabilities.
This method provides comprehensive property access for any Java object, supporting nested objects, collections, arrays, maps, and custom field access patterns. It uses intelligent property resolution with automatic type handling and supports complex object graphs.
-#### **Basic Property Testing:**
+### **Basic Property Testing:**
```java
// Simple properties
assertBean(user, "name,email", "John,john@example.com");
@@ -149,7 +149,7 @@ assertBean(user, "active,verified", "true,false");
assertBean(user, "middleName", "null");
```
-#### **Nested Object Testing:**
+### **Nested Object Testing:**
```java
// Single-level nesting
assertBean(user, "address{street,city}", "{123 Main St,Springfield}");
@@ -161,7 +161,7 @@ assertBean(user, "profile{settings{notifications{email}}}", "{{{true}}}");
assertBean(order, "id,customer{name,email},total", "12345,{John Doe,john@example.com},99.95");
```
-#### **Collection and Array Testing:**
+### **Collection and Array Testing:**
```java
// Index-based access
assertBean(order, "items{0{name},1{name}}", "{{Laptop},{Phone}}");
@@ -176,7 +176,7 @@ assertBean(order, "items{length,#{price}}", "{3,[{999.99},{699.99},{299.99}]}");
assertBean(data, "values{0,1,2}", "{100,200,300}");
```
-#### **Map Testing:**
+### **Map Testing:**
```java
// Direct key access
assertBean(config, "database{host,port}", "{localhost,5432}");
@@ -188,7 +188,7 @@ assertBean(user, "settings{size}", "{5}");
assertBean(user, "mapWithNullKey{<null>}", "{nullKeyValue}");
```
-#### **Field and Method Testing:**
+### **Field and Method Testing:**
```java
// Public fields (no getters required)
assertBean(myBean, "f1,f2,f3", "val1,val2,val3");
@@ -200,13 +200,13 @@ assertBean(myBean, "f1{length},f2{class{simpleName}}", "{5},{{String}}");
assertBean(user, "enabled,isActive,hasPermission", "true,false,true");
```
-#### [assertBeans(Collection, String, String...)](pathname:///site/apidocs/org/apache/juneau/junit/bct/BctAssertions.html#assertBeans(java.lang.Object,java.lang.String,java.lang.String...))
+### [assertBeans(Collection, String, String...)](pathname:///site/apidocs/org/apache/juneau/test/junit/bct/BctAssertions.html#assertBeans(java.lang.Object,java.lang.String,java.lang.String...))
Tests multiple objects in a collection, comparing the same properties across all objects using the same property access logic as `assertBean`.
This method validates that each bean in a collection has the specified property values. It's perfect for testing collections of similar objects, validation results, or parsed data structures. Each expected value string corresponds to one bean in the collection.
-#### **Basic Collection Testing:**
+### **Basic Collection Testing:**
```java
List<User> users = Arrays.asList(
new User("Alice", 25),
@@ -222,7 +222,7 @@ assertBeans(users, "name,age",
);
```
-#### **Complex Nested Properties:**
+### **Complex Nested Properties:**
```java
// Test nested properties across multiple beans
List<Order> orders = getOrderList();
@@ -239,13 +239,13 @@ assertBeans(carts, "items{0{name}},total",
);
```
-#### [assertList(Object, Object...)](pathname:///site/apidocs/org/apache/juneau/junit/bct/BctAssertions.html#assertList(java.lang.Object,java.lang.Object...))
+### [assertList(Object, Object...)](pathname:///site/apidocs/org/apache/juneau/test/junit/bct/BctAssertions.html#assertList(java.lang.Object,java.lang.Object...))
Tests collection elements directly with support for multiple comparison modes: string conversion, functional validation with predicates, and direct object equality.
This method supports any object that can be converted to a List, including arrays, collections, iterables, streams, and more. It provides three distinct comparison modes based on the type of expected values provided.
-#### **String Conversion Testing (Default Mode):**
+### **String Conversion Testing (Default Mode):**
```java
// String collections - compares string representations
assertList(List.of("a", "b", "c"), "a", "b", "c");
@@ -260,7 +260,7 @@ assertList(productNames, "Laptop", "Phone", "Tablet");
assertList(myArray, "element1", "element2", "element3");
```
-#### **Predicate Testing (Functional Validation):**
+### **Predicate Testing (Functional Validation):**
```java
// Use Predicate<T> for functional testing
Predicate<Integer> greaterThanOne = x -> x > 1;
@@ -275,7 +275,7 @@ Predicate<User> isActive = user -> user.isActive();
assertList(userList, isActive, isActive);
```
-#### **Object Equality Testing (Direct Comparison):**
+### **Object Equality Testing (Direct Comparison):**
```java
// Non-String, non-Predicate objects use Objects.equals() comparison
assertList(List.of(1, 2, 3), 1, 2, 3); // Integer objects
@@ -287,13 +287,13 @@ assertList(List.of(myBean1, myBean2), myBean1, myBean2);
assertList(mixedList, stringObj, integerObj, customObj);
```
-#### [assertMapped(Object, BiFunction, String, String)](pathname:///site/apidocs/org/apache/juneau/junit/bct/BctAssertions.html#assertMapped(java.lang.Object,java.util.function.BiFunction,java.lang.String,java.lang.String))
+### [assertMapped(Object, BiFunction, String, String)](pathname:///site/apidocs/org/apache/juneau/test/junit/bct/BctAssertions.html#assertMapped(java.lang.Object,java.util.function.BiFunction,java.lang.String,java.lang.String))
Tests objects with custom property access logic using a BiFunction, designed for objects that don't follow standard JavaBean patterns or require specialized property extraction.
This method creates an intermediate LinkedHashMap to collect all property values before using the same logic as `assertBean` for comparison. This ensures consistent ordering and supports the full nested property syntax. The BiFunction receives the object and property name, returning the property value.
-#### **Custom Property Access:**
+### **Custom Property Access:**
```java
// Custom property access for non-standard objects
assertMapped(myObject, (obj, prop) -> obj.getProperty(prop),
@@ -307,7 +307,7 @@ assertMapped(data, (map, key) -> map.get(key),
"name,score", "Alice,95");
```
-#### **Exception Handling:**
+### **Exception Handling:**
```java
// Exceptions become simple class names in output
assertMapped(dataSource, (ds, prop) -> {
@@ -328,7 +328,7 @@ assertMapped(webService, (service, endpoint) -> {
}, "userEndpoint", "TimeoutException");
```
-#### **Complex Property Logic:**
+### **Complex Property Logic:**
```java
// Transform complex nested access patterns
assertMapped(configSystem, (config, prop) -> {
@@ -351,7 +351,7 @@ assertMapped(userService, (service, operation) -> {
}, "count,active", "150,45");
```
-#### **Legacy System Integration:**
+### **Legacy System Integration:**
```java
// Access legacy objects without standard getters
assertMapped(legacyBean, (bean, fieldName) -> {
@@ -365,7 +365,7 @@ assertMapped(legacyBean, (bean, fieldName) -> {
BCT provides several additional assertion methods for common testing scenarios:
-#### [assertContains(String, Object)](pathname:///site/apidocs/org/apache/juneau/junit/bct/BctAssertions.html#assertContains(java.lang.String,java.lang.Object))
+### [assertContains(String, Object)](pathname:///site/apidocs/org/apache/juneau/test/junit/bct/BctAssertions.html#assertContains(java.lang.String,java.lang.Object))
Tests that a string appears somewhere within the stringified object.
@@ -379,7 +379,7 @@ assertContains("Smith", user);
assertContains("banana", items);
```
-#### [assertContainsAll(Object, String...)](pathname:///site/apidocs/org/apache/juneau/junit/bct/BctAssertions.html#assertContainsAll(java.lang.Object,java.lang.String...))
+### [assertContainsAll(Object, String...)](pathname:///site/apidocs/org/apache/juneau/test/junit/bct/BctAssertions.html#assertContainsAll(java.lang.Object,java.lang.String...))
Tests that all specified strings appear within the stringified object.
@@ -392,7 +392,7 @@ assertContainsAll(user, "Alice", "Smith", "25");
assertContainsAll(user, "alice", "example.com");
```
-#### [assertEmpty(Object)](pathname:///site/apidocs/org/apache/juneau/junit/bct/BctAssertions.html#assertEmpty(java.lang.Object))
+### [assertEmpty(Object)](pathname:///site/apidocs/org/apache/juneau/test/junit/bct/BctAssertions.html#assertEmpty(java.lang.Object))
Tests that collections, arrays, maps, or strings are empty.
@@ -409,7 +409,7 @@ assertEmpty(emptyMap);
assertEmpty(emptyString);
```
-#### [assertNotEmpty(Object)](pathname:///site/apidocs/org/apache/juneau/junit/bct/BctAssertions.html#assertNotEmpty(java.lang.Object))
+### [assertNotEmpty(Object)](pathname:///site/apidocs/org/apache/juneau/test/junit/bct/BctAssertions.html#assertNotEmpty(java.lang.Object))
Tests that collections, arrays, maps, or strings are not empty.
@@ -426,7 +426,7 @@ assertNotEmpty(config);
assertNotEmpty(message);
```
-#### [assertSize(int, Object)](pathname:///site/apidocs/org/apache/juneau/junit/bct/BctAssertions.html#assertSize(int,java.lang.Object))
+### [assertSize(int, Object)](pathname:///site/apidocs/org/apache/juneau/test/junit/bct/BctAssertions.html#assertSize(int,java.lang.Object))
Tests the size/length of collections, arrays, maps, or strings.
@@ -443,7 +443,7 @@ assertSize(2, scores);
assertSize(5, message);
```
-#### [assertString(String, Object)](pathname:///site/apidocs/org/apache/juneau/junit/bct/BctAssertions.html#assertString(java.lang.String,java.lang.Object))
+### [assertString(String, Object)](pathname:///site/apidocs/org/apache/juneau/test/junit/bct/BctAssertions.html#assertString(java.lang.String,java.lang.Object))
Tests the string representation of an object using the configured converter.
@@ -458,7 +458,7 @@ assertString("[1, 2, 3]", numbers);
assertString("2021-01-01", date);
```
-#### [assertMatchesGlob(String, Object)](pathname:///site/apidocs/org/apache/juneau/junit/bct/BctAssertions.html#assertMatchesGlob(java.lang.String,java.lang.Object))
+### [assertMatchesGlob(String, Object)](pathname:///site/apidocs/org/apache/juneau/test/junit/bct/BctAssertions.html#assertMatchesGlob(java.lang.String,java.lang.Object))
Tests that the stringified object matches a glob-style pattern (* and ? wildcards).
diff --git a/pages/topics/08.02.CustomErrorMessages.md b/pages/topics/08.02.CustomErrorMessages.md
index 270826e0a6..aa7b81086b 100644
--- a/pages/topics/08.02.CustomErrorMessages.md
+++ b/pages/topics/08.02.CustomErrorMessages.md
@@ -398,7 +398,7 @@ void testOrderIntegration() {
## See Also
-- [juneau-bct Basics](JuneauBctBasics) - Main BCT documentation
+- [Bean-Centric Testing Basics](JuneauBctBasics) - Main BCT documentation
- [Customization](Customization) - Configuration via @BctConfig and BctConfiguration
- [Stringifiers](Stringifiers) - Converting objects to strings
- [Listifiers](Listifiers) - Converting collection-like objects to lists
diff --git a/pages/topics/08.03.01.Customization.md b/pages/topics/08.03.01.Customization.md
index 75c405788a..af3a474fbd 100644
--- a/pages/topics/08.03.01.Customization.md
+++ b/pages/topics/08.03.01.Customization.md
@@ -23,7 +23,7 @@ The `@BctConfig` annotation provides a declarative way to configure BCT settings
### Basic Usage
```java
-import org.apache.juneau.junit.bct.annotations.BctConfig;
+import org.apache.juneau.test.junit.bct.annotations.BctConfig;
import org.apache.juneau.commons.lang.TriState;
@BctConfig(sortMaps=TriState.TRUE)
@@ -39,7 +39,7 @@ class MyTest {
### Annotation Properties
-#### sortMaps
+### sortMaps
Controls whether map entries are sorted by key before comparison in assertions.
@@ -60,7 +60,7 @@ class MyTest {
- `TriState.FALSE` - Disable map sorting
- `TriState.UNSET` - Inherit from class-level annotation (default for method-level)
-#### sortCollections
+### sortCollections
Controls whether collection elements are sorted before comparison in assertions.
@@ -81,7 +81,7 @@ class MyTest {
- `TriState.FALSE` - Disable collection sorting
- `TriState.UNSET` - Inherit from class-level annotation (default for method-level)
-#### beanConverter
+### beanConverter
Specifies a custom bean converter class to use for all assertions in the test.
@@ -157,7 +157,7 @@ The `BctConfiguration` class provides a programmatic API for configuring BCT set
### Setting Configuration Values
```java
-import static org.apache.juneau.junit.bct.BctConfiguration.*;
+import static org.apache.juneau.test.junit.bct.BctConfiguration.*;
@BeforeEach
void setUp() {
@@ -345,7 +345,7 @@ For more advanced customization options, see:
## See Also
-- [juneau-bct Basics](JuneauBctBasics) - Main BCT documentation
+- [Bean-Centric Testing Basics](JuneauBctBasics) - Main BCT documentation
- [Custom Error Messages](CustomErrorMessages) - Enhanced error reporting
- [Property Extractors](PropertyExtractors) - Custom property access logic
diff --git a/pages/topics/08.03.02.Stringifiers.md b/pages/topics/08.03.02.Stringifiers.md
index d530f9f1e2..fd7200a77c 100644
--- a/pages/topics/08.03.02.Stringifiers.md
+++ b/pages/topics/08.03.02.Stringifiers.md
@@ -190,7 +190,7 @@ try {
## See Also
-- [juneau-bct Basics](JuneauBctBasics) - Main BCT documentation
+- [Bean-Centric Testing Basics](JuneauBctBasics) - Main BCT documentation
- [Customization](Customization) - Configuration via @BctConfig and BctConfiguration
- [Listifiers](Listifiers) - Converting collection-like objects to lists
- [Swappers](Swappers) - Transforming objects before processing
diff --git a/pages/topics/08.03.03.Listifiers.md b/pages/topics/08.03.03.Listifiers.md
index 17e5179285..246a01c13f 100644
--- a/pages/topics/08.03.03.Listifiers.md
+++ b/pages/topics/08.03.03.Listifiers.md
@@ -259,7 +259,7 @@ Listifier<DataSource> safeListifier = (conv, source) -> {
## See Also
-- [juneau-bct Basics](JuneauBctBasics) - Main BCT documentation
+- [Bean-Centric Testing Basics](JuneauBctBasics) - Main BCT documentation
- [Customization](Customization) - Configuration via @BctConfig and BctConfiguration
- [Stringifiers](Stringifiers) - Converting objects to strings
- [Swappers](Swappers) - Transforming objects before processing
diff --git a/pages/topics/08.03.04.Swappers.md b/pages/topics/08.03.04.Swappers.md
index 7c1bae0364..48ae78596a 100644
--- a/pages/topics/08.03.04.Swappers.md
+++ b/pages/topics/08.03.04.Swappers.md
@@ -355,7 +355,7 @@ Swapper<Validation> validationSwapper = (conv, validation) -> {
## See Also
-- [juneau-bct Basics](JuneauBctBasics) - Main BCT documentation
+- [Bean-Centric Testing Basics](JuneauBctBasics) - Main BCT documentation
- [Customization](Customization) - Configuration via @BctConfig and BctConfiguration
- [Stringifiers](Stringifiers) - Converting objects to strings
- [Listifiers](Listifiers) - Converting collection-like objects to lists
diff --git a/pages/topics/08.03.05.PropertyExtractors.md b/pages/topics/08.03.05.PropertyExtractors.md
index 827719a3d0..9cfd323e04 100644
--- a/pages/topics/08.03.05.PropertyExtractors.md
+++ b/pages/topics/08.03.05.PropertyExtractors.md
@@ -480,7 +480,7 @@ try {
## See Also
-- [juneau-bct Basics](JuneauBctBasics) - Main BCT documentation
+- [Bean-Centric Testing Basics](JuneauBctBasics) - Main BCT documentation
- [Customization](Customization) - Configuration via @BctConfig and BctConfiguration
- [Stringifiers](Stringifiers) - Converting objects to strings
- [Listifiers](Listifiers) - Converting collection-like objects to lists
diff --git a/pages/topics/08.04.JuneauTestJUnitExtensions.md b/pages/topics/08.04.JuneauTestJUnitExtensions.md
new file mode 100644
index 0000000000..26e212436e
--- /dev/null
+++ b/pages/topics/08.04.JuneauTestJUnitExtensions.md
@@ -0,0 +1,49 @@
+---
+title: "JUnit Extensions"
+slug: JuneauTestJUnitExtensions
+---
+
+# JUnit 5 Extensions
+
+The `juneau-test` module bundles a small JUnit 5 extension (formerly the standalone `juneau-junit5` module) for **test-time bean injection** — swapping production beans with test doubles inside a Juneau `BeanStore` for the duration of a JUnit 5 test, without modifying production code and without proxying. It is the Juneau-flavored answer to Spring's `@TestConfiguration` / `@MockBean`.
+
+The extension lives in the <a href="/site/apidocs/org/apache/juneau/test/junit/package-summary.html" target="_blank">org.apache.juneau.test.junit</a> package and centers on three types:
+
+- <a href="/site/apidocs/org/apache/juneau/test/junit/JuneauBeanStoreExtension.html" target="_blank">JuneauBeanStoreExtension</a> — the JUnit 5 `Extension`, registered via `@ExtendWith` or `@RegisterExtension`.
+- <a href="/site/apidocs/org/apache/juneau/test/junit/TestBean.html" target="_blank">TestBean</a> — the field/method annotation that declares an override.
+- <a href="/site/apidocs/org/apache/juneau/test/junit/TestBeanStore.html" target="_blank">TestBeanStore</a> — the overlay bean store, resolvable as a test-method parameter.
+
+## Quick start
+
+```java
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.apache.juneau.test.junit.*;
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.extension.*;
+
+@ExtendWith(JuneauBeanStoreExtension.class)
+class MyServiceTest {
+
+ @TestBean
+ ExternalApi mockApi = () -> "test-double";
+
+ @Test
+ void resolvesTheTestDouble(TestBeanStore store) {
+ assertSame(mockApi, store.getBean(ExternalApi.class).orElseThrow());
+ }
+
+ interface ExternalApi { String describe(); }
+}
+```
+
+## Two wiring modes
+
+- **Mode INJECT** (default) — construction-time wiring. The system-under-test is built *after* the overlay, which is threaded into the builder's `overridingBeanStore(...)` setter. Universal: every bean type is eligible for replacement, including ones the framework would otherwise pin into a per-op memoizer at boot.
+- **Mode OVERLAY** — push/pop overlays on a long-lived SUT (typically a `Microservice` booted once in `@BeforeAll`), applied and removed per test via `@TestBean(mode = Mode.OVERLAY)`.
+
+The `overridingBeanStore(BeanStore)` setter is available on every builder implementing `BeanStoreOverridable<B>`: `MockRestClient.Builder`, `Microservice.Builder`, `SerializerSet.Builder`, `ParserSet.Builder`, and `EncoderSet.Builder`.
+
+## REST-focused deep dive
+
+For a full walkthrough of `@TestBean` with `MockRestClient` — named-bean qualifiers, explicit-type overrides, per-test vs. per-class scope, and the Mode-OVERLAY safety inventory — see [Test-time Bean Injection](/docs/topics/RestServerTestBeanInjection).
diff --git a/pages/topics/09.01.JuneauRestCommonBasics.md b/pages/topics/09.01.JuneauRestCommonBasics.md
index 0cd0a43c7b..d80b378e3a 100644
--- a/pages/topics/09.01.JuneauRestCommonBasics.md
+++ b/pages/topics/09.01.JuneauRestCommonBasics.md
@@ -10,7 +10,7 @@ slug: JuneauRestCommonBasics
| `juneau-rest-common` | Transport-neutral types under `org.apache.juneau.http.*` and `org.apache.juneau.http.remote.*` — annotations, lazy header beans, remote-proxy meta, transport-neutral parts. Used by every `juneau-rest-*` module. | **No.** Zero `org.apache.httpcomponents:*` on the classpath. |
| `juneau-rest-common-classic` | Apache HttpClient 4.5–compatible facades under `org.apache.juneau.http.classic.*` — `BasicHeader`, `BasicMediaTypeHeader`, `BasicHttpEntity`, `BasicHttpResponse`, response/exception classes, `HeaderList`, etc. (~170 types). | **Yes.** Depends on `juneau-rest-common` and `org.apache.httpcomponents:httpcore:4.4.16`. |
-#### Maven Dependency
+### Maven Dependency
For NG (transport-neutral) consumers — the canonical path:
@@ -39,21 +39,21 @@ For code that uses any `org.apache.juneau.http.classic.*` facade (e.g. `BasicHea
The aggregator artifacts (`juneau-rest-server`, `juneau-rest-client-classic`, `juneau-rest-mock`, `juneau-microservice`, `juneau-rest-server-springboot`, `juneau-shaded-rest-server`, `juneau-shaded-rest-client`, `juneau-shaded-all`, `juneau-distrib`) already pull both modules in transitively, so most callers don't need to declare them directly.
-#### Java Library
+### Java Library
```text
juneau-rest-common-0.0.0.jar
juneau-rest-common-classic-0.0.0.jar
```
-#### OSGi Module
+### OSGi Module
```text
org.apache.juneau.rest.server.common_0.0.0.jar
org.apache.juneau.rest.server.common.classic_0.0.0.jar
```
-#### Contents/Features
+### Contents/Features
The transport-neutral packages in `juneau-rest-common`:
diff --git a/pages/topics/09.02.HelperClasses.md b/pages/topics/09.02.HelperClasses.md
index 1aebb24169..8c25372462 100644
--- a/pages/topics/09.02.HelperClasses.md
+++ b/pages/topics/09.02.HelperClasses.md
@@ -14,7 +14,7 @@ standard HTTP components using static imports.
<node-0><java-class><a href="/site/apidocs/org/apache/juneau/http/HttpResponses.html" target="_blank">HttpResponses</a></java-class> - Utility class for standard HTTP resources.</node-0>
</tree>
-#### HttpHeaders
+### HttpHeaders
The <a href="/site/apidocs/org/apache/juneau/http/HttpHeaders.html" target="_blank">HttpHeaders</a> class contains many convenience static methods
and fields for working with standard HTTP request and response headers and header lists.
@@ -88,7 +88,7 @@ Lists of headers can be produced with the following methods:
The capabilities of the <a href="/site/apidocs/org/apache/juneau/http/header/HeaderList.html" target="_blank">HeaderList</a> class is described
later.
-#### HttpParts
+### HttpParts
The <a href="/site/apidocs/org/apache/juneau/http/HttpParts.html" target="_blank">HttpParts</a> class contains convenience static methods for
generating query/form-data/path parts and part lists.
@@ -136,7 +136,7 @@ Lists of parts can be produced with the following methods:
The capabilities of the <a href="/site/apidocs/org/apache/juneau/http/part/PartList.html" target="_blank">PartList</a> class is described later.
-#### HttpEntities
+### HttpEntities
The <a href="/site/apidocs/org/apache/juneau/http/HttpEntities.html" target="_blank">HttpEntities</a> class contains convenience static methods for
generating HTTP message entities.
@@ -175,7 +175,7 @@ public HttpEntity helloWold(...) {
```
:::
-#### HttpResources
+### HttpResources
The <a href="/site/apidocs/org/apache/juneau/http/HttpResources.html" target="_blank">HttpResources</a> class contains convenience static methods
for generating HTTP message resources.
@@ -208,7 +208,7 @@ public HttpResource helloWold(...) {
```
:::
-#### HttpResponses
+### HttpResponses
The <a href="/site/apidocs/org/apache/juneau/http/HttpResponses.html" target="_blank">HttpResponses</a> class contains convenience static methods
for standard HTTP responses.
diff --git a/pages/topics/09.04.HttpHeaders.md b/pages/topics/09.04.HttpHeaders.md
index ae2b875843..551693f560 100644
--- a/pages/topics/09.04.HttpHeaders.md
+++ b/pages/topics/09.04.HttpHeaders.md
@@ -19,7 +19,7 @@ These headers extend from the following classes that provide data-type specific
<node-3><javac-class><a href="/site/apidocs/org/apache/juneau/http/header/BasicBooleanHeader.html" target="_blank">BasicBooleanHeader</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/http/header/BasicCsvHeader.html" target="_blank">BasicCsvHeader</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/http/header/BasicDateHeader.html" target="_blank">BasicDateHeader</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/http/header/ [...]
</tree>
-#### Creator Methods
+### Creator Methods
Static methods are provided on <a href="/site/apidocs/org/apache/juneau/http/HttpHeaders.html" target="_blank">HttpHeaders</a> to simplify creation
of headers:
@@ -44,7 +44,7 @@ restClient
```
:::
-#### HeaderList
+### HeaderList
The <a href="/site/apidocs/org/apache/juneau/http/header/HeaderList.html" target="_blank">HeaderList</a> class is a list of HTTP headers.
diff --git a/pages/topics/09.05.HttpParts.md b/pages/topics/09.05.HttpParts.md
index 363e005967..2faca707c3 100644
--- a/pages/topics/09.05.HttpParts.md
+++ b/pages/topics/09.05.HttpParts.md
@@ -19,7 +19,7 @@ The <a href="/site/apidocs/org/apache/juneau/http/part/package-summary.html" tar
<node-1><java-class><a href="/site/apidocs/org/apache/juneau/http/part/BasicUriPart.html" target="_blank">BasicUriPart</a></java-class></node-1>
</tree>
-#### PartList
+### PartList
The <a href="/site/apidocs/org/apache/juneau/http/part/PartList.html" target="_blank">PartList</a> class is a list of HTTP parts (form-data,
query-parameters, path-parameters).
diff --git a/pages/topics/09.06.HttpEntitiesAndResources.md b/pages/topics/09.06.HttpEntitiesAndResources.md
index 294c1c711a..4ade42b8c2 100644
--- a/pages/topics/09.06.HttpEntitiesAndResources.md
+++ b/pages/topics/09.06.HttpEntitiesAndResources.md
@@ -38,7 +38,7 @@ HttpEntity entity = byteArrayEntity(payload, ContentType.APPLICATION_OCTET_STREA
HTTP entities and resources can be used by both the server and client side APIs described in later sections.
-#### Server-side example:
+### Server-side example:
```java
// REST endpoint that simply echos an HTTP entity.
@@ -54,7 +54,7 @@ public HttpResource getStaticFile(@Path String fileName, Locale locale) {
}
```
-#### Client-side example:
+### Client-side example:
```java
// REST client that uses the echo REST endpoint above.
diff --git a/pages/topics/10.01.JuneauRestServerBasics.md b/pages/topics/10.01.JuneauRestServerBasics.md
index 66fba845f4..f0873a2afb 100644
--- a/pages/topics/10.01.JuneauRestServerBasics.md
+++ b/pages/topics/10.01.JuneauRestServerBasics.md
@@ -3,7 +3,7 @@ title: "juneau-rest-server Basics"
slug: JuneauRestServerBasics
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
@@ -13,13 +13,13 @@ slug: JuneauRestServerBasics
</dependency>
```
-#### Java Library
+### Java Library
```text
juneau-rest-server-0.0.0.jar
```
-#### OSGi Module
+### OSGi Module
```text
org.apache.juneau.rest.server_0.0.0.jar
@@ -51,7 +51,7 @@ you can revert to the existing servlet APIs to do low-level processing of reques
It also means you need nothing more than a Servlet container such as Jetty to use the REST framework.
-#### Contents/Features
+### Contents/Features
- Deployable in standard Servlet containers.
- Deployable in Spring Boot environments with full support for injected beans.
diff --git a/pages/topics/10.04.04.JavaMethodReturnTypes.md b/pages/topics/10.04.04.JavaMethodReturnTypes.md
index b27704d0e5..e3b5ab9546 100644
--- a/pages/topics/10.04.04.JavaMethodReturnTypes.md
+++ b/pages/topics/10.04.04.JavaMethodReturnTypes.md
@@ -18,33 +18,33 @@ public String doGet() {
In addition to POJOs, the following return types are also supported:
-#### Parameters based on class types:
+### Parameters based on class types:
-#### Direct streams:
+### Direct streams:
<tree>
<node-0><javac-class><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/InputStream.html" target="_blank">InputStream</a></javac-class> <javac-class><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/Reader.html" target="_blank">Reader</a></javac-class></node-0>
</tree>
-#### Apache HttpComponent beans:
+### Apache HttpComponent beans:
<tree>
<node-0><javac-class><a href="https://hc.apache.org/httpcomponents-core-4.4.x/current/httpcore/apidocs/org/apache/http/HttpEntity.html" target="_blank">HttpEntity</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/http/resource/HttpResource.html" target="_blank">HttpResource</a></javac-class> <javac-class><a href="https://hc.apache.org/httpcomponents-core-4.4.x/current/httpcore/apidocs/org/apache/http/HttpResponse.html" target="_blank">HttpResponse</a></javac-class>< [...]
</tree>
-#### Standard HTTP response beans:
+### Standard HTTP response beans:
<tree>
<node-0><javac-class><a href="/site/apidocs/org/apache/juneau/http/response/Accepted.html" target="_blank">Accepted</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/http/response/AlreadyReported.html" target="_blank">AlreadyReported</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/http/response/BadRequest.html" target="_blank">BadRequest</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/http/response/Conflict.html" targe [...]
</tree>
-#### Other:
+### Other:
<tree>
<node-0><javac-class><a href="/site/apidocs/org/apache/juneau/rest/server/beans/ChildResourceDescriptions.html" target="_blank">ChildResourceDescriptions</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/rest/server/beans/ResourceDescriptions.html" target="_blank">ResourceDescriptions</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/rest/server/beans/SeeOtherRoot.html" target="_blank">SeeOtherRoot</a></javac-class> <javac-class><a href="https: [...]
</tree>
-#### Annotated parameters (either on the parameter or parameter type):
+### Annotated parameters (either on the parameter or parameter type):
<tree>
<node-0><javac-annotation><a href="/site/apidocs/org/apache/juneau/http/Response.html" target="_blank">Response</a></javac-annotation></node-0>
diff --git a/pages/topics/10.04.05.JavaMethodThrowableTypes.md b/pages/topics/10.04.05.JavaMethodThrowableTypes.md
index a9ef597928..d69a9171fb 100644
--- a/pages/topics/10.04.05.JavaMethodThrowableTypes.md
+++ b/pages/topics/10.04.05.JavaMethodThrowableTypes.md
@@ -5,13 +5,13 @@ slug: JavaMethodThrowableTypes
Annotated Java methods can throw any of the following:
-#### Standard HTTP response beans:
+### Standard HTTP response beans:
<tree>
<node-0><javac-class><a href="/site/apidocs/org/apache/juneau/http/response/BadRequest.html" target="_blank">BadRequest</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/http/response/Conflict.html" target="_blank">Conflict</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/http/response/ExpectationFailed.html" target="_blank">ExpectationFailed</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/http/response/FailedDependency [...]
</tree>
-#### Annotated throwables:
+### Annotated throwables:
<tree>
<node-0><java-annotation><a href="/site/apidocs/org/apache/juneau/http/Response.html" target="_blank">Response</a></java-annotation></node-0>
@@ -19,18 +19,18 @@ Annotated Java methods can throw any of the following:
All other throwables get processed as follows:
-#### Processed as 400/Bad Request:
+### Processed as 400/Bad Request:
<tree>
<node-0><java-class><a href="/site/apidocs/org/apache/juneau/marshall/parser/ParseException.html" target="_blank">ParseException</a></java-class></node-0>
<node-0><java-class><a href="/site/apidocs/org/apache/juneau/InvalidDataConversionException.html" target="_blank">InvalidDataConversionException</a></java-class></node-0>
</tree>
-#### Processed as 401/Unauthorized:
+### Processed as 401/Unauthorized:
- Any class named "*AccessDenied*" or "*Unauthorized*"
-#### Processed as 404/Not Found:
+### Processed as 404/Not Found:
- Any class named "*Empty*" or "*NotFound*"
diff --git a/pages/topics/10.05.01.HttpPartBasics.md b/pages/topics/10.05.01.HttpPartBasics.md
index 6d119eabb9..7456f32285 100644
--- a/pages/topics/10.05.01.HttpPartBasics.md
+++ b/pages/topics/10.05.01.HttpPartBasics.md
@@ -24,7 +24,7 @@ Annotations are provided for both request and response HTTP parts.
The annotations used for defining the schema for request HTTP parts are:
-#### HTTP request parts:
+### HTTP request parts:
<tree>
<node-0><java-annotation><a href="/site/apidocs/org/apache/juneau/http/Request.html" target="_blank">Request</a></java-annotation></node-0>
@@ -37,7 +37,7 @@ The annotations used for defining the schema for request HTTP parts are:
<node-0><java-annotation><a href="/site/apidocs/org/apache/juneau/http/HasQuery.html" target="_blank">HasQuery</a></java-annotation></node-0>
</tree>
-#### HTTP response parts:
+### HTTP response parts:
<tree>
<node-0><java-annotation><a href="/site/apidocs/org/apache/juneau/http/Response.html" target="_blank">Response</a></java-annotation></node-0>
diff --git a/pages/topics/10.05.03.HttpPartAnnotations.md b/pages/topics/10.05.03.HttpPartAnnotations.md
index 56c0474418..89dd34c000 100644
--- a/pages/topics/10.05.03.HttpPartAnnotations.md
+++ b/pages/topics/10.05.03.HttpPartAnnotations.md
@@ -5,7 +5,7 @@ slug: HttpPartAnnotations
The following annotations allow for defining part schemas based on the OpenAPI standard.
-#### Request annotations:
+### Request annotations:
<tree>
<node-0><java-annotation><a href="/site/apidocs/org/apache/juneau/http/Request.html" target="_blank">Request</a></java-annotation></node-0>
@@ -22,7 +22,7 @@ The following annotations allow for defining part schemas based on the OpenAPI s
<node-1><javac-method-annotation><a href="/site/apidocs/org/apache/juneau/http/Content.html#schema()" target="_blank">schema</a></javac-method-annotation></node-1>
</tree>
-#### Response annotations:
+### Response annotations:
<tree>
<node-0><java-annotation><a href="/site/apidocs/org/apache/juneau/http/Response.html" target="_blank">Response</a></java-annotation></node-0>
@@ -35,7 +35,7 @@ The following annotations allow for defining part schemas based on the OpenAPI s
<node-1><javac-method-annotation><a href="/site/apidocs/org/apache/juneau/http/StatusCode.html#value()" target="_blank">value</a></javac-method-annotation></node-1>
</tree>
-#### Common schema annotation:
+### Common schema annotation:
<tree>
<node-0><java-annotation><a href="/site/apidocs/org/apache/juneau/annotation/Schema.html" target="_blank">Schema</a></java-annotation></node-0>
diff --git a/pages/topics/10.05.08.HttpPartValidation.md b/pages/topics/10.05.08.HttpPartValidation.md
index 28bdaff638..f6d9a6aa4c 100644
--- a/pages/topics/10.05.08.HttpPartValidation.md
+++ b/pages/topics/10.05.08.HttpPartValidation.md
@@ -13,25 +13,25 @@ Juneau supports comprehensive format validation for HTTP parts based on JSON Sch
The following format types are supported:
-#### Email Formats
+### Email Formats
- `email` - Email address (RFC 5321)
- `idn-email` - Internationalized email address (RFC 6531)
-#### Hostname Formats
+### Hostname Formats
- `hostname` - Internet host name (RFC 1123)
- `idn-hostname` - Internationalized host name (RFC 5890)
-#### IP Address Formats
+### IP Address Formats
- `ipv4` - IPv4 address (RFC 2673)
- `ipv6` - IPv6 address (RFC 4291)
-#### URI/IRI Formats
+### URI/IRI Formats
- `uri` - Universal Resource Identifier (RFC 3986)
- `uri-reference` - URI Reference (RFC 3986)
- `iri` - Internationalized Resource Identifier (RFC 3987)
- `iri-reference` - IRI Reference (RFC 3987)
-#### Other Formats
+### Other Formats
- `uuid` - Universally Unique Identifier (RFC 4122)
- `uri-template` - URI Template (RFC 6570)
- `json-pointer` - JSON Pointer (RFC 6901)
@@ -43,7 +43,7 @@ The following format types are supported:
- `time` - Time (RFC 3339)
- `duration` - Duration (RFC 3339 Appendix A / ISO 8601)
-#### Transformation Formats
+### Transformation Formats
- `byte` - BASE-64 encoded characters
- `binary` - Hexadecimal encoded octets
- `binary-spaced` - Space-separated hexadecimal octets
diff --git a/pages/topics/10.07.HandlingFormPosts.md b/pages/topics/10.07.HandlingFormPosts.md
index dca397b227..2f707e174e 100644
--- a/pages/topics/10.07.HandlingFormPosts.md
+++ b/pages/topics/10.07.HandlingFormPosts.md
@@ -70,7 +70,7 @@ public class SpringBootAppConfig {
```
:::
-#### Multi-part Form Posts
+### Multi-part Form Posts
The Juneau framework does not natively support multipart form posts.
However, it can be done in conjunction with the Apache Commons File Upload library or through the Servlet 3.0 API
diff --git a/pages/topics/10.19.SvlVariables.md b/pages/topics/10.19.SvlVariables.md
index ab22d6dcf5..16301439c7 100644
--- a/pages/topics/10.19.SvlVariables.md
+++ b/pages/topics/10.19.SvlVariables.md
@@ -22,7 +22,7 @@ Variables take the form `$X{contents}` where `X` can consist of zero or more ASC
virtually anything.
This is called Simple Variable Language, or SVL, and is defined here: [Simple Variable Language](/docs/topics/SimpleVariableLanguageBasics).
-#### Features
+### Features
- Variables can be nested arbitrarily deep (e.g.
@@ -42,7 +42,7 @@ There are two distinct groups of variables:
The following is the default list of supported variables:
-#### Default REST SVL Variables:
+### Default REST SVL Variables:
| Module | Class | Pattern | Initialization time | Request time | Examples |
|--------|-------|---------|-------------------|--------------|----------|
diff --git a/pages/topics/10.29.04.BasicSwaggerInfo.md b/pages/topics/10.29.04.BasicSwaggerInfo.md
index c9d2ab4f42..df956af327 100644
--- a/pages/topics/10.29.04.BasicSwaggerInfo.md
+++ b/pages/topics/10.29.04.BasicSwaggerInfo.md
@@ -12,7 +12,7 @@ The top part of the page shows general information about the REST interface:
The information is pulled from the <a href="/site/apidocs/org/apache/juneau/rest/server/Rest.html#swagger()" target="_blank">@Rest(swagger)</a>
annotation.
-#### org.apache.juneau.petstore.rest.PetStoreResource
+### org.apache.juneau.petstore.rest.PetStoreResource
```java
@Rest(
@@ -27,7 +27,7 @@ public class PetStoreResource extends BasicRestServlet {...}
In this particular case, the Swagger is pulled in from a localized Swagger JSON file located in the `org.apache.juneau.petstore.rest` package using the <a href="/site/apidocs/org/apache/juneau/rest/server/vars/FileVar.html" target="_blank">$F</a> variable.
-#### PetStoreResource.json
+### PetStoreResource.json
```js
{
diff --git a/pages/topics/10.29.05.SwaggerTags.md b/pages/topics/10.29.05.SwaggerTags.md
index 64648feffb..23106f8571 100644
--- a/pages/topics/10.29.05.SwaggerTags.md
+++ b/pages/topics/10.29.05.SwaggerTags.md
@@ -12,7 +12,7 @@ In the example below, the `pet` and `store` tag sections are collapsed and the `
Tags are also defined in the <a href="/site/apidocs/org/apache/juneau/rest/server/Swagger.html" target="_blank">@Swagger</a> annotation
-#### PetStoreResource.json
+### PetStoreResource.json
```json
"tags": [
@@ -41,7 +41,7 @@ Tags are also defined in the <a href="/site/apidocs/org/apache/juneau/rest/serve
The annotation-only approach is shown here:
-#### org.apache.juneau.petstore.rest.PetStoreResource
+### org.apache.juneau.petstore.rest.PetStoreResource
```java
swagger=@Swagger(
@@ -73,7 +73,7 @@ swagger=@Swagger(
Tags are associated with operations using the <a href="/site/apidocs/org/apache/juneau/rest/server/OpSwagger.html#tags()" target="_blank">@OpSwagger(tags)</a> annotation:
-#### GET /user operation
+### GET /user operation
```java
@RestGet(
diff --git a/pages/topics/10.29.06.SwaggerOperations.md b/pages/topics/10.29.06.SwaggerOperations.md
index 9ced45de69..4b2d551fa8 100644
--- a/pages/topics/10.29.06.SwaggerOperations.md
+++ b/pages/topics/10.29.06.SwaggerOperations.md
@@ -7,7 +7,7 @@ slug: SwaggerOperations
The following shows the annotations defined on the `GET /pet` operation:
-#### PetStoreResource.getPets()
+### PetStoreResource.getPets()
```java
@RestGet(
@@ -26,7 +26,7 @@ public Collection getPets() throws NotAcceptable {
Methods marked as deprecated will show up as deprecated in the Swagger UI:
s
-#### PetStoreResource.findPetsByTag()
+### PetStoreResource.findPetsByTag()
```java
@RestGet(
diff --git a/pages/topics/10.29.07.SwaggerParameters.md b/pages/topics/10.29.07.SwaggerParameters.md
index 66e18ccc7a..281706b155 100644
--- a/pages/topics/10.29.07.SwaggerParameters.md
+++ b/pages/topics/10.29.07.SwaggerParameters.md
@@ -53,7 +53,7 @@ Another option is to specify your parameter information in the `parameters` anno
In the case of the `PetStoreResource.getPets()` method, we pull this information from a static field defined in the <a href="/site/apidocs/org/apache/juneau/rest/server/converter/Queryable.html" target="_blank">Queryable</a> class:
-#### PetStoreResource.getPets()
+### PetStoreResource.getPets()
```java
@RestGet(
@@ -73,7 +73,7 @@ public Collection getPets() throws NotAcceptable {
}
```
-#### Queryable
+### Queryable
```java
public class Queryable implements RestConverter {
diff --git a/pages/topics/10.29.09.SwaggerModels.md b/pages/topics/10.29.09.SwaggerModels.md
index f85ac0241e..654a68e32a 100644
--- a/pages/topics/10.29.09.SwaggerModels.md
+++ b/pages/topics/10.29.09.SwaggerModels.md
@@ -28,11 +28,11 @@ public static JsonSchemaGenerator jsonSchemaGenerator(JsonSchemaGenerator.Builde
In the Swagger UI, this causes bean definitions to show up in the Models section at the bottom of the page:
-#### Models section
+### Models section
-#### Models section with Order bean expanded
+### Models section with Order bean expanded
diff --git a/pages/topics/10.31.04.HtmlPredefinedWidgets.md b/pages/topics/10.31.04.HtmlPredefinedWidgets.md
index 7b3e5fd0fa..1a8a042ab2 100644
--- a/pages/topics/10.31.04.HtmlPredefinedWidgets.md
+++ b/pages/topics/10.31.04.HtmlPredefinedWidgets.md
@@ -10,7 +10,7 @@ The <a href="/site/apidocs/org/apache/juneau/rest/server/widget/package-summary.
<node-1><javac-class><a href="/site/apidocs/org/apache/juneau/rest/server/widget/Widget.html" target="_blank">Widget</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/rest/server/widget/MenuItemWidget.html" target="_blank">MenuItemWidget</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/rest/server/widget/ContentTypeMenuItem.html" target="_blank">ContentTypeMenuItem</a></javac-class> <javac-class><a href="/site/apidocs/org/apache/juneau/rest/se [...]
</tree>
-#### MenuItemWidget
+### MenuItemWidget
<a href="/site/apidocs/org/apache/juneau/rest/server/widget/MenuItemWidget.html" target="_blank">MenuItemWidget</a> is an abstract class for rendering menu
items with drop-downs.
@@ -41,7 +41,7 @@ public Div getContent() {
The HTML content returned by the <a href="/site/apidocs/org/apache/juneau/rest/server/widget/MenuItemWidget.html#getHtml(org.apache.juneau.rest.server.RestRequest,org.apache.juneau.rest.server.RestResponse)" target="_blank">getHtml(RestRequest,RestResponse)</a> method is added where the `$W{...}` is referenced in the page.
-#### ContentTypeMenuItem
+### ContentTypeMenuItem
<a href="/site/apidocs/org/apache/juneau/rest/server/widget/ContentTypeMenuItem.html" target="_blank">ContentTypeMenuItem</a> is a predefined <a href="/site/apidocs/org/apache/juneau/rest/server/widget/Widget.html" target="_blank">Widget</a> that
returns back a list of hyperlinks for rendering the contents of a page in a variety of content types.
@@ -72,7 +72,7 @@ It renders the following popup-box:
-#### QueryMenuItem
+### QueryMenuItem
<a href="/site/apidocs/org/apache/juneau/rest/server/widget/QueryMenuItem.html" target="_blank">QueryMenuItem</a> is a predefined <a href="/site/apidocs/org/apache/juneau/rest/server/widget/Widget.html" target="_blank">Widget</a> that returns a
menu-item drop-down form for entering search/view/sort arguments.
@@ -117,7 +117,7 @@ When submitted, the form submits a GET request against the current URI with spec
The <a href="/site/apidocs/org/apache/juneau/rest/server/converter/Queryable.html" target="_blank">Queryable</a> class knows how to perform these filters
against `collections` of POJOs.
-#### ThemeMenuItem
+### ThemeMenuItem
<a href="/site/apidocs/org/apache/juneau/rest/server/widget/ThemeMenuItem.html" target="_blank">ThemeMenuItem</a> is a predefined <a href="/site/apidocs/org/apache/juneau/rest/server/widget/Widget.html" target="_blank">Widget</a> that returns back
a list of hyperlinks for rendering the contents of a page in the various default styles.
@@ -144,7 +144,7 @@ rendering all other supported content types in plain text:
public Collection getPets() {
```
-#### PoweredByJuneau
+### PoweredByJuneau
<a href="/site/apidocs/org/apache/juneau/rest/server/widget/PoweredByJuneau.html" target="_blank">PoweredByJuneau</a> is a predefined <a href="/site/apidocs/org/apache/juneau/rest/server/widget/Widget.html" target="_blank">Widget</a> that places a
powered-by-Juneau message on a page.
@@ -166,7 +166,7 @@ It renders the following image:
-#### Tooltip
+### Tooltip
<a href="/site/apidocs/org/apache/juneau/rest/server/widget/Tooltip.html" target="_blank">Tooltip</a> is a predefined template for adding tooltips to HTML5
bean constructs, typically in menu item widgets.
diff --git a/pages/topics/10.32.LoggingAndDebugging.md b/pages/topics/10.32.LoggingAndDebugging.md
index d9a4849fe7..791b39711e 100644
--- a/pages/topics/10.32.LoggingAndDebugging.md
+++ b/pages/topics/10.32.LoggingAndDebugging.md
@@ -76,13 +76,13 @@ HTTP calls can be logged with the following levels of granularity:
The following examples show the output format for each detail type:
-#### STATUS_LINE
+### STATUS_LINE
```text
WARNING: [500] HTTP POST /foo?foo=bar
```
-#### HEADER
+### HEADER
```text
WARNING:
@@ -100,7 +100,7 @@ WARNING:
=== END ===================================================================
```
-#### ENTITY
+### ENTITY
```text
WARNING:
diff --git a/pages/topics/10.36.RestServerRateLimitAndRequestId.md b/pages/topics/10.36.RestServerRateLimitAndRequestId.md
index bf9ba89858..28fa883dcc 100644
--- a/pages/topics/10.36.RestServerRateLimitAndRequestId.md
+++ b/pages/topics/10.36.RestServerRateLimitAndRequestId.md
@@ -148,7 +148,7 @@ Use this hook for metrics (`statsd`, `micrometer`), structured logging, or pushi
The method is `default` returning `Map.of()`, which makes the addition **purely additive and binary-compatible**: external storage backends (Redis-backed, DynamoDB-backed, JDBC-backed, …) that don't enumerate buckets cheaply keep compiling unchanged and inherit the empty-map default. The bundled in-memory storage overrides `snapshot()` to walk its `ConcurrentHashMap<String,Bucket>` and emit one `BucketState` per entry.
-#### `BucketState` record
+### `BucketState` record
Each entry in the returned map is a <a href="/site/apidocs/org/apache/juneau/rest/server/guard/RateLimitGuard.BucketState.html" target="_blank">`BucketState`</a> record describing a single per-key bucket:
@@ -164,7 +164,7 @@ Vocabulary is intentionally token-bucket-shaped: the underlying model is continu
The `lastRequest` field is wall-clock-accurate because each `Bucket` carries a `lastWallMillis` field updated alongside the existing monotonic `System.nanoTime()` value. The 8-byte-per-bucket overhead is trivial (~800 KB worst-case at the default 100k-key cap) and avoids the drift you'd get from mapping a `nanoTime` delta back to wall-clock under JVM suspension or container pause.
-#### `RateLimitGuard` accessors
+### `RateLimitGuard` accessors
For programmatic access — operator dashboards, custom admin endpoints, integration tests — `RateLimitGuard` exposes the configured state plus a snapshot convenience:
@@ -191,13 +191,13 @@ for (var b : live.values())
log.warn("client {} is throttled (last seen {})", b.key(), b.lastRequest());
```
-#### Consistency contract
+### Consistency contract
Each per-bucket read inside `InMemoryStorage.snapshot()` is consistent (the `Bucket` accessors are `synchronized` on the bucket monitor), but the snapshot as a whole is **not** a global point-in-time consistent view — the iterator walks `ConcurrentHashMap` weakly-consistent entries, and concurrent `tryAcquire(...)` calls on other buckets may interleave with the walk. This is the right trade-off for operator visibility: contention-free under load, accurate per-key, and inconsistent only i [...]
The returned `Map` is immutable (`Map.copyOf(...)`); callers can safely pass it across threads.
-#### `/admin/ratelimit` endpoint
+### `/admin/ratelimit` endpoint
The Juneau ops/introspection mixin pack ships [`BasicAdminResource`](/docs/topics/OpsIntrospectionMixins#basicadminresource), whose `/admin/ratelimit` endpoint already exposes `snapshot()` over HTTP for every registered `RateLimitGuard` bean — alongside the enriched `config` block (`class`, `limit`, `permitsPerSecond`, `xForwardedForAware`, `exemptPaths`). See the [`BasicAdminResource` section](/docs/topics/OpsIntrospectionMixins#basicadminresource) of the ops-pack page for the full JSON [...]
diff --git a/pages/topics/10.37.RestServerTestBeanInjection.md b/pages/topics/10.37.RestServerTestBeanInjection.md
index d37a3da3b1..ffcc3023fd 100644
--- a/pages/topics/10.37.RestServerTestBeanInjection.md
+++ b/pages/topics/10.37.RestServerTestBeanInjection.md
@@ -3,11 +3,11 @@ title: "Test-time Bean Injection"
slug: RestServerTestBeanInjection
---
-`juneau-junit5` provides a small JUnit 5 extension for swapping production beans with test doubles (mocks/fakes) inside a Juneau `BeanStore` for the duration of a JUnit 5 test — without modifying production code and without proxying. It's the Juneau-flavored answer to Spring's `@TestConfiguration` / `@MockBean`.
+The `juneau-test` module provides a small JUnit 5 extension for swapping production beans with test doubles (mocks/fakes) inside a Juneau `BeanStore` for the duration of a JUnit 5 test — without modifying production code and without proxying. It's the Juneau-flavored answer to Spring's `@TestConfiguration` / `@MockBean`.
The mechanism rests on three pieces:
-- A new module — [`juneau-junit5`](https://search.maven.org/artifact/org.apache.juneau/juneau-junit5) — containing the JUnit 5 extension and a `@TestBean` annotation.
+- The [`juneau-test`](https://search.maven.org/artifact/org.apache.juneau/juneau-test) module — containing the JUnit 5 extension and a `@TestBean` annotation.
- A small overlay-builder, `TestBeanStore`, that wraps the existing `BasicBeanStore` overriding-parent slot.
- A consistent `overridingBeanStore(BeanStore)` setter convention (the `BeanStoreOverridable<B>` marker interface) on the four user-facing builders that Juneau apps construct: `MockRestClient.Builder`, `Microservice.Builder`, `SerializerSet.Builder`, `ParserSet.Builder`, and `EncoderSet.Builder`.
@@ -261,8 +261,8 @@ This split is the v1 ship; revisit Mode OVERLAY for `MockRestClient` if a concre
- [REST Server — Conditional-GET / ETag Helpers](/docs/topics/RestServerConditionalGet)
- [REST Server — Rate-Limiting and Request-Id Propagation](/docs/topics/RestServerRateLimitAndRequestId)
- Apache Juneau Javadoc:
- - [`JuneauBeanStoreExtension`](/site/apidocs/org/apache/juneau/junit5/JuneauBeanStoreExtension.html)
- - [`TestBean`](/site/apidocs/org/apache/juneau/junit5/TestBean.html)
- - [`TestBeanStore`](/site/apidocs/org/apache/juneau/junit5/TestBeanStore.html)
+ - [`JuneauBeanStoreExtension`](/site/apidocs/org/apache/juneau/test/junit/JuneauBeanStoreExtension.html)
+ - [`TestBean`](/site/apidocs/org/apache/juneau/test/junit/TestBean.html)
+ - [`TestBeanStore`](/site/apidocs/org/apache/juneau/test/junit/TestBeanStore.html)
- [`BeanStoreOverridable`](/site/apidocs/org/apache/juneau/commons/inject/BeanStoreOverridable.html)
- [`Snapshot`](/site/apidocs/org/apache/juneau/commons/inject/Snapshot.html)
diff --git a/pages/topics/10.48.SessionOptions.md b/pages/topics/10.48.SessionOptions.md
index 201b380ca0..2702a676a5 100644
--- a/pages/topics/10.48.SessionOptions.md
+++ b/pages/topics/10.48.SessionOptions.md
@@ -72,7 +72,7 @@ RestClient client = RestClient.create()
.build();
```
-#### Via HTTP Headers (JSON5 format)
+### Via HTTP Headers (JSON5 format)
```java
// Builder-level (applies to all requests)
@@ -94,7 +94,7 @@ client.get("/mybean")
.getContent().as(MyBean.class);
```
-#### Via Query Parameters (UON format)
+### Via Query Parameters (UON format)
```java
// Builder-level (applies to all requests via default query params)
@@ -110,7 +110,7 @@ client.get("/mybean")
.getContent().as(MyBean.class);
```
-#### Parser Options
+### Parser Options
```java
// Parser options work the same way
diff --git a/pages/topics/10.53.RestRpc.md b/pages/topics/10.53.RestRpc.md
index 994d3cb7f9..6e656b8a9e 100644
--- a/pages/topics/10.53.RestRpc.md
+++ b/pages/topics/10.53.RestRpc.md
@@ -11,7 +11,7 @@ This is not to be confused with REST Proxies which are entirely client-side driv
against arbitrary backend REST interfaces.
:::
-#### Remote Interfaces
+### Remote Interfaces
The following example shows a remote interface:
@@ -48,7 +48,7 @@ The requirements for a remote interface method are:
Throwables with public no-arg or single-arg-string constructors are automatically recreated on the client side when
thrown on the server side.
-#### Client side
+### Client side
Remote Interface proxies are instantiated on the client side using one of the following methods:
@@ -114,7 +114,7 @@ Note that the body of the request is an array.
This array contains the serialized arguments of the method.
The object returned by the method is then serialized as the body of the response.
-#### Server side
+### Server side
There are two ways to expose remote interfaces on the server side:
@@ -127,7 +127,7 @@ through pure REST calls.
This can also aid significantly in debugging, since calls to the remote interface service can be made directly from a
browser with no coding involved.
-#### RrpcServlet
+### RrpcServlet
The <a href="/site/apidocs/org/apache/juneau/rest/server/remote/RrpcServlet.html" target="_blank">RrpcServlet</a> class is a simple specialized servlet
with an abstract `getServiceMap()` method to define the server-side POJOs:
@@ -155,7 +155,7 @@ public class SampleRrpcServlet extends RrpcServlet {
}
```
-#### @RestOp(method=RRPC)
+### @RestOp(method=RRPC)
The <a href="/site/apidocs/org/apache/juneau/rest/server/RestOp.html" target="_blank">@RestOp(method=RRPC)</a> approach is easier if you only have a single interface you want to expose.
You simply define a Java method whose return type is an interface, and return the implementation of that interface:
@@ -168,7 +168,7 @@ public IAddressBook getProxy() {
}
```
-#### RrpcServlet in a browser
+### RrpcServlet in a browser
If you point your browser to the servlet above, you get a list of available interfaces:
@@ -180,7 +180,7 @@ Clicking the hyperlinks on each shows you the list of methods that can be invoke
Note that the `IAddressBook` link shows that you can only invoke methods defined on that interface, whereas the
`AddressBook` link shows ALL public methods defined on that class.
-#### IAddressBook
+### IAddressBook
@@ -190,7 +190,7 @@ http://localhost:10000/remote/org.apache.juneau.examples.addressbook.IAddressBoo
Since `AddressBook` extends from `LinkedList`, you may notice familiar `collections` framework methods listed.
-#### AddressBook
+### AddressBook
@@ -287,6 +287,6 @@ Therefore, UON is preferred.
The hyperlinks on the method names above lead you to a simple form-entry page where you can test passing parameters in
UON notation as URL-encoded form posts.
-#### Sample form entry page
+### Sample form entry page
-#### Sample form entry page results
+### Sample form entry page results
diff --git a/pages/topics/10.55.UtilityBeans.md b/pages/topics/10.55.UtilityBeans.md
index b315bc8657..7d47eaf253 100644
--- a/pages/topics/10.55.UtilityBeans.md
+++ b/pages/topics/10.55.UtilityBeans.md
@@ -11,7 +11,7 @@ beans are used.
The resource class is hosted in the example REST applications rendered below:
-#### ResourceDescriptions
+### ResourceDescriptions
The <a href="/site/apidocs/org/apache/juneau/examples/rest/UtilityBeansResource.html#getChildDescriptions()" target="_blank">getChildDescriptions()</a> method shows an example of rendering a list of descriptive links for child endpoints.
@@ -26,15 +26,15 @@ public ResourceDescriptions getChildDescriptions() {
}
```
-#### HTML representation
+### HTML representation
-#### JSON representation
+### JSON representation
-#### BeanDescription
+### BeanDescription
The <a href="/site/apidocs/org/apache/juneau/examples/rest/UtilityBeansResource.html#aBeanDescription()" target="_blank">aBeanDescription()</a>
method shows an example of rendering simple schema information about an arbitrary bean class.
@@ -53,15 +53,15 @@ public BeanDescription aBeanDescription() {
}
```
-#### HTML representation
+### HTML representation
-#### JSON representation
+### JSON representation
-#### Hyperlink
+### Hyperlink
The <a href="/site/apidocs/org/apache/juneau/examples/rest/UtilityBeansResource.html#aHyperlink()" target="_blank">aHyperlink()</a> method shows an
example of rendering a simple hyperlink.
@@ -80,15 +80,15 @@ public Hyperlink aHyperlink() {
}
```
-#### HTML representation
+### HTML representation
-#### JSON representation
+### JSON representation
-#### SeeOtherRoot
+### SeeOtherRoot
The <a href="/site/apidocs/org/apache/juneau/examples/rest/UtilityBeansResource.html#aSeeOtherRoot()" target="_blank">aSeeOtherRoot()</a> method
shows an example of sending a `303 See Other` with a `Location` header pointing to the servlet root.
diff --git a/pages/topics/10.58.Log4j.md b/pages/topics/10.58.Log4j.md
index 570cd1489e..29f03880da 100644
--- a/pages/topics/10.58.Log4j.md
+++ b/pages/topics/10.58.Log4j.md
@@ -7,13 +7,13 @@ The REST API uses Java logging by default.
If you wish to use LOG4J logging, you simple need to add the following to your JVM arguments and maven dependencies:
-#### Command-line argument
+### Command-line argument
```text
-Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager
```
-#### Maven dependency
+### Maven dependency
```xml
<dependency>
diff --git a/pages/topics/12.01.JuneauRestServerSpringbootBasics.md b/pages/topics/12.01.JuneauRestServerSpringbootBasics.md
index caf4bf032f..a2ca67707d 100644
--- a/pages/topics/12.01.JuneauRestServerSpringbootBasics.md
+++ b/pages/topics/12.01.JuneauRestServerSpringbootBasics.md
@@ -3,7 +3,7 @@ title: "juneau-rest-server-springboot Basics"
slug: JuneauRestServerSpringbootBasics
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
@@ -13,24 +13,24 @@ slug: JuneauRestServerSpringbootBasics
</dependency>
```
-#### Java Library
+### Java Library
```text
juneau-rest-server-springboot-0.0.0.jar
```
-#### OSGi Module
+### OSGi Module
```text
org.apache.juneau.rest.server.springboot_0.0.0.jar
```
-#### Contents/Features
+### Contents/Features
The `juneau-rest-server-springboot` library provides classes to make it easy to integrate Juneau REST resources with
Spring and Spring Boot.
-#### Bean Precedence
+### Bean Precedence
When a Juneau REST resource runs inside a Spring Boot application, framework-managed beans on `RestContext`
(`CallLogger`, `EncoderSet`, `SerializerSet`, `ParserSet`, `ThrownStore`, `Config`, `VarResolver`,
diff --git a/pages/topics/13.01.JuneauRestClientBasics.md b/pages/topics/13.01.JuneauRestClientBasics.md
index 9a4ddaf555..d6d436dd17 100644
--- a/pages/topics/13.01.JuneauRestClientBasics.md
+++ b/pages/topics/13.01.JuneauRestClientBasics.md
@@ -3,7 +3,7 @@ title: "juneau-rest-client Basics"
slug: JuneauRestClientBasics
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
@@ -13,19 +13,19 @@ slug: JuneauRestClientBasics
</dependency>
```
-#### Java Library
+### Java Library
```text
juneau-rest-client-0.0.0.jar
```
-#### OSGi Module
+### OSGi Module
```text
org.apache.juneau.rest.client_0.0.0.jar
```
-#### Contents/Features
+### Contents/Features
Built upon the feature-rich Apache HttpClient library, the Juneau RestClient API adds support for fluent-style REST
calls and the ability to perform marshalling of POJOs to and from HTTP parts.
@@ -122,7 +122,7 @@ The root URL can also be inspected after the client is built using
String rootUrl = client.getRootUrl(); // "http://localhost:10000"
```
-#### Dynamic Root URL
+### Dynamic Root URL
The <a href="/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html#rootUrl(java.util.function.Supplier)" target="_blank">RestClient.Builder.rootUrl(Supplier<String>)</a>
overload allows the root URL to be computed dynamically at request time.
@@ -209,7 +209,7 @@ String content = client.get(URI).run().getContent().asString();
int status = client.get(URI).complete().getStatusCode();
```
-#### Resource Management with Try-With-Resources
+### Resource Management with Try-With-Resources
Both <a href="/site/apidocs/org/apache/juneau/rest/client/RestRequest.html" target="_blank">RestRequest</a> and
<a href="/site/apidocs/org/apache/juneau/rest/client/RestResponse.html" target="_blank">RestResponse</a> implement
diff --git a/pages/topics/13.06.ResponseHeaders.md b/pages/topics/13.06.ResponseHeaders.md
index c5701c7a1b..5a79b9264b 100644
--- a/pages/topics/13.06.ResponseHeaders.md
+++ b/pages/topics/13.06.ResponseHeaders.md
@@ -74,10 +74,10 @@ Assertion methods are also provided for fluent-style calls:
<tree>
<node-0><java-class><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseHeader.html" target="_blank">ResponseHeader</a></java-class></node-0>
-<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseHeader.html#assertString()" target="_blank">assertString()</a></java-method> → <a href="/site/apidocs/org/apache/juneau/assertions/FluentStringAssertion.html" target="_blank">FluentStringAssertion</a></node-1>
-<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseHeader.html#assertInteger()" target="_blank">assertInteger()</a></java-method> → <a href="/site/apidocs/org/apache/juneau/assertions/FluentIntegerAssertion.html" target="_blank">FluentIntegerAssertion</a></node-1>
-<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseHeader.html#assertLong()" target="_blank">assertLong()</a></java-method> → <a href="/site/apidocs/org/apache/juneau/assertions/FluentLongAssertion.html" target="_blank">FluentLongAssertion</a></node-1>
-<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseHeader.html#assertZonedDateTime()" target="_blank">assertZonedDateTime()</a></java-method> → <a href="/site/apidocs/org/apache/juneau/assertions/FluentZonedDateTimeAssertion.html" target="_blank">FluentZonedDateTimeAssertion</a></node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseHeader.html#assertString()" target="_blank">assertString()</a></java-method> → <a href="/site/apidocs/org/apache/juneau/test/assertions/FluentStringAssertion.html" target="_blank">FluentStringAssertion</a></node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseHeader.html#assertInteger()" target="_blank">assertInteger()</a></java-method> → <a href="/site/apidocs/org/apache/juneau/test/assertions/FluentIntegerAssertion.html" target="_blank">FluentIntegerAssertion</a></node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseHeader.html#assertLong()" target="_blank">assertLong()</a></java-method> → <a href="/site/apidocs/org/apache/juneau/test/assertions/FluentLongAssertion.html" target="_blank">FluentLongAssertion</a></node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseHeader.html#assertZonedDateTime()" target="_blank">assertZonedDateTime()</a></java-method> → <a href="/site/apidocs/org/apache/juneau/test/assertions/FluentZonedDateTimeAssertion.html" target="_blank">FluentZonedDateTimeAssertion</a></node-1>
</tree>
Note how in the following example, the fluent assertion returns control to the <a href="/site/apidocs/org/apache/juneau/rest/client/RestResponse.html" target="_blank">RestResponse</a> object after
diff --git a/pages/topics/13.07.ResponseContent.md b/pages/topics/13.07.ResponseContent.md
index a67f9e8193..78a75b0a93 100644
--- a/pages/topics/13.07.ResponseContent.md
+++ b/pages/topics/13.07.ResponseContent.md
@@ -92,10 +92,10 @@ Assertion methods are also provided for fluent-style calls:
<tree>
<node-0><java-class><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseContent.html" target="_blank">ResponseContent</a></java-class></node-0>
-<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseContent.html#assertString()" target="_blank">assertString()</a></java-method> → <a href="/site/apidocs/org/apache/juneau/assertions/FluentStringAssertion.html" target="_blank">FluentStringAssertion</a></node-1>
-<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseContent.html#assertBytes()" target="_blank">assertBytes()</a></java-method> → <a href="/site/apidocs/org/apache/juneau/assertions/FluentByteArrayAssertion.html" target="_blank">FluentByteArrayAssertion</a></node-1>
-<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseContent.html#assertObject(java.lang.Class)" target="_blank">assertObject(Class)</a></java-method> → <a href="/site/apidocs/org/apache/juneau/assertions/FluentObjectAssertion.html" target="_blank">FluentObjectAssertion</a></node-1>
-<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseContent.html#assertObject(java.lang.Class)" target="_blank">assertObject(Type,Type...)</a></java-method> → <a href="/site/apidocs/org/apache/juneau/assertions/FluentObjectAssertion.html" target="_blank">FluentObjectAssertion</a></node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseContent.html#assertString()" target="_blank">assertString()</a></java-method> → <a href="/site/apidocs/org/apache/juneau/test/assertions/FluentStringAssertion.html" target="_blank">FluentStringAssertion</a></node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseContent.html#assertBytes()" target="_blank">assertBytes()</a></java-method> → <a href="/site/apidocs/org/apache/juneau/test/assertions/FluentByteArrayAssertion.html" target="_blank">FluentByteArrayAssertion</a></node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseContent.html#assertObject(java.lang.Class)" target="_blank">assertObject(Class)</a></java-method> → <a href="/site/apidocs/org/apache/juneau/test/assertions/FluentObjectAssertion.html" target="_blank">FluentObjectAssertion</a></node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/rest/client/ResponseContent.html#assertObject(java.lang.Class)" target="_blank">assertObject(Type,Type...)</a></java-method> → <a href="/site/apidocs/org/apache/juneau/test/assertions/FluentObjectAssertion.html" target="_blank">FluentObjectAssertion</a></node-1>
</tree>
:::tip Example
diff --git a/pages/topics/13.10.02.Remote.md b/pages/topics/13.10.02.Remote.md
index 4cc7c3a188..f617c8fbe3 100644
--- a/pages/topics/13.10.02.Remote.md
+++ b/pages/topics/13.10.02.Remote.md
@@ -13,7 +13,7 @@ identify it as a REST proxy interface.
The @Remote annotation is optional but often included for code readability.
-#### @Remote(path)
+### @Remote(path)
The <a href="/site/apidocs/org/apache/juneau/http/remote/Remote.html#path()" target="_blank">@Remote(path)</a> annotation is used to define the HTTP
path of the REST service.
@@ -80,7 +80,7 @@ PetStore store = client.getRemote(PetStore.class);
```
:::
-#### @Remote(headers/headerList)
+### @Remote(headers/headerList)
The <a href="/site/apidocs/org/apache/juneau/http/remote/Remote.html#headers()" target="_blank">@Remote(headers)</a> and <a href="/site/apidocs/org/apache/juneau/http/remote/Remote.html#headerList()" target="_blank">@Remote(headerList)</a> annotations are used to add headers on all requests.
@@ -105,7 +105,7 @@ public class MyHeaderList extends HeaderList {
```
:::
-#### @Remote(version/versionHeader)
+### @Remote(version/versionHeader)
The <a href="/site/apidocs/org/apache/juneau/http/remote/Remote.html#version()" target="_blank">@Remote(version)</a> and <a href="/site/apidocs/org/apache/juneau/http/remote/Remote.html#versionHeader()" target="_blank">@Remote(versionHeader)</a> annotations are used to specify the client-side version of this interface that can be used on the server side to perform version-specific handling.
diff --git a/pages/topics/13.10.03.RemoteMethod.md b/pages/topics/13.10.03.RemoteMethod.md
index bc718c14f7..75d36c2e81 100644
--- a/pages/topics/13.10.03.RemoteMethod.md
+++ b/pages/topics/13.10.03.RemoteMethod.md
@@ -23,7 +23,7 @@ Specialized sub-annotations are provided for common HTTP methods:
<node-0><java-annotation><a href="/site/apidocs/org/apache/juneau/http/remote/RemoteDelete.html" target="_blank">RemoteDelete</a></java-annotation></node-0>
</tree>
-#### @RemoteOp(method/path)
+### @RemoteOp(method/path)
The HTTP method and path are mapped to a Java method using the `method` and `path` annotations.
@@ -41,7 +41,7 @@ public interface PetStore {
The Java method name can be anything.
-#### Inferred method/path
+### Inferred method/path
In such cases, `method` and `path` annotations are optional if you follow certain naming conventions on your method that
identify the method and path.
@@ -81,7 +81,7 @@ do(?i)(get|put|post|delete|options|head|connect|trace|patch)
| `doFoo()` | `[default]` | `/doFoo` |
:::
-#### @RemoteOp(returns)
+### @RemoteOp(returns)
The return type of the Java methods can be any of the following:
diff --git a/pages/topics/14.01.JuneauRestMockBasics.md b/pages/topics/14.01.JuneauRestMockBasics.md
index a62f8b280f..93ddbfcc6c 100644
--- a/pages/topics/14.01.JuneauRestMockBasics.md
+++ b/pages/topics/14.01.JuneauRestMockBasics.md
@@ -3,7 +3,7 @@ title: "juneau-rest-mock Basics"
slug: JuneauRestMockBasics
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
@@ -13,19 +13,19 @@ slug: JuneauRestMockBasics
</dependency>
```
-#### Java Library
+### Java Library
```text
juneau-rest-mock-0.0.0.jar
```
-#### OSGi Module
+### OSGi Module
```text
org.apache.juneau.rest.mock_0.0.0.jar
```
-#### Contents/Features
+### Contents/Features
The `juneau-rest-mock` module contains convenience APIs for performing serverless unit testing of your REST APIs.
Each of the APIs provide the ability to fully test your server and client REST interfaces without the need for a running
diff --git a/pages/topics/15.00.MicroserviceOverview.md b/pages/topics/15.00.MicroserviceOverview.md
new file mode 100644
index 0000000000..c7f65671c8
--- /dev/null
+++ b/pages/topics/15.00.MicroserviceOverview.md
@@ -0,0 +1,265 @@
+---
+title: "Microservice Overview"
+slug: MicroserviceOverview
+---
+
+# Microservice Support
+
+Juneau microservices are **self-contained, deployable REST servers** built on top of the Juneau REST
+server framework. A microservice packages your REST resources, configuration, and an embedded HTTP container
+into a single executable jar (or WAR) that you can start with a plain `java -jar` command.
+
+The microservice layer builds on top of the full Juneau stack:
+
+<tree>
+<node-0>Juneau Microservice Stack</node-0>
+<node-1>juneau-microservice — core lifecycle, config, console, inject bootstrap</node-1>
+<node-1>juneau-rest-server — @Rest / @RestOp REST engine (serialization, routing, guards, …)</node-1>
+<node-1>juneau-marshall — multi-format POJO marshalling (JSON, XML, HTML, YAML, …)</node-1>
+<node-1>Deployment target (one of Jetty / Tomcat / Spring Boot)</node-1>
+</tree>
+
+---
+
+## Deployment Targets
+
+Juneau provides three independently-releasable deployment adapters. All three share the same
+`Microservice` + `@Configuration` + `@Bean Servlet` programming model and the same lifecycle contracts.
+
+| Module | When to use |
+|---|---|
+| [juneau-microservice-jetty](/docs/topics/JuneauMicroserviceJettyBasics) | Default choice for standalone runnable jars. Ships a zero-config `JettyMicroservice.run(args, servlet)` one-liner and a classpath-driven `jetty.xml` knob for advanced connector tuning. |
+| [juneau-microservice-tomcat](/docs/topics/JuneauMicroserviceTomcatBasics) | Drop-in alternative when your organisation standardises on Tomcat, or when you want to share `[Tomcat]` config between an embedded dev launcher and a full Tomcat deployment. |
+| [juneau-rest-server-springboot](/docs/topics/JuneauRestServerSpringbootBasics) | Integration point for Spring Boot applications. REST resources extend `BasicSpringRestServlet` / `BasicSpringRestServletGroup` so Spring `@Autowired` injection and `@Bean` resolution flow through the Spring application context instead of the Juneau bean store. |
+
+All three adapters depend on [juneau-microservice](/docs/topics/JuneauMicroserviceBasics) for the core
+lifecycle engine and on [juneau-rest-server](/docs/topics/JuneauRestServerBasics) for the REST framework
+itself.
+
+---
+
+## Lifecycle
+
+Every Juneau microservice follows a builder → configure → start → join/stop lifecycle.
+
+<tree>
+<node-0><java-class><a href="/site/apidocs/org/apache/juneau/microservice/Microservice.html" target="_blank">Microservice</a></java-class></node-0>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/microservice/Microservice.html#create()" target="_blank">Microservice.create()</a></java-method> — obtain a fluent builder</node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html#args(java.lang.String[])" target="_blank">builder.args(args)</a></java-method> — pass CLI arguments</node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html#configurations(java.lang.Class[])" target="_blank">builder.configurations(…)</a></java-method> — register <c>@Configuration</c> classes (adds the HTTP container)</node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html#build()" target="_blank">builder.build()</a></java-method> — construct the <c>Microservice</c> instance</node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/microservice/Microservice.html#start()" target="_blank">start()</a></java-method> — start all <c>MicroserviceListener</c>s (including the HTTP container)</node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/microservice/Microservice.html#startConsole()" target="_blank">startConsole()</a></java-method> — (optional) launch interactive stdin console</node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/microservice/Microservice.html#join()" target="_blank">join()</a></java-method> — block the calling thread until <c>stop()</c> is called</node-1>
+<node-1><java-method><a href="/site/apidocs/org/apache/juneau/microservice/Microservice.html#stop()" target="_blank">stop()</a></java-method> — stop all listeners in reverse order; close the bean store</node-1>
+</tree>
+
+All methods on `Microservice` return `this`, making it easy to chain the whole bootstrap in one
+fluent expression.
+
+---
+
+## Hello World (Jetty)
+
+The following is the smallest complete Juneau microservice: a single REST resource mounted on an
+embedded Jetty server with automatic JSON/XML/HTML content negotiation.
+
+Add the dependency:
+
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-microservice-jetty</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+Define a REST resource:
+
+```java
+import org.apache.juneau.rest.annotation.*;
+import org.apache.juneau.rest.server.servlet.*;
+
+@Rest(
+ path = "/hello",
+ title = "Hello World"
+)
+public class HelloResource extends BasicRestServlet {
+
+ @RestGet(path = "/*", summary = "Returns a greeting.")
+ public String sayHello() {
+ return "Hello, World!";
+ }
+}
+```
+
+Boot it from `main`:
+
+```java
+import org.apache.juneau.microservice.jetty.*;
+
+public class App {
+ public static void main(String[] args) throws Exception {
+ JettyMicroservice.run(args, new HelloResource()).join();
+ }
+}
+```
+
+`JettyMicroservice.run(args, servlet)` is a convenience facade that wires `JettyConfiguration` into
+the `Microservice` builder, registers the servlet, starts on port `10000` (or as configured in
+`juneau.cfg`), launches the interactive console, and blocks. Point a browser at
+`http://localhost:10000/hello` — the default HTML view renders automatically.
+
+For the Tomcat or Spring Boot equivalents, see the module-specific pages listed in the
+[Deployment Targets](#deployment-targets) section above.
+
+---
+
+## Configuration Files
+
+Every microservice reads its runtime settings from an INI-style `juneau.cfg` file that is resolved
+from the classpath or working directory at startup. Key sections used by the built-in modules:
+
+```ini
+[Microservice]
+# Name and version shown in the console banner.
+name = MyApp
+version = 1.0
+
+[Jetty]
+# Comma-separated list of candidate ports; first available wins. 0 = random.
+port = 8080, 0
+
+[Logging]
+# Root logging level (java.util.logging).
+level = WARNING
+# Log file relative to the working directory.
+logFile = logs/microservice.%g.log
+```
+
+The configuration is exposed as a
+<a href="/site/apidocs/org/apache/juneau/config/Config.html" target="_blank">Config</a>
+object through `Microservice.getConfig()` and is also registered in the
+[bean store](/docs/topics/MicroserviceCoreInject) so `@Bean` factory methods can inject it directly.
+
+### Hot-reload
+
+`Config` supports **file-watch hot-reload** out of the box. When the underlying `juneau.cfg` file
+changes on disk, listeners registered via
+<a href="/site/apidocs/org/apache/juneau/config/Config.html#addListener(org.apache.juneau.config.event.ConfigEventListener)" target="_blank">Config.addListener(…)</a>
+are notified with the full set of changed entries. The microservice uses this to propagate logging
+level changes and port-list updates without a restart.
+
+You can register your own listener from a `@Configuration` class:
+
+```java
+import org.apache.juneau.commons.inject.*;
+import org.apache.juneau.config.*;
+import org.apache.juneau.microservice.*;
+
+@Configuration
+public class AppConfig {
+
+ @Bean
+ MicroserviceListener configWatcher(Config config) {
+ return new BasicMicroserviceListener() {
+ @Override
+ public void onConfigChange(Microservice ms, Config c) {
+ System.out.println("Config changed: " + c.getSectionKeys("MyApp"));
+ }
+ };
+ }
+}
+```
+
+The `onConfigChange` callback fires on the calling thread of the file-store watcher, not the
+request thread, so keep it non-blocking.
+
+---
+
+## Built-in Management Resources
+
+The Jetty and Tomcat launchers expose several built-in REST endpoints under the root path when
+management mixins are enabled. These are opt-in: add the appropriate mixin to your root
+`@Rest` resource.
+
+| Endpoint | Mixin / feature | Description |
+|---|---|---|
+| `GET /healthz` | [Health Probes](/docs/topics/HealthProbes) | Aggregated health/liveness check. Returns `200 OK` or `503 Service Unavailable`. |
+| `GET /readyz` | [Health Probes](/docs/topics/HealthProbes) | Readiness probe, used by Kubernetes load-balancer pre-stop hooks. |
+| `GET /livez` | [Health Probes](/docs/topics/HealthProbes) | Liveness probe for pod restart decisions. |
+| `GET /actuator` | [Management Surface](/docs/topics/ManagementSurface) | Actuator-style endpoint listing all available management sub-paths. |
+| `GET /api` | Auto-generated via [Swagger / OpenAPI](/docs/topics/SwaggerBasics) | Swagger 2.x JSON schema; `OPTIONS` on any resource returns an inline schema. |
+| `GET /stats` | [Execution Statistics](/docs/topics/ExecutionStatistics) | Per-operation call counts, error rates, and latency percentiles. |
+
+The management surface is implemented via the standard Juneau
+[mixin pack](/docs/topics/RestServerComposition) mechanism — there are no special microservice APIs.
+The same mixins work in a plain servlet container too.
+
+---
+
+## Bean Store and Inject Bootstrap
+
+`Microservice` owns an internal
+<a href="/site/apidocs/org/apache/juneau/commons/inject/WritableBeanStore.html" target="_blank">WritableBeanStore</a>
+populated from every `@Configuration` class registered on the builder. This makes it easy for
+companion modules — such as `JettyConfiguration` and `TomcatConfiguration` — to contribute lifecycle
+components and for user code to wire in application services without subclassing.
+
+```java
+@Configuration
+public class AppConfig {
+
+ @Bean
+ Servlet rootResources() { return new RootResources(); } // auto-mounted by JettyConfiguration
+
+ @Bean
+ MyService myService() { return new MyService(); } // available to other @Bean methods
+}
+
+public class App {
+ public static void main(String[] args) throws Exception {
+ Microservice.create()
+ .args(args)
+ .configurations(JettyConfiguration.class, AppConfig.class)
+ .build()
+ .start()
+ .startConsole()
+ .join();
+ }
+}
+```
+
+`JettyConfiguration` walks the bean store at startup, finds every `@Bean` whose declared return type
+is `Servlet` and whose runtime class carries `@Rest`, and mounts it at the path declared in
+`@Rest(path = "...")`. `TomcatConfiguration` follows an identical contract.
+
+See [Inject-Aware Microservice](/docs/topics/MicroserviceCoreInject) for a complete reference on
+resolution priority, `@PostConstruct` / `@PreDestroy` callbacks, and external bean store integration.
+
+---
+
+## Starter Projects
+
+Apache Juneau provides three minimal **clone-and-go starter projects** — one per deployment target —
+that demonstrate a `HelloResource`, content negotiation, a Swagger/OPTIONS page, `@Path`/`@Query`
+binding, a YAML config file, and a `MockRestClient` test:
+
+| Starter | Deployment | Links |
+|---|---|---|
+| Jetty | Embedded Jetty, runnable jar | [GitHub](https://github.com/jamesbognar/juneau-microservice-jetty-starter) · [Docs](https://jamesbognar.github.io/juneau-microservice-jetty-starter/) |
+| Spring Boot | Spring Boot, runnable jar | [GitHub](https://github.com/jamesbognar/juneau-microservice-springboot-starter) · [Docs](https://jamesbognar.github.io/juneau-microservice-springboot-starter/) |
+| Tomcat | WAR on Tomcat 10+ | [GitHub](https://github.com/jamesbognar/juneau-microservice-tomcat-starter) · [Docs](https://jamesbognar.github.io/juneau-microservice-tomcat-starter/) |
+
+See [Starter Projects](/docs/topics/StarterProjects) for full details.
+
+---
+
+## See Also
+
+- [juneau-microservice](/docs/topics/JuneauMicroserviceBasics) — core microservice module (lifecycle engine, config, console)
+- [juneau-microservice-jetty](/docs/topics/JuneauMicroserviceJettyBasics) — embedded Jetty launcher
+- [juneau-microservice-tomcat](/docs/topics/JuneauMicroserviceTomcatBasics) — embedded Tomcat launcher
+- [juneau-rest-server-springboot](/docs/topics/JuneauRestServerSpringbootBasics) — Spring Boot integration
+- [REST Server](/docs/topics/JuneauRestServerBasics) — the underlying REST server API
+- [Config Files](/docs/topics/JuneauConfigBasics) — full configuration file reference
diff --git a/pages/topics/15.01.JuneauMicroserviceBasics.md b/pages/topics/15.01.JuneauMicroserviceBasics.md
index db1c1863de..ac1e836f80 100644
--- a/pages/topics/15.01.JuneauMicroserviceBasics.md
+++ b/pages/topics/15.01.JuneauMicroserviceBasics.md
@@ -3,7 +3,7 @@ title: "juneau-microservice Basics"
slug: JuneauMicroserviceBasics
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
@@ -13,19 +13,19 @@ slug: JuneauMicroserviceBasics
</dependency>
```
-#### Java Library
+### Java Library
```text
juneau-microservice-0.0.0.jar
```
-#### OSGi Module
+### OSGi Module
```text
org.apache.juneau.microservice_0.0.0.jar
```
-#### Contents/Features
+### Contents/Features
Juneau Microservice is an API for creating stand-alone executable jars with automatic support for Juneau configurations
and console commands.
@@ -37,7 +37,7 @@ Features include:
- Simple-to-use APIs for accessing manifest file entries, command-line arguments, and external configuration file properties.
- A bean-store-aware inject-style bootstrap (`@Configuration` + `@Bean`) that lets companion modules — such as `juneau-microservice-jetty` — contribute servers, listeners, and servlets through standard `@Bean` definitions, rather than via subclassing.
-#### Module Name (Renamed in 9.5)
+### Module Name (Renamed in 9.5)
In 9.5 this module was renamed from `juneau-microservice-core` to `juneau-microservice`. The Java package
(`org.apache.juneau.microservice`) is unchanged. See the [V9.5 Migration Guide](/docs/release-notes/9.5.0) for the
diff --git a/pages/topics/16.01.JuneauMicroserviceJettyBasics.md b/pages/topics/16.01.JuneauMicroserviceJettyBasics.md
index b2a08eabd9..372f229a4f 100644
--- a/pages/topics/16.01.JuneauMicroserviceJettyBasics.md
+++ b/pages/topics/16.01.JuneauMicroserviceJettyBasics.md
@@ -3,7 +3,7 @@ title: "juneau-microservice-jetty Basics"
slug: JuneauMicroserviceJettyBasics
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
@@ -13,19 +13,19 @@ slug: JuneauMicroserviceJettyBasics
</dependency>
```
-#### Java Library
+### Java Library
```text
juneau-microservice-jetty-0.0.0.jar
```
-#### OSGi Module
+### OSGi Module
```text
org.apache.juneau.microservice.jetty_0.0.0.jar
```
-#### Contents/Features
+### Contents/Features
Juneau Microservice Jetty is an API for creating stand-alone executable jars that can be used to start lightweight
configurable REST interfaces with all the power of the Juneau REST server and client APIs.
diff --git a/pages/topics/16.06.Config.md b/pages/topics/16.06.Config.md
index a5846fc966..2f7c45b441 100644
--- a/pages/topics/16.06.Config.md
+++ b/pages/topics/16.06.Config.md
@@ -78,7 +78,7 @@ Once the configuration is resolved, it is made as the system default configurati
This in turn allows it to be used by REST resources that reference the system default configuration via the
`SYSTEM_DEFAULT` such as those extending <a href="/site/apidocs/org/apache/juneau/rest/server/servlet/BasicRestServlet.html" target="_blank">BasicRestServlet</a> or <a href="/site/apidocs/org/apache/juneau/rest/server/servlet/BasicRestResource.html" target="_blank">BasicRestResource</a>.
-#### BasicRestConfig.java
+### BasicRestConfig.java
```java
@Rest(
diff --git a/pages/topics/16.09.Extending.md b/pages/topics/16.09.Extending.md
index 725c9a5f9f..62529e7153 100644
--- a/pages/topics/16.09.Extending.md
+++ b/pages/topics/16.09.Extending.md
@@ -11,7 +11,7 @@ was introduced to collapse the standard `Microservice` + `JettyConfiguration` bo
into the standard [Microservice](JuneauMicroserviceBasics). Customization is therefore done by **contributing your own
`@Bean` definitions** rather than subclassing.
-#### Hooking into the lifecycle
+### Hooking into the lifecycle
Implement [`MicroserviceListener`](MicroserviceCoreListeners) and expose it as a `@Bean` — every
`MicroserviceListener` bean in the store is invoked on `start()` / `stop()` / config-change events
@@ -53,7 +53,7 @@ public class App {
}
```
-#### Overriding Jetty defaults
+### Overriding Jetty defaults
The relevant Jetty hooks are all keyed by **bean type** in the store; user-supplied `@Bean`s win over the
defaults that `JettyConfiguration` contributes.
@@ -65,7 +65,7 @@ defaults that `JettyConfiguration` contributes.
| Ports / `jetty.xml` content / var resolution | `@Bean JettySettings` (use `JettySettings.create().ports(...).jettyXml(...).build()`). |
| Servlet auto-mounts | `@Bean Servlet`s annotated with `@Rest` — mounted at `@Rest(path = "...")`. |
-#### Accessing the Jetty server at runtime
+### Accessing the Jetty server at runtime
```java
JettyServerComponent jetty = Microservice
diff --git a/pages/topics/17.01.JuneauMicroserviceTomcatBasics.md b/pages/topics/17.01.JuneauMicroserviceTomcatBasics.md
index 506cd64ad6..7183b7eab5 100644
--- a/pages/topics/17.01.JuneauMicroserviceTomcatBasics.md
+++ b/pages/topics/17.01.JuneauMicroserviceTomcatBasics.md
@@ -3,7 +3,7 @@ title: "juneau-microservice-tomcat Basics"
slug: JuneauMicroserviceTomcatBasics
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
@@ -13,19 +13,19 @@ slug: JuneauMicroserviceTomcatBasics
</dependency>
```
-#### Java Library
+### Java Library
```text
juneau-microservice-tomcat-0.0.0.jar
```
-#### OSGi Module
+### OSGi Module
```text
org.apache.juneau.microservice.tomcat_0.0.0.jar
```
-#### Contents/Features
+### Contents/Features
`juneau-microservice-tomcat` is a Tomcat-embedded microservice launcher that mirrors the developer experience of
[juneau-microservice-jetty](/docs/topics/JuneauMicroserviceJettyBasics) but runs Juneau REST resources inside an
diff --git a/pages/topics/18.02.ScServerOverview.md b/pages/topics/18.02.ScServerOverview.md
index c74bf84720..f8840203ad 100644
--- a/pages/topics/18.02.ScServerOverview.md
+++ b/pages/topics/18.02.ScServerOverview.md
@@ -3,7 +3,7 @@ title: "juneau-sc-server"
slug: ScServerOverview
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
@@ -13,13 +13,13 @@ slug: ScServerOverview
</dependency>
```
-#### Java Library
+### Java Library
```text
juneau-sc-server-0.0.0.jar
```
-#### Contents/Features
+### Contents/Features
`juneau-sc-server` is the server component of the [juneau-sc](/docs/topics/JuneauScOverview) configuration
server. It is a **standalone Juneau microservice** built on `juneau-microservice-jetty` that:
diff --git a/pages/topics/18.03.ScClientOverview.md b/pages/topics/18.03.ScClientOverview.md
index 235e1557cf..2a31ab395e 100644
--- a/pages/topics/18.03.ScClientOverview.md
+++ b/pages/topics/18.03.ScClientOverview.md
@@ -3,7 +3,7 @@ title: "juneau-sc-client"
slug: ScClientOverview
---
-#### Maven Dependency
+### Maven Dependency
```xml
<dependency>
@@ -13,7 +13,7 @@ slug: ScClientOverview
</dependency>
```
-#### Java Library
+### Java Library
```text
juneau-sc-client-0.0.0.jar
diff --git a/pages/topics/20.01.JuneauExamplesCore.md b/pages/topics/20.01.JuneauExamplesCore.md
index c6b4c6c4aa..b4618913d4 100644
--- a/pages/topics/20.01.JuneauExamplesCore.md
+++ b/pages/topics/20.01.JuneauExamplesCore.md
@@ -34,7 +34,7 @@ To use the examples in this module, add the following dependency to your project
Juneau provides comprehensive JSON support out of the box, allowing you to read and write JSON structures into POJOs with minimal configuration.
-#### [JsonSimpleExample.java](https://github.com/apache/juneau/blob/master/juneau-examples/juneau-examples-core/src/main/java/org/apache/juneau/examples/core/json/JsonSimpleExample.java)
+### [JsonSimpleExample.java](https://github.com/apache/juneau/blob/master/juneau-examples/juneau-examples-core/src/main/java/org/apache/juneau/examples/core/json/JsonSimpleExample.java)
Demonstrates basic usage of <a href="/site/apidocs/org/apache/juneau/marshall/json/JsonSerializer.html" target="_blank">JsonSerializer</a> and <a href="/site/apidocs/org/apache/juneau/marshall/json/JsonParser.html" target="_blank">JsonParser</a> to convert POJOs to JSON strings and back to POJOs.
**Key Features:**
@@ -43,7 +43,7 @@ Demonstrates basic usage of <a href="/site/apidocs/org/apache/juneau/marshall/js
- Automatic type inference
- Null handling
-#### [JsonConfigurationExample.java](https://github.com/apache/juneau/blob/master/juneau-examples/juneau-examples-core/src/main/java/org/apache/juneau/examples/core/json/JsonConfigurationExample.java)
+### [JsonConfigurationExample.java](https://github.com/apache/juneau/blob/master/juneau-examples/juneau-examples-core/src/main/java/org/apache/juneau/examples/core/json/JsonConfigurationExample.java)
Shows how to create <a href="/site/apidocs/org/apache/juneau/marshall/json/JsonParser.html" target="_blank">JsonParser</a> and <a href="/site/apidocs/org/apache/juneau/marshall/json/JsonSerializer.html" target="_blank">JsonSerializer</a> instances with custom configuration properties.
**Key Features:**
@@ -56,7 +56,7 @@ Shows how to create <a href="/site/apidocs/org/apache/juneau/marshall/json/JsonP
Juneau's XML support enables seamless conversion between POJOs and XML structures.
-#### [XmlComplexExample.java](https://github.com/apache/juneau/blob/master/juneau-examples/juneau-examples-core/src/main/java/org/apache/juneau/examples/core/xml/XmlComplexExample.java)
+### [XmlComplexExample.java](https://github.com/apache/juneau/blob/master/juneau-examples/juneau-examples-core/src/main/java/org/apache/juneau/examples/core/xml/XmlComplexExample.java)
Demonstrates how to use <a href="/site/apidocs/org/apache/juneau/marshall/xml/XmlSerializer.html" target="_blank">XmlSerializer</a> and <a href="/site/apidocs/org/apache/juneau/marshall/xml/XmlParser.html" target="_blank">XmlParser</a> to handle complex POJOs with nested objects and collections.
**Key Features:**
@@ -69,7 +69,7 @@ Demonstrates how to use <a href="/site/apidocs/org/apache/juneau/marshall/xml/Xm
For RDF support, Juneau integrates with Apache Jena to provide RDF serialization capabilities.
-#### Prerequisites
+### Prerequisites
Add Apache Jena to your classpath:
```xml
@@ -80,7 +80,7 @@ Add Apache Jena to your classpath:
</dependency>
```
-#### RDF Support
+### RDF Support
RDF serialization support is available through the `juneau-marshall-rdf` module. While there isn't a dedicated example file, RDF functionality can be demonstrated using the existing serializers with RDF-specific configurations.
**Key Features:**
diff --git a/pages/topics/21.02.JuneauShadedCore.md b/pages/topics/21.02.JuneauShadedCore.md
index db3cd34717..b4221f6bed 100644
--- a/pages/topics/21.02.JuneauShadedCore.md
+++ b/pages/topics/21.02.JuneauShadedCore.md
@@ -10,8 +10,6 @@ The `juneau-shaded-core` artifact bundles all core Juneau modules for general ma
This artifact includes the following Juneau modules:
- **juneau-commons** - Core utilities and common classes
-- **juneau-assertions** - Fluent-style assertions API
-- **juneau-bct** - Bean-Centric Testing framework
- **juneau-config** - Configuration file API
- **juneau-marshall** - Serializers and parsers (JSON, XML, HTML, MessagePack, etc.)
@@ -119,26 +117,6 @@ public class ConfigExample {
}
```
-### Bean-Centric Testing
-
-```java
-import static org.apache.juneau.junit.bct.BctAssertions.*;
-
-public class BctExample {
- @Test
- public void testPerson() {
- Person person = new Person("John", 42);
-
- assertBean(person)
- .is("name", "John")
- .is("age", 42);
-
- assertBean(person).asJson()
- .is("{name:'John',age:42}");
- }
-}
-```
-
## Performance Characteristics
- **Serialization**: Fast, memory-efficient
diff --git a/pages/topics/21.06.JuneauShadedAll.md b/pages/topics/21.06.JuneauShadedAll.md
index 4565fea456..3c196191bd 100644
--- a/pages/topics/21.06.JuneauShadedAll.md
+++ b/pages/topics/21.06.JuneauShadedAll.md
@@ -11,8 +11,6 @@ This artifact includes **everything**:
### Core Modules
- **juneau-commons** - Core utilities
-- **juneau-assertions** - Fluent assertions API
-- **juneau-bct** - Bean-Centric Testing framework
- **juneau-config** - Configuration file API
- **juneau-marshall** - All serializers/parsers (JSON, XML, HTML, MessagePack, etc.)
@@ -238,33 +236,25 @@ public class ProductResource extends SpringRestServlet {
## Example: Testing with All Features
```java
-import static org.apache.juneau.junit.bct.BctAssertions.*;
+import static org.junit.jupiter.api.Assertions.*;
import org.apache.juneau.rest.mock.*;
@Test
public void testCompleteWorkflow() throws Exception {
- // Bean testing
User user = new User("John", "john@example.com");
- assertBean(user)
- .is("name", "John")
- .is("email", "john@example.com");
-
- // Serialization testing
- assertBean(user).asJson()
- .is("{name:'John',email:'john@example.com'}");
-
+
// REST API testing
MockRestClient client = MockRestClient.create(MyApi.class)
.json()
.build();
-
+
User created = client.post("/users")
.content(user)
.run()
.assertStatus().is(201)
.getContent().as(User.class);
-
- assertBean(created).is("name", "John");
+
+ assertEquals("John", created.getName());
}
```
diff --git a/pages/topics/22.02.MarshallingSecurity.md b/pages/topics/22.02.MarshallingSecurity.md
index 382f579cde..d109f17f13 100644
--- a/pages/topics/22.02.MarshallingSecurity.md
+++ b/pages/topics/22.02.MarshallingSecurity.md
@@ -3,7 +3,7 @@ title: "Marshalling Security"
slug: MarshallingSecurity
---
-#### Demarshalling vulnerabilities
+### Demarshalling vulnerabilities
One common security vulnerability is the ability to create arbitrary Java object instances through crafted user input.
@@ -54,7 +54,7 @@ public class MyInsecureSwap extends ObjectSwap {
All other parsers (JSON, URL-Encoding, MessagePack, etc...) work the same way in determining POJO types, so should be
safe from demarshalling vulnerabilities.
-#### Dependent libraries
+### Dependent libraries
When accessing security vulnerabilities of any library, dependent libraries must also be taken into account:
diff --git a/pages/topics/22.05.ContentSecurityPolicy.md b/pages/topics/22.05.ContentSecurityPolicy.md
index bfec2ab665..092dd991ee 100644
--- a/pages/topics/22.05.ContentSecurityPolicy.md
+++ b/pages/topics/22.05.ContentSecurityPolicy.md
@@ -18,7 +18,7 @@ Both live in `juneau-rest-common` alongside the other modern HTTP header beans.
CSP is **off by default**. Turning a policy on silently would break existing apps, so you must opt in.
:::
-#### Building a policy
+### Building a policy
The builder exposes typed setters for the common directives plus a generic `directive(name, sources...)` escape hatch
so new directives never require an API change. Source-expression keywords are exposed as constants (`SELF`, `NONE`,
@@ -43,7 +43,7 @@ String value = ContentSecurityPolicy.create()
Setting the same directive twice **replaces** its source list (while preserving its original position), and a directive
with no sources renders as a bare keyword (e.g. `directive("upgrade-insecure-requests")`).
-#### Emitting the header
+### Emitting the header
Because <a href="/site/apidocs/org/apache/juneau/http/header/ContentSecurityPolicy.html" target="_blank">ContentSecurityPolicy</a>
is an ordinary string header, it flows through the existing response-header path. The simplest opt-in is the static
@@ -80,7 +80,7 @@ public class MyResource extends BasicRestServlet {
`toHeader()` returns a `ContentSecurityPolicy` whose name is `Content-Security-Policy` (or
`Content-Security-Policy-Report-Only` when report-only mode is enabled).
-#### Report-only mode
+### Report-only mode
Operators can deploy a policy in observe-only mode first, watch violations, tune, then enforce. `reportOnly()` flips
the header name to `Content-Security-Policy-Report-Only`; the `reportUri(...)` / `reportTo(...)` directives point a
@@ -96,7 +96,7 @@ ContentSecurityPolicy csp = ContentSecurityPolicy.create()
// Header name => "Content-Security-Policy-Report-Only"
```
-#### The strict-starter preset
+### The strict-starter preset
`strictStarter()` returns a builder pre-populated with a ready, nonce-based baseline:
@@ -119,7 +119,7 @@ Do not combine a nonce with `'unsafe-inline'` in `script-src` — browsers ignor
hash) is present. The strict starter deliberately omits `'unsafe-inline'`.
:::
-#### See also
+### See also
- <a href="/site/apidocs/org/apache/juneau/http/header/ContentSecurityPolicy.html" target="_blank">ContentSecurityPolicy</a>
- <a href="/site/apidocs/org/apache/juneau/http/header/ContentSecurityPolicy.Builder.html" target="_blank">ContentSecurityPolicy.Builder</a>
diff --git a/sidebars.ts b/sidebars.ts
index 8c6698fadb..935aac2729 100644
--- a/sidebars.ts
+++ b/sidebars.ts
@@ -34,68 +34,79 @@ const sidebars: SidebarsConfig = {
label: 'Documentation',
collapsed: false,
items: [
- {
- type: 'category',
- label: '1. Juneau Ecosystem',
- collapsed: false,
- items: [
- {
- type: 'doc',
- id: 'topics/01.01.JuneauEcosystemOverview',
- label: '1.1. Juneau Ecosystem Overview',
- },
- {
- type: 'doc',
- id: 'topics/01.02.Marshalling',
- label: '1.2. Marshalling',
- },
- {
- type: 'doc',
- id: 'topics/01.03.EndToEndRest',
- label: '1.3. End-to-End REST',
- },
- {
- type: 'doc',
- id: 'topics/01.04.RestServer',
- label: '1.4. REST Server',
- },
- {
- type: 'doc',
- id: 'topics/01.05.RestClient',
- label: '1.5. REST Client',
- },
- {
- type: 'doc',
- id: 'topics/01.06.DtoBeans',
- label: '1.6. DTO Beans',
- },
- {
- type: 'doc',
- id: 'topics/01.07.ConfigFiles',
- label: '1.7. Config Files',
- },
- {
- type: 'doc',
- id: 'topics/01.08.FluentAssertions',
- label: '1.8. Fluent Assertions',
- },
- {
- type: 'doc',
- id: 'topics/01.09.GeneralDesign',
- label: '1.9. General Design',
- },
- {
- type: 'doc',
- id: 'topics/01.10.FrameworkComparisons',
- label: '1.10. Framework Comparisons',
- },
- {
- type: 'doc',
- id: 'topics/01.11.WhyJuneau',
- label: '1.11. Why Choose Juneau?',
- },
- ],
- },
+ {
+ type: 'category',
+ label: '1. Juneau Ecosystem',
+ collapsed: false,
+ link: { type: 'doc', id: 'topics/01.01.JuneauEcosystemOverview' },
+ items: [
+ {
+ type: 'doc',
+ id: 'topics/01.01.01.Commons',
+ label: '1.1. Commons',
+ },
+ {
+ type: 'doc',
+ id: 'topics/01.02.Marshalling',
+ label: '1.2. Marshalling',
+ },
+ {
+ type: 'doc',
+ id: 'topics/01.02.01.SimpleVariableLanguage',
+ label: '1.3. Simple Variable Language',
+ },
+ {
+ type: 'doc',
+ id: 'topics/01.02.02.BeanContextOverview',
+ label: '1.4. Bean Context',
+ },
+ {
+ type: 'doc',
+ id: 'topics/01.03.EndToEndRest',
+ label: '1.5. End-to-End REST',
+ },
+ {
+ type: 'doc',
+ id: 'topics/01.04.RestServer',
+ label: '1.6. REST Server',
+ },
+ {
+ type: 'doc',
+ id: 'topics/01.05.RestClient',
+ label: '1.7. REST Client',
+ },
+ {
+ type: 'doc',
+ id: 'topics/01.06.DtoBeans',
+ label: '1.8. DTO Beans',
+ },
+ {
+ type: 'doc',
+ id: 'topics/01.07.ConfigFiles',
+ label: '1.9. Config Files',
+ },
+ {
+ type: 'doc',
+ id: 'topics/01.08.FluentAssertions',
+ label: '1.10. Fluent Assertions',
+ },
+ {
+ type: 'doc',
+ id: 'topics/01.09.GeneralDesign',
+ label: '1.11. General Design',
+ },
+ {
+ type: 'doc',
+ id: 'topics/01.10.FrameworkComparisons',
+ label: '1.12. Framework Comparisons',
+ },
+ {
+ type: 'doc',
+ id: 'topics/01.11.WhyJuneau',
+ label: '1.13. Why Choose Juneau?',
+ },
+ ],
+ },
{
type: 'category',
label: '2. juneau-marshall',
@@ -1155,68 +1166,73 @@ const sidebars: SidebarsConfig = {
},
{
type: 'category',
- label: '7. juneau-assertions',
+ label: '7. juneau-test',
collapsed: true,
items: [
{
type: 'doc',
id: 'topics/07.01.JuneauAssertionBasics',
- label: '7.1. juneau-assertions Basics',
+ label: '7.1. juneau-test Basics',
},
{
type: 'doc',
id: 'topics/07.02.AssertionsOverview',
label: '7.2. Assertions Overview',
},
- ],
- },
- {
- type: 'category',
- label: '8. juneau-bct',
- collapsed: true,
- items: [
- {
- type: 'doc',
- id: 'topics/08.01.JuneauBctBasics',
- label: '8.1. juneau-bct Basics',
- },
- {
- type: 'doc',
- id: 'topics/08.02.CustomErrorMessages',
- label: '8.2. Custom Error Messages',
- },
{
type: 'category',
- label: '8.3. Customization',
+ label: '7.3. Bean-Centric Testing',
collapsed: true,
items: [
{
type: 'doc',
- id: 'topics/08.03.01.Customization',
- label: '8.3.1. Customization',
- },
- {
- type: 'doc',
- id: 'topics/08.03.02.Stringifiers',
- label: '8.3.2. Stringifiers',
- },
- {
- type: 'doc',
- id: 'topics/08.03.03.Listifiers',
- label: '8.3.3. Listifiers',
- },
- {
- type: 'doc',
- id: 'topics/08.03.04.Swappers',
- label: '8.3.4. Swappers',
- },
- {
- type: 'doc',
- id: 'topics/08.03.05.PropertyExtractors',
- label: '8.3.5. Property Extractors',
+ id: 'topics/08.01.JuneauBctBasics',
+ label: '7.3.1. Bean-Centric Testing Basics',
+ },
+ {
+ type: 'doc',
+ id: 'topics/08.02.CustomErrorMessages',
+ label: '7.3.2. Custom Error Messages',
+ },
+ {
+ type: 'category',
+ label: '7.3.3. Customization',
+ collapsed: true,
+ items: [
+ {
+ type: 'doc',
+ id: 'topics/08.03.01.Customization',
+ label: '7.3.3.1. Customization',
+ },
+ {
+ type: 'doc',
+ id: 'topics/08.03.02.Stringifiers',
+ label: '7.3.3.2. Stringifiers',
+ },
+ {
+ type: 'doc',
+ id: 'topics/08.03.03.Listifiers',
+ label: '7.3.3.3. Listifiers',
+ },
+ {
+ type: 'doc',
+ id: 'topics/08.03.04.Swappers',
+ label: '7.3.3.4. Swappers',
+ },
+ {
+ type: 'doc',
+ id: 'topics/08.03.05.PropertyExtractors',
+ label: '7.3.3.5. Property Extractors',
+ },
+ ],
},
],
},
+ {
+ type: 'doc',
+ id: 'topics/08.04.JuneauTestJUnitExtensions',
+ label: '7.4. JUnit Extensions',
+ },
],
},
{
@@ -2042,16 +2058,21 @@ const sidebars: SidebarsConfig = {
},
],
},
- {
- type: 'category',
- label: '15. juneau-microservice',
- collapsed: true,
- items: [
- {
- type: 'doc',
- id: 'topics/15.01.JuneauMicroserviceBasics',
- label: '15.1. juneau-microservice Basics',
- },
+ {
+ type: 'category',
+ label: '15. juneau-microservice',
+ collapsed: true,
+ items: [
+ {
+ type: 'doc',
+ id: 'topics/15.00.MicroserviceOverview',
+ label: '15.0. Microservice Overview',
+ },
+ {
+ type: 'doc',
+ id: 'topics/15.01.JuneauMicroserviceBasics',
+ label: '15.1. juneau-microservice Basics',
+ },
{
type: 'doc',
id: 'topics/15.02.MicroserviceCoreOverview',
diff --git a/src/pages/about.md b/src/pages/about.md
index 3b55f8f4bf..be01be8555 100644
--- a/src/pages/about.md
+++ b/src/pages/about.md
@@ -15,7 +15,7 @@ Juneau excels in the following scenarios:
* **Microservice development with production-focused building blocks** - Start quickly with `juneau-microservice` and deploy on Jetty or Tomcat while reusing REST APIs, auth filters (JWT, SAML, OAuth/OIDC), reactive endpoints, observability hooks (Micrometer/OpenTelemetry), and configuration APIs across services
* **Using one ecosystem across service, client, and DTO layers** - Keep service contracts and model objects aligned with reusable DTO modules (OpenAPI, JSON Schema, RFC 7807, MCP, Atom/HAL/JSON:API) and transport adapters for Apache HttpClient 4.5/5.x, OkHttp, or Jetty clients
* **Universal Java marshalling** - The framework handles the full breadth of Java language features automatically during marshalling — beans, generics, collections, enums, records, optionals, and more — and is extensible via swaps and surrogate classes so that virtually any Java artifact can be serialized and deserialized
-* **Bean-Centric Testing and fluent-style assertions** - Write compact, expressive unit tests that are considerably smaller than equivalent JUnit-alone tests; juneau-bct and juneau-assertions provide deep bean-aware assertions and fluent validation chains that eliminate boilerplate while improving readability
+* **Bean-Centric Testing and fluent-style assertions** - Write compact, expressive unit tests that are considerably smaller than equivalent JUnit-alone tests; juneau-test provides deep bean-aware assertions and fluent validation chains that eliminate boilerplate while improving readability
* **Content negotiation and HTTP/2 support** - Handle multiple content types automatically with modern HTTP features
## When to Choose Juneau
@@ -35,8 +35,7 @@ The Juneau ecosystem consists of the following parts:
| [juneau-marshall](/docs/topics/JuneauMarshallBasics) | POJO marshalling for 25+ wire formats — JSON/JSON5/JSONL/JCS, XML/SOAP, HTML, YAML/TOML/HOCON/HJSON/INI, CBOR/BSON/MessagePack, Protobuf/Prototext, UON/URL-encoding, CSV, Parquet, Markdown, SSE, OpenAPI, and PlainText — plus a token-streaming API; no external dependencies required. |
| [juneau-marshall-rdf](/docs/topics/JuneauMarshallRdfOverview) | Extended marshalling support for RDF/XML, N3, N-Triple, N-Quads, Turtle, TriG, TriX, JSON-LD, RDF/JSON, RDF/Proto, and RDF/Thrift (requires Apache Jena). |
| [juneau-config](/docs/topics/JuneauConfigBasics) | Multi-format (INI and YAML) configuration file API with POJO support, variable resolution, and real-time file watching. |
-| [juneau-assertions](/docs/topics/JuneauAssertionBasics) | Fluent assertion API for readable, expressive unit test validations. |
-| [juneau-bct](/docs/topics/JuneauBctBasics) | Bean-Centric Testing framework that extends JUnit with streamlined assertion methods for Java objects. |
+| [juneau-test](/docs/topics/JuneauAssertionBasics) | Fluent assertions, Bean-Centric Testing, and JUnit 5 extensions for readable, expressive unit tests. |
| **juneau-bean** | |
| [juneau-bean-atom](/docs/topics/JuneauBeanAtom) | DTOs for the Atom Syndication Format (RFC 4287). |
| [juneau-bean-common](/docs/topics/JuneauBeanCommon) | Shared DTO base classes and utilities used across juneau-bean modules. |
diff --git a/src/pages/downloads.md b/src/pages/downloads.md
index 7653bdb1e1..ab670d24df 100644
--- a/src/pages/downloads.md
+++ b/src/pages/downloads.md
@@ -68,8 +68,7 @@
<!-- ...but can also be any of the following... -->
<!-- Core modules -->
-<artifactId>juneau-assertions</artifactId>
-<artifactId>juneau-bct</artifactId>
+<artifactId>juneau-test</artifactId>
<artifactId>juneau-commons</artifactId>
<artifactId>juneau-config</artifactId>
<artifactId>juneau-marshall</artifactId>
diff --git a/static/ai/juneau-knowledge.jsonl b/static/ai/juneau-knowledge.jsonl
index feee001bc1..84dd98afba 100644
--- a/static/ai/juneau-knowledge.jsonl
+++ b/static/ai/juneau-knowledge.jsonl
@@ -14,7 +14,7 @@
{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:650bc860a2c3", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/RestPatch.java", "source_type": "api-metadata", "summary": "RestPatch exposes summary/su metadata fields for concise AI-or [...]
{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:7e1bb7a3a947", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/RestPost.java", "source_type": "api-metadata", "summary": "RestPost exposes summary/su metadata fields for concise AI-orie [...]
{"description": "Detected summary()/su() annotation attributes used by Juneau schema and HTTP metadata annotations. These fields provide short descriptions intended for compact AI/LLM consumption.", "id": "api-metadata:8b1ffe4e4b64", "module": "api-metadata", "related_ids": [], "source_path": "juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/RestPut.java", "source_type": "api-metadata", "summary": "RestPut exposes summary/su metadata fields for concise AI-orient [...]
-{"description": "# Release 10.0.0\n\n**Date:** TBD\n\nJuneau 10.0.0 is a major version release representing a significant milestone for the Apache Juneau project. This release continues the feature work introduced in 9.5.0 while also delivering a broad code-quality and maintainability uplift via an extensive SonarQube/SonarLint cleanup pass across the entire codebase.\n\n### Major version bump note\n\nThis is the first release in the 10.x line. The jump from 9.x to 10.0 reflects accumula [...]
+{"description": "# Release 10.0.0\n\n**Date:** TBD\n\nJuneau 10.0.0 is a major version release representing a significant milestone for the Apache Juneau project. This release continues the feature work introduced in 9.5.0 while also delivering a broad code-quality and maintainability uplift via an extensive SonarQube/SonarLint cleanup pass across the entire codebase.\n\n### Major version bump note\n\nThis is the first release in the 10.x line. The jump from 9.x to 10.0 reflects accumula [...]
{"description": "# Release 5.0.0.0\n\n**Date:** Jun 11, 2012\n\nVersion 5.0 marks a major release milestone for the Juno/JJSON library. \n\nIt is now available for download from iRAM under the name \"Juno (previously JJSON)\". \n\nThe Juno Starters Guide has been updated to reflect new functionality in this release.\n\n- New name. Unfortunately, \"JJSON\" was already trademarked by another similar library. Therefore, it's been renamed \"Juno\" (after the Roman goddess and wife of Jupit [...]
{"description": "# Release 5.0.0.1\n\n**Date:** Jun 14, 2012\n\nJuno 5.0.0.1 is a moderate update.\n\n- New support for generating XML-Schema documents from POJO models.\n\n- New support for serializing to RDF/XML.", "id": "release-note:907dd2e70994", "module": "release-notes", "related_ids": [], "source_path": "pages/release-notes/5.0.0.01.md", "source_type": "release-note", "summary": "**Date:** Jun 14, 2012", "tags": ["release-note", "release-notes"], "title": "Release 5.0.0.1", "upda [...]
{"description": "# Release 5.0.0.2\n\n**Date:** Sept 28, 2012\n\nJuno 5.0.0.2 is a minor update.\n\n- Improvements to Javadocs.\n Most of the information in the Juno Starters Guide wiki has been moved into the overview and package-level javadocs.\n Since the information is now written in HTML, you can now copy and paste the code examples directly from the\n Javadocs.\n The code examples are also syntax-highlighted using CSS.\n\n- Support for defining default XML namespaces on package [...]
@@ -99,19 +99,22 @@
{"description": "# Release 9.1.0\n\n**Date:** June 19, 2025\n\nJuneau 9.1.0 is a major compatibility update focused on Jakarta EE migration and Spring Boot modernization.\n\n## Major Changes\n\n### Jakarta EE Migration\n\n- **Complete javax to jakarta namespace migration**: All references to `javax.*` packages have been converted to their corresponding `jakarta.*` equivalents.\n This includes:\n - `javax.servlet.*` \u2192 `jakarta.servlet.*`\n - `javax.validation.*` \u2192 `jakarta.va [...]
{"description": "# Release 9.2.0\n\n**Date:** 01/05/2026\n\nJuneau 9.2.0 is a minor release focused on enhancements and bug fixes.\n\nMajor changes include:\n\n- **Hjson (Human JSON) Support**: New native serializer and parser for Hjson format with quoteless strings, multiline strings, comments, and optional commas \u2014 ideal for configuration files and hand-edited data\n- **New Module**: Introduced `juneau-shaded` with five shaded (uber) JAR artifacts for simplified dependency managem [...]
{"description": "# Release 9.5.0\n\n**Date:** TBD\n\nJuneau 9.5.0 is a minor release with native OpenAPI 3.1 emission (alongside Swagger v2, composed via the new four-class `org.apache.juneau.rest.docs` mixin pack \u2014 `SwaggerMixin` / `SwaggerUiMixin` / `OpenApiMixin` / `RedocMixin` \u2014 that replaces the previously-considered `apiFormat` string knob), native TOML and YAML support, BSON (Binary JSON) support for MongoDB-interoperable binary serialization, CBOR (Concise Binary Object [...]
-{"description": "#### About\n\nApache Juneau\u2122 is a single cohesive Java ecosystem for marshalling Java objects to a wide variety of language types and \ncreating annotation-based REST end-to-end server and client APIs.\n\n#### Ecosystem\n\nThe Juneau ecosystem consists of the following parts:\n\n| Category | Maven Artifacts | Description | Prerequisites |\n|----------|------------------|-------------|---------------|\n| **juneau-core** | [juneau\u2011commons](/docs/topics/JuneauComm [...]
-{"description": "The [juneau-marshall](/docs/topics/JuneauMarshallBasics) library includes easy-to-use and highly customizable serializers and parsers based around a common\nAPI.\nIt allows you to marshall Java POJOs directly to and from a wide variety of language types without the need for\nintermediate Document Object Models making them extremely efficient.\n\nSupported languages include: \n\n- JSON\n- XML\n- HTML\n- UON\n- URL-Encoding\n- MessagePack\n- OpenAPI\n- SOAP/XML\n- CSV\n- Y [...]
+{"description": "# Commons\n\nThe [juneau-commons](/docs/topics/JuneauCommonsBasics) module is the foundational layer of the Juneau ecosystem.\nIt has no framework dependencies \u2014 just Java \u2014 and provides the low-level utilities, collections, I/O helpers,\nreflection tools, settings management, and dependency-injection support that all other Juneau modules build on top of.\nBecause every other Juneau module depends on it transitively, its classes are always on the classpath when [...]
+{"description": "### About\n\nApache Juneau\u2122 is a single cohesive Java ecosystem for marshalling Java objects to a wide variety of language types and \ncreating annotation-based REST end-to-end server and client APIs.\n\n### Ecosystem\n\nThe Juneau ecosystem consists of the following parts:\n\n| Maven Artifacts | Description | Prerequisites |\n|-----------------|-------------|---------------|\n| **juneau-core** | | |\n| [juneau\u2011commons](/docs/topics/JuneauCommonsBasics) | Commo [...]
+{"description": "# Simple Variable Language\n\nThe <a href=\"/site/apidocs/org/apache/juneau/commons/svl/package-summary.html\" target=\"_blank\">org.apache.juneau.commons.svl</a> package defines an API for a language called \"Simple Variable\nLanguage\" (SVL) \u2014 text that contains variables of the form `$varName{varKey}`.\nVariables can be recursively nested and can return values that themselves contain more variables.\n\n`VarResolver.DEFAULT` ships the following built-in source var [...]
+{"description": "# Bean Context\n\nThe **Bean Context** (BCT \u2014 _Bean Context Type_) is Juneau's core bean-introspection framework.\nIt provides a unified, highly configurable view of Java beans that all serializers, parsers, and\nother framework components share.\n\nEvery marshaller in Juneau extends `MarshallingContext`, which means a single set of bean-modeling\nsettings controls how beans are discovered, read, and written across all formats \u2014 JSON, XML, YAML,\nCSV, MessagePa [...]
+{"description": "The [juneau-marshall](/docs/topics/JuneauMarshallBasics) library includes easy-to-use and highly customizable serializers and parsers based around a common\nAPI.\nIt allows you to marshall Java POJOs directly to and from a wide variety of language types without the need for\nintermediate Document Object Models making them extremely efficient.\n\nSupported languages include:\n\n<div>\n <a href=\"/docs/topics/JsonBasics\"><span className=\"badge badge--secondary margin--x [...]
{"description": "The [juneau-rest-server](/docs/topics/JuneauRestServerBasics) and [juneau-rest-client](/docs/topics/JuneauRestClientBasics) libraries provide server and client side REST capabilities that can be\nused by themselves, or together to create simplified yet sophisticated Java-based REST communications layers that\ncompletely hide away the complexities of the REST protocol.\n\nA typical pattern is to define a REST API on the server side:\n\n```java\n@Rest(path=\"/petstore\")\n [...]
-{"description": "#### `@Rest`-Annotated Resources\n\nA REST resource is simply a Java class annotated with <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html\" target=\"_blank\">Rest</a>.\nThe most common case is a class that extends <a href=\"/site/apidocs/org/apache/juneau/rest/server/servlet/BasicRestServlet.html\" target=\"_blank\">BasicRestServlet</a>, which itself is simply an extension of <a href=\"https://jakarta.ee/specifications/servlet/6.0/apidocs/jakarta/servlet/ [...]
-{"description": "Juneau ships two REST client stacks:\n\n- The classic `org.apache.juneau.rest.client.classic.RestClient` (HC4.5-based, supports the rich fluent surface shown below) in the `juneau-rest-client-classic` Maven module.\n- The next-generation `org.apache.juneau.rest.client.RestClient` (transport-agnostic, no Apache HttpClient dependency) in the `juneau-rest-client` Maven module \u2014 see [Next-Generation REST Client](/docs/topics/NextGenRestClient).\n\nThe remainder of this [...]
-{"description": "The [juneau-bean](/docs/topics/JuneauBeanBasics) libraries contain several predefined POJOs for generating commonly-used document types that are designed\nto be used with the Juneau Marshaller APIs for both serializing and parsing.\n\n#### HTML5\n\nThe Juneau HTML5 DTO beans are simply beans with fluent-style setters that allow you to quickly construct HTML fragments as\nJava objects.\nThese objects can then be serialized to HTML using one of the existing HTML serializer [...]
+{"description": "### `@Rest`-Annotated Resources\n\nA REST resource is simply a Java class annotated with <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html\" target=\"_blank\">Rest</a>.\nThe most common case is a class that extends <a href=\"/site/apidocs/org/apache/juneau/rest/server/servlet/BasicRestServlet.html\" target=\"_blank\">BasicRestServlet</a>, which itself is simply an extension of <a href=\"https://jakarta.ee/specifications/servlet/6.0/apidocs/jakarta/servlet/h [...]
+{"description": "Juneau ships two REST client stacks:\n\n- The classic `org.apache.juneau.rest.client.classic.RestClient` (HC4.5-based, supports the rich fluent surface shown below) in the `juneau-rest-client-classic` Maven module.\n- The next-generation `org.apache.juneau.rest.client.RestClient` (transport-agnostic, no Apache HttpClient dependency) in the `juneau-rest-client` Maven module \u2014 see [Next-Generation REST Client](/docs/topics/NextGenRestClient).\n\nThe remainder of this [...]
+{"description": "The [juneau-bean](/docs/topics/JuneauBeanBasics) libraries contain several predefined POJOs for generating commonly-used document types that are designed\nto be used with the Juneau Marshaller APIs for both serializing and parsing.\n\n### HTML5\n\nThe Juneau HTML5 DTO beans are simply beans with fluent-style setters that allow you to quickly construct HTML fragments as\nJava objects.\nThese objects can then be serialized to HTML using one of the existing HTML serializers [...]
{"description": "The [juneau-config](/docs/topics/JuneauConfigBasics) library contains a powerful API for creating and using INI-style config files.\n\n:::tip Example configuration file\n```ini\n# A set of entries\n[Section1]\n\n# An integer\nkey1 = 1\n\n# A boolean\nkey2 = true\n\n# An array\nkey3 = 1,2,3\n\n# A POJO\nkey4 = http://bar\n```\n:::\n\nConfig files are accessed through the <a href=\"/site/apidocs/org/apache/juneau/config/Config.html\" target=\"_blank\">Config</a> class whic [...]
-{"description": "The juneau-assertions module in Juneau is a powerful API for performing fluent style assertions.\n\nFluent assertions have two types of methods:\n\n- `asX` methods which perform transformations.\n- `isX` methods which perform assertions.\n\nMultiple transformations and assertions can be performed per statement.\n\n:::tip Examples\n```java\nimport static org.apache.juneau.assertions.Assertions.*;\nimport static org.apache.juneau.assertions.AssertionPredicates.*;\n\n// Che [...]
+{"description": "The juneau-test module in Juneau is a powerful API for performing fluent style assertions.\n\nFluent assertions have two types of methods:\n\n- `asX` methods which perform transformations.\n- `isX` methods which perform assertions.\n\nMultiple transformations and assertions can be performed per statement.\n\n:::tip Examples\n```java\nimport static org.apache.juneau.test.assertions.Assertions.*;\nimport static org.apache.juneau.test.assertions.AssertionPredicates.*;\n\n// [...]
{"description": "The Juneau framework uses the design pattern of builders, context, and session objects:\n\n- Context Builders - Modifiable objects that allow you to define configuration settings for contexts.\n- Contexts - Unmodifiable thread-safe objects meant to be cacheable and reusable.\n- Sessions - Modifiable objects usually meant for one-time use.\n\nThis is a general design pattern used throughout the framework including the REST client and server APIs.\n\nThe following shows th [...]
{"description": "# Framework Comparisons\n\nThis page provides detailed comparisons between Juneau and popular alternatives to help you choose the right tool for your needs.\n\n## Juneau vs Jackson\n\n| Feature | Juneau | Jackson | Winner |\n|---------|--------|---------|--------|\n| **Multi-format support** | JSON, XML, HTML, URL-Encoding, UON, OpenAPI, PlainText, CSV, SOAP, MessagePack, RDF | Primarily JSON (with modules for XML, YAML, etc.) | **Juneau** - Built-in multi-format support [...]
-{"description": "# Why Choose Juneau?\n\nApache Juneau\u2122 offers a unique combination of simplicity, power, and zero-dependency design that makes it an excellent choice for modern Java development. Here's why developers choose Juneau over alternatives.\n\n## The Juneau Advantage\n\n### **Zero Dependencies, Maximum Power**\n\nUnlike other frameworks that require multiple dependencies and complex configurations, Juneau provides comprehensive functionality with minimal external requireme [...]
-{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-marshall</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-marshall-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.marshall_0.0.0.jar\n```\n\n#### Contents/Features\n\n- Foundation for all serializers and parsers.\n- Implementations for all serializers and parsers except RDF lang [...]
-{"description": "<a href=\"/site/apidocs/org/apache/juneau/marshall/marshaller/Marshaller.html\" target=\"_blank\">Marshallers</a> are simple pairings of a <a href=\"/site/apidocs/org/apache/juneau/marshall/serializer/Serializer.html\" target=\"_blank\">Serializer</a> \nand <a href=\"/site/apidocs/org/apache/juneau/marshall/parser/Parser.html\" target=\"_blank\">Parser</a> with convenience methods for serializing and parsing\nPOJOs.\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site [...]
+{"description": "# Why Choose Juneau?\n\nApache Juneau\u2122 offers a unique combination of simplicity, power, and zero-dependency design that makes it an excellent choice for modern Java development. Here's why developers choose Juneau over alternatives.\n\n## The Juneau Advantage\n\n### **Zero Dependencies, Maximum Power**\n\nUnlike other frameworks that require multiple dependencies and complex configurations, Juneau provides comprehensive functionality with minimal external requireme [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-marshall</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-marshall-0.0.0.jar\n```\n\n### OSGi Module\n\n```text\norg.apache.juneau.marshall_0.0.0.jar\n```\n\n### Contents/Features\n\n- Foundation for all serializers and parsers.\n- Implementations for all serializers and parsers except RDF language [...]
+{"description": "<a href=\"/site/apidocs/org/apache/juneau/marshall/marshaller/Marshaller.html\" target=\"_blank\">Marshallers</a> are simple pairings of a <a href=\"/site/apidocs/org/apache/juneau/marshall/serializer/Serializer.html\" target=\"_blank\">Serializer</a> \nand <a href=\"/site/apidocs/org/apache/juneau/marshall/parser/Parser.html\" target=\"_blank\">Parser</a> with convenience methods for serializing and parsing\nPOJOs.\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site [...]
{"description": "One of the goals of Juneau was to make serialization as simple as possible.\nIn a single line of code, you should be able to serialize and parse most POJOs.\n\nDespite this simplicity, Juneau provides lots of extensibility and configuration properties for tailoring how POJOs are\nserialized and parsed.\n\nThe built-in serializers in Juneau are fast, efficient, and highly configurable.\nThey work by serializing POJOs directly to streams instead of using intermediate Docum [...]
{"description": "At the heart of the marshalling APIs is the <a href=\"/site/apidocs/org/apache/juneau/MarshallingContext.html\" target=\"_blank\">Marshalling Context</a> API that\nprovides a common framework for marshalling beans and POJOs across all serializers and parsers.\n\nAll serializers and parsers (and their builders) extend from the marshalling context API classes.\n\nOne important feature of the marshalling context API is the ability to wrap Java beans inside maps to allow pro [...]
{"description": "Out-of-the-box, Juneau supports marshalling of Java beans with standard public getters and setters, public fields, and\nfluent setters (e.g.\n`withX` naming convention).\nThere are also many settings and annotations that can be used to customize how bean properties are detected.\n\nThe following is an example of some of the ways to define bean properties:\n\n```java\npublic class MyBean {\n\n // Public field property.\n public String property1;\n\n // Standard p [...]
@@ -129,16 +132,16 @@
{"description": "Juneau gives you fine-grained control over **what gets emitted on the wire** and **what happens when a `null`\narrives during parsing**. The two surfaces are co-designed so the round-trip behavior is predictable across\nevery format (JSON, JSON5, XML, HTML, YAML, MsgPack, \u2026).\n\nThis page documents:\n\n- The serializer **inclusion knobs** that suppress empty / default values.\n- The parser **`Nulls` policy** that decides what to do when an incoming `null` reaches a [...]
{"description": "Serializers and parsers have a wide variety of configurable settings.\nTheir builders all extend from the <a href=\"/site/apidocs/org/apache/juneau/MarshallingContext.Builder.html\" target=\"_blank\">MarshallingContext.Builder</a> class\nthat allows you to easily construct new instances from scratch or build upon existing instances.\n\nFor example, the following code shows how to configure a JSON serializer:\n\n```java\nWriterSerializer serializer = JsonSerializer\n . [...]
{"description": "All configurable properties described in the previous section have annotation equivalents that can be applied on classes\nor methods.\n\nIn the section on the REST server API, we describe how to configure serializers and parsers using `@XConfig` annotations\nlike those shown below:\n\n```java\n@Rest(\n path=\"/addressBook\",\n title=\"Address Book REST API\"\n ...\n)\n@SerializerConfig(quoteChar=\"'\")\n@RdfConfig(rdfxml_tab=\"5\", addRootProperty=\"true\")\n@Ma [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/collections/MarshalledNode.html\" target=\"_blank\">MarshalledNode</a> class is a typed tree\n**fa\u00e7ade** layered over the generic-collections model \u2014 <a href=\"/site/apidocs/org/apache/juneau/marshall/collections/MarshalledMap.html\" target=\"_blank\">MarshalledMap</a> /\n<a href=\"/site/apidocs/org/apache/juneau/marshall/collections/MarshalledList.html\" target=\"_blank\">MarshalledList</a> and their\n<a h [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/collections/MarshalledNode.html\" target=\"_blank\">MarshalledNode</a> class is a typed tree\n**fa\u00e7ade** layered over the generic-collections model \u2014 <a href=\"/site/apidocs/org/apache/juneau/marshall/collections/MarshalledMap.html\" target=\"_blank\">MarshalledMap</a> /\n<a href=\"/site/apidocs/org/apache/juneau/marshall/collections/MarshalledList.html\" target=\"_blank\">MarshalledList</a> and their\n<a h [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/collections/JsonMap.html\" target=\"_blank\">JsonMap</a> and <a href=\"/site/apidocs/org/apache/juneau/marshall/collections/JsonList.html\" target=\"_blank\">JsonList</a> classes are generic Java representations of JSON objects and arrays.\nThese classes can be used to create \"unstructured\" models for serialization (as opposed to \"structured\" models\nconsisting of beans).\n\nIf you want to quickly generate JSON/X [...]
{"description": "Juneau provides **first-class, direct serializer/parser support** for a wide range of JDK datatypes \u2014 no\nextra modules, no opt-in registration, no swap setup required for the common cases. This page enumerates the\nsupported types, their default wire forms, and the per-type knobs that let you adjust the wire form across\nall formats.\n\n## Design principle: first-class > swaps\n\nJuneau handles common JDK datatypes through **direct serializer/parser code paths plus [...]
{"description": "The Juneau parsers have the ability to parse into complex data types that consist of multidimensional arrays and nested\n`Maps` and `Collections` using the methods below:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/marshall/parser/Parser.html\" target=\"_blank\">Parser</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/marshall/parser/Parser.html#<init>(org.apache.juneau.marshall.parser.Parser.Builder)\" [...]
-{"description": "On top of the serializers and parsers are the <a href=\"/site/apidocs/org/apache/juneau/marshall/serializer/SerializerSet.html\" target=\"_blank\">SerializerSet</a> and <a href=\"/site/apidocs/org/apache/juneau/marshall/parser/ParserSet.html\" target=\"_blank\">ParserSet</a> classes.\nThese classes allow serializers and parsers to be grouped and retrieved by W3C-compliant HTTP `Accept` and\n`Content-Type` values...\n\n```java\n// Construct a new serializer group with con [...]
+{"description": "On top of the serializers and parsers are the <a href=\"/site/apidocs/org/apache/juneau/marshall/serializer/SerializerSet.html\" target=\"_blank\">SerializerSet</a> and <a href=\"/site/apidocs/org/apache/juneau/marshall/parser/ParserSet.html\" target=\"_blank\">ParserSet</a> classes.\nThese classes allow serializers and parsers to be grouped and retrieved by W3C-compliant HTTP `Accept` and\n`Content-Type` values...\n\n```java\n// Construct a new serializer group with con [...]
{"description": "<a href=\"/site/apidocs/org/apache/juneau/swap/ObjectSwap.html\" target=\"_blank\">Swaps</a> are a critical component of Juneau.\nThey allow the serializers and parsers to handle Java objects that wouldn't normally be serializable.\n\nSwaps are, simply put, 'object swappers' that swap in serializable objects for non-serializable ones during serialization, and vis-versa during parsing.\n\nSome examples of non-serializable objects are `File`, `Reader`, `Iterable`, etc...\n [...]
-{"description": "By default, all serializers and parsers have built in `ObjectSwaps` defined for the following common data types:\n\n:::note\nAs of 9.5.0, `Iterator`, `Iterable`, `Stream`, and `Enumeration` types are serialized natively without swaps.\nThe `IteratorSwap` and `EnumerationSwap` classes have been removed.\nSee [Release 9.5.0](/release-notes/9.5.0) for details.\n:::\n\n:::note\nAs of 9.5.0, date/time types (`Calendar`, `Date`, `Temporal` subtypes, `XMLGregorianCalendar`) and [...]
+{"description": "By default, all serializers and parsers have built in `ObjectSwaps` defined for the following common data types:\n\n:::note\nAs of 9.5.0, `Iterator`, `Iterable`, `Stream`, and `Enumeration` types are serialized natively without swaps.\nThe `IteratorSwap` and `EnumerationSwap` classes have been removed.\nSee [Release 9.5.0](/docs/release-notes/9.5.0) for details.\n:::\n\n:::note\nAs of 9.5.0, date/time types (`Calendar`, `Date`, `Temporal` subtypes, `XMLGregorianCalendar` [...]
{"description": "Various methods can be defined on a class directly to affect how it gets serialized.\nThis can often be simpler than using `ObjectSwaps`.\n\nObjects serialized as `Strings` can be parsed back into their original objects by implementing one of the following methods on the class:\n\n- `public static T fromString(String)` method.\n \n Any of the following method names also work:\n - `valueOf(String)`\n - `parse(String)`\n - `parseString(String)`\n - `forName(String)`\ [...]
-{"description": "Swaps can also be defined per-media-type.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/swap/ObjectSwap.html#forMediaTypes()\" target=\"_blank\">ObjectSwap.forMediaTypes()</a> method can be\noverridden to provide a set of media types that the swap is invoked on.\n\nIt's also possible to define multiple swaps against the same object as long as they're differentiated by media type.\n\nWhen multiple swaps are defined, the best-match media type is used.\n\nIn the followin [...]
-{"description": "In the previous sections, we defined two-way swaps, meaning swaps where the original objects could be reconstructing\nduring parsing.\nHowever, there are certain kinds of objects that we may want to support for serializing but that are not possible to\nreconstruct during parsing.\nFor these, we can use one-way object swaps.\n\nA one-way swap is simply an object transform that only implements the `swap()` method.\nThe `unswap()` method is simply left unimplemented.\n\n::: [...]
+{"description": "Swaps can also be defined per-media-type.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/swap/ObjectSwap.html#forMediaTypes()\" target=\"_blank\">ObjectSwap.forMediaTypes()</a> method can be\noverridden to provide a set of media types that the swap is invoked on.\n\nIt's also possible to define multiple swaps against the same object as long as they're differentiated by media type.\n\nWhen multiple swaps are defined, the best-match media type is used.\n\nIn the followin [...]
+{"description": "In the previous sections, we defined two-way swaps, meaning swaps where the original objects could be reconstructing\nduring parsing.\nHowever, there are certain kinds of objects that we may want to support for serializing but that are not possible to\nreconstruct during parsing.\nFor these, we can use one-way object swaps.\n\nA one-way swap is simply an object transform that only implements the `swap()` method.\nThe `unswap()` method is simply left unimplemented.\n\n::: [...]
{"description": "<a href=\"/site/apidocs/org/apache/juneau/annotation/Swap.html\" target=\"_blank\">@Swap</a> can be used to associate a swap class using an annotation.\nThis is often cleaner than using the builder `swaps()` method since you can keep your swap class near your POJO class.\n\n```java\n@Swap(MyObjectSwap.class)\npublic class MyPojo {\n ...\n}\n\n// Sample swap for converting MyPojo classes to a simple string.\npublic class MyObjectSwap extends ObjectSwap {\n @Override [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/annotation/Swap.html#template()\" target=\"_blank\">@Swap(template)</a> annotation allows you to associate\narbitrary contextual strings with swaps.\nThe primary purpose is for providing template names, such as for Apache FreeMarker, therefore the name 'template'.\nHowever, the usage of the string is open-ended.\n\nFor example, you could pair a template string like so:\n\n```java\n@Swap(impl=FreeMarkerSwap.class, template=\"M [...]
{"description": "Surrogate classes are very similar in concept to `ObjectSwaps` except they're simpler to define.\n\nFor example, let's say we want to be able to serialize the following class but it's not serializable for some reason\n(for example, there are no properties exposed):\n\n```java\n// Not serializable because it's not a bean because it has no public properties.\npublic class MyNonSerializableClass {\n protected String foo;\n}\n```\n\nThis could be solved with the following [...]
@@ -147,56 +150,56 @@
{"description": "In addition to the bean type name support described above, simplified support is provided for bean subtypes.\n\nBean subtypes are similar in concept to bean type names, except for the following differences:\n\n- You specify the list of possible subclasses through an annotation on a parent bean class.\n- You do not need to register the subtype classes on the bean dictionary of the parser.\n\nIn the following example, the abstract class has two subclasses:\n\n```java\n// A [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/MarshallingContext.Builder.html#disableInterfaceProxies()\" target=\"_blank\">MarshallingContext.Builder.disableInterfaceProxies()</a> setting (enabled by default) allows the Juneau parsers to parse content into virtual beans (bean interfaces without implementation classes).\n\nFor example, the following code creates an instance of the specified unimplemented interface:\n\n```java\n// Our unimplemented interface\npublic inter [...]
{"description": "The Juneau Serializer API is designed to be used against POJO tree structures.\nIt expects that there not be loops in the POJO model (e.g.\nchildren with references to parents, etc...).\nIf you try to serialize models with loops, you will usually cause a `StackOverflowError` to be thrown (if <a href=\"/site/apidocs/org/apache/juneau/MarshallingTraverseContext.Builder.html#maxDepth(int)\" target=\"_blank\">MarshallingTraverseContext.Builder.maxDepth(int)</a> is not reache [...]
-{"description": "The Juneau parsers are not limited to parsing back into the original bean classes.\nIf the bean classes are not available on the parsing side, the parser can also be used to parse into a generic model\nconsisting of `Maps`, `Collections`, and primitive objects.\n\nYou can parse into any `Map` type (e.g. `HashMap`, `TreeMap`) but using <a href=\"/site/apidocs/org/apache/juneau/collections/JsonMap.html\" target=\"_blank\">JsonMap</a> is recommended since it has many conven [...]
+{"description": "The Juneau parsers are not limited to parsing back into the original bean classes.\nIf the bean classes are not available on the parsing side, the parser can also be used to parse into a generic model\nconsisting of `Maps`, `Collections`, and primitive objects.\n\nYou can parse into any `Map` type (e.g. `HashMap`, `TreeMap`) but using <a href=\"/site/apidocs/org/apache/juneau/marshall/collections/JsonMap.html\" target=\"_blank\">JsonMap</a> is recommended since it has ma [...]
{"description": "The following parsers can be configured to read continuous streams of objects from the same input stream:\n\n<tree>\n<node-0><javac-class><a href=\"/site/apidocs/org/apache/juneau/marshall/json/JsonParser.html\" target=\"_blank\">JsonParser</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/marshall/uon/UonParser.html\" target=\"_blank\">UonParser</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/marshall/msgpack/MsgPackParser [...]
{"description": "Juneau supports streaming serialization and parsing of arbitrarily large datasets without loading\nall elements into memory. The feature is built directly into the serializer and parser APIs, so\nevery format (JSON, XML, YAML, CSV, MessagePack, \u2026) works transparently.\n\n## Key Interfaces\n\n| Interface | Extends | Direction | Purpose |\n|---|---|---|---|\n| `BeanSupplier<T>` | `Iterable<T>` | Serialization | Provides beans to serializers lazily from a cursor or que [...]
-{"description": "Juneau serializers have sophisticated support for transforming relative URIs to absolute form.\n\nThe following example shows a bean containing URIs of various forms and how they end up serialized.\n\n```java\n// Our bean with properties containing various kinds of URIs.\npublic class TestURIs {\n public URI\n a = URI.create(\"http://www.apache.org/a\"),\n b = URI.create(\"/b\"),\n c = URI.create(\"/c/x/y\"),\n d = URI.create(\"d\"),\n [...]
+{"description": "Juneau serializers have sophisticated support for transforming relative URIs to absolute form.\n\nThe following example shows a bean containing URIs of various forms and how they end up serialized.\n\n```java\n// Our bean with properties containing various kinds of URIs.\npublic class TestURIs {\n public URI\n a = URI.create(\"http://www.apache.org/a\"),\n b = URI.create(\"/b\"),\n c = URI.create(\"/c/x/y\"),\n d = URI.create(\"d\"),\n [...]
{"description": "Juneau was developed independently from Jackson but shares many of the same features and capabilities.\nWhereas Jackson was created to work primarily with JSON, Juneau was created to work for multiple languages.\nTherefore, the terminology and annotations in Juneau are similar but language-agnostic.\n\nThe following charts describe equivalent features between the two libraries:\n\n## Annotations\n\n| Jackson | Juneau |\n|---------|--------|\n| `@JsonGetter`<br/>`@JsonSet [...]
-{"description": "In general, Juneau allows for marshalling for a wide variety of POJO types including:\n\nThe following chart shows POJOs categorized into groups and whether they can be serialized or parsed:\n\n#### General POJO serialization/parsing support\n\n<table className=\"styled w800\" style={{borderCollapse: 'collapse'}}>\n <tr>\n <th>Group</th>\n <th>Description</th>\n <th>Examples</th>\n <th>Can<br />serialize?</th>\n <th>Can<br />parse?</th>\n </tr>\n <tr cl [...]
+{"description": "In general, Juneau allows for marshalling for a wide variety of POJO types including:\n\nThe following chart shows POJOs categorized into groups and whether they can be serialized or parsed:\n\n### General POJO serialization/parsing support\n\n<table className=\"styled w800\" style={{borderCollapse: 'collapse'}}>\n <tr>\n <th>Type</th>\n <th>Description</th>\n <th>Can<br />serialize?</th>\n <th>Can<br />parse?</th>\n </tr>\n <tr className=\"dark bb\" style [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/commons/svl/package-summary.html\" target=\"_blank\">org.apache.juneau.commons.svl</a> package defines an API for a language called\n\"Simple Variable Language\".\n\nIn a nutshell, Simple Variable Language (or SVL) is text that contains variables of the form `$varName{varKey}`.\nIt is used extensively in the Config, REST and Microservice APIs.\n\nMost variables can be recursively nested within the varKey (e.g. `$FOO{$BAR{xxx} [...]
{"description": "Variables are defined through the <a href=\"/site/apidocs/org/apache/juneau/commons/svl/Var.html\" target=\"_blank\">Var</a> API.\nThe API comes with several predefined variables and is easily extensible.\n\nThe following is an example of a variable that performs URL-Encoding on strings.\n\n```java\n// First create our var.\npublic class UrlEncodeVar extends SimpleVar {\n\n // Must have a no-arg constructor!\n public UrlEncodeVar() {\n super(\"UE\");\n }\ [...]
{"description": "The main class for performing variable resolution is <a href=\"/site/apidocs/org/apache/juneau/commons/svl/VarResolver.html\" target=\"_blank\">VarResolver</a>.\n\nTwo methods are provided for resolving variables:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/commons/svl/VarResolver.html\" target=\"_blank\">VarResolver</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/commons/svl/VarResolver.html#resolve( [...]
-{"description": "<a href=\"/site/apidocs/org/apache/juneau/commons/svl/VarResolver.html#DEFAULT\" target=\"_blank\">VarResolver.DEFAULT</a> is a reusable variable resolver with\ndefault support for the following variables:\n\n- `$S{key[,default]}` - <a href=\"/site/apidocs/org/apache/juneau/commons/svl/vars/SystemPropertiesVar.html\" target=\"_blank\">SystemPropertiesVar</a>\n- `$E{key[,default]}` - <a href=\"/site/apidocs/org/apache/juneau/commons/svl/vars/EnvVariablesVar.html\" target= [...]
+{"description": "<a href=\"/site/apidocs/org/apache/juneau/commons/svl/VarResolver.html#DEFAULT\" target=\"_blank\">VarResolver.DEFAULT</a> is a reusable variable resolver with\ndefault support for the following variables:\n\n- `$S{key[,default]}` - <a href=\"/site/apidocs/org/apache/juneau/commons/svl/vars/SystemPropertiesVar.html\" target=\"_blank\">SystemPropertiesVar</a>\n- `$E{key[,default]}` - <a href=\"/site/apidocs/org/apache/juneau/commons/svl/vars/EnvVariablesVar.html\" target= [...]
{"description": "- The escape character `\\` can be used when necessary to escape the following characters: `$ , { }` \n\n:::warning\nIt is possible to cause <a href=\"https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StackOverflowError.html\" target=\"_blank\">StackOverflowErrors</a> if your nested variables\nresult in a recursive loop (e.g. the environment variable `'MYPROPERTY'` has the value `'$E{MYPROPERTY}'`).\nSo don't do that!\n:::\n\n- As a general rule, thi [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/commons/inject/Value.html\" target=\"_blank\">@Value</a> annotation\n(introduced in 9.5.0, package `org.apache.juneau.commons.inject`) is a declarative way to inject configuration\nvalues into beans created by <a href=\"/site/apidocs/org/apache/juneau/commons/inject/BeanInstantiator.html\" target=\"_blank\">BeanInstantiator</a> \u2014 constructor parameters, setter parameters, and fields.\n\nIt complements <a href=\"/site/api [...]
{"description": "This page documents the framework-internal sites that read configuration through the\n`@Value` seam (introduced in 9.5.0). It is a reference for users who:\n\n- Used to import the deleted `CallLogger.SP_xxx` constants directly.\n- Want to know which framework defaults are now `@Value`-driven (and therefore overridable\n through the standard `Settings` precedence chain \u2014 system properties, environment\n variables, registered `PropertySource`s, and `Settings.setGlob [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/encoders/package-summary.html\" target=\"_blank\">org.apache.juneau.encoders</a> package defines an API for handling encoding-based matching\nof `Accept-Encoding`/`Content-Encoding` HTTP headers.\n\nIt consists of the following classes:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/encoders/EncoderSet.html\" target=\"_blank\">EncoderSet</a></java-class></node-0>\n<node-0><java-abstract-class><a href [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/objecttools/package-summary.html\" target=\"_blank\">org.apache.juneau.objecttools</a> package defines convenience utility\nclasses for accessing and manipulating POJOs.\n\nIt consists of the following classes:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/objecttools/ObjectSearcher.html\" target=\"_blank\">ObjectSearcher</a></java-class></node-0>\n<node-0><java-class><a href=\"/site/apidocs/org/apa [...]
-{"description": "Juneau supports converting arbitrary POJOs to and from JSON using ultra-efficient serializers and parsers.\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/json/JsonSerializer.html\" target=\"_blank\">JsonSerializer</a> converts POJOs directly to strict RFC 8259 JSON (double quotes) without intermediate DOM objects.\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/json/JsonParser.html\" target=\"_blank\">JsonParser</a> creates POJOs from strict JSON only. F [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/encoders/package-summary.html\" target=\"_blank\">org.apache.juneau.encoders</a> package defines an API for handling encoding-based matching\nof `Accept-Encoding`/`Content-Encoding` HTTP headers.\n\nIt consists of the following classes:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/encoders/EncoderSet.html\" target=\"_blank\">EncoderSet</a></java-class></node-0>\n<node-0><java-abstract-class><a href [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/objecttools/package-summary.html\" target=\"_blank\">org.apache.juneau.objecttools</a> package defines convenience utility\nclasses for accessing and manipulating POJOs.\n\nIt consists of the following classes:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/objecttools/ObjectSearcher.html\" target=\"_blank\">ObjectSearcher</a></java-class></node-0>\n<node-0><java-class><a href=\"/site/apidocs/org/apa [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from JSON using ultra-efficient serializers and parsers.\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/json/JsonSerializer.html\" target=\"_blank\">JsonSerializer</a> converts POJOs directly to strict RFC 8259 JSON (double quotes) without intermediate DOM objects.\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/json/JsonParser.html\" target=\"_blank\">JsonParser</a> creates POJOs from strict JSON only. F [...]
{"description": "The JSON data type produced depends on the Java object type being serialized.\n\n- Primitives and primitive objects are converted to JSON primitives.\n- Beans and `Maps` are converted to JSON objects.\n- `Collections` and arrays are converted to JSON arrays.\n- Anything else is converted to JSON strings.\n\n##### Data type conversions:\n\n| POJO type | JSON type | Example | Serialized form |\n|-----------|-----------|---------|----------------|\n| String | String | `seri [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/json/JsonSerializer.html\" target=\"_blank\">JsonSerializer</a> class is used to serialize POJOs into\nJSON.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Mar [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/json/Json5Serializer.html\" target=\"_blank\">Json5Serializer</a> class can be used to serialized POJOs\ninto JSON 5 notation.\n\nJSON 5 is similar to JSON except for the following:\n\n- JSON attributes are only quoted when necessary.\n- Uses single-quotes for quoting.\n\n:::tip Examples\n```java\n// Some free-form JSON.\nJsonMap map = JsonMap.of(\n \"foo\", \"x1\",\n \"_bar\", \"x2\",\n \" baz \", \"x3\",\n [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/json/JsonParser.html\" target=\"_blank\">JsonParser</a> class is used to parse JSON into POJOs.\n\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/MarshallingContextab [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/json/Json.html\" target=\"_blank\">@Json</a> annotation is used to override the behavior of <a href=\"/site/apidocs/org/apache/juneau/marshall/json/JsonSerializer.html\" target=\"_blank\">JsonSerializer</a> on individual bean classes or properties.\n\nThe annotation can be applied to beans as well as other objects serialized to other types (e.g. strings).\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/or [...]
-{"description": "Juneau provides the <a href=\"/site/apidocs/org/apache/juneau/marshall/json/JsonSchemaSerializer.html\" target=\"_blank\">JsonSchemaSerializer</a> class for\ngenerating JSON-Schema documents that describe the output generated by the <a href=\"/site/apidocs/org/apache/juneau/marshall/json/JsonSerializer.html\" target=\"_blank\">JsonSerializer</a> class.\nThis class shares the same properties as `JsonSerializer`.\n\nFor convenience the <a href=\"/site/apidocs/org/apache/ju [...]
-{"description": "Juneau supports converting arbitrary POJOs to and from XML using ultra-efficient serializers and parsers.\n\nThe XML serializer converts POJOs directly to XML without the need for intermediate DOM objects.\nLikewise, the XML parser uses a STaX parser and creates POJOs directly without intermediate DOM objects.\n\nUnlike frameworks such as JAXB, Juneau does not require POJO classes to be annotated to produce and consume XML.\nHowever, several XML annotations are provided [...]
+{"description": "Juneau provides the <a href=\"/site/apidocs/org/apache/juneau/marshall/json/JsonSchemaSerializer.html\" target=\"_blank\">JsonSchemaSerializer</a> class for\ngenerating JSON-Schema documents that describe the output generated by the <a href=\"/site/apidocs/org/apache/juneau/marshall/json/JsonSerializer.html\" target=\"_blank\">JsonSerializer</a> class.\nThis class shares the same properties as `JsonSerializer`.\n\nFor convenience the <a href=\"/site/apidocs/org/apache/ju [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from XML using ultra-efficient serializers and parsers.\n\nThe XML serializer converts POJOs directly to XML without the need for intermediate DOM objects.\nLikewise, the XML parser uses a STaX parser and creates POJOs directly without intermediate DOM objects.\n\nUnlike frameworks such as JAXB, Juneau does not require POJO classes to be annotated to produce and consume XML.\nHowever, several XML annotations are provided [...]
{"description": "The following examples show how different data types are represented in XML.\nThey mirror how the data structures are represented in JSON.\n\n##### Simple types\n\nThe representation of loose (not a direct bean property value) simple types are shown below:\n\n<table class=\"code-table\">\n<tr>\n<th>Data type</th>\n<th>JSON example</th>\n<th>XML</th>\n</tr>\n<tr>\n<td>string</td>\n<td>\n```json\n'foo'\n```\n</td>\n<td>\n```xml\n<string>foo</string>\n```\n</td>\n</tr>\n<tr [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/xml/XmlSerializer.html\" target=\"_blank\">XmlSerializer</a> class is used to serialize POJOs into XML.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/xml/XmlDocSerializer.html\" target=\"_blank\">XmlDocSerializer</a> class is the same but serializes a\n`<?xml?>` header at the top of the file.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/s [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/xml/XmlParser.html\" target=\"_blank\">XmlParser</a> class is used to parse XML into POJOs.\n\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/MarshallingContextable.B [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/annotation/Marshalled.html#typeName()\" target=\"_blank\">@Marshalled(typeName)</a> annotation can be used to override the Juneau default name on bean elements.\n\nTypes names serve two distinct purposes:\n\n1. To override the element name.\n2. To serve as a class identifier so that the bean class can be inferred during parsing if it cannot automatically be inferred through reflection.\n\n:::tip Example\n<table class=\"code-t [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/xml/Xml.html#childName()\" target=\"_blank\">@Xml(childName)</a> annotation can be used to\nspecify the name of XML child elements for bean properties of type collection or array.\n\n:::tip Example\n\n<table class=\"code-table\">\n<tr>\n<th>Data type</th>\n<th>JSON example</th>\n<th>Without annotation</th>\n<th>With annotation</th>\n</tr>\n<tr>\n<td>\n\n```java\nclass MyBean {\n @Xml(childName=\"X\")\n public Strin [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/xml/Xml.html#format()\" target=\"_blank\">@Xml(format)</a> annotation can be used to tweak the\nXML format of a POJO.\nThe value is set to an enum value of type <a href=\"/site/apidocs/org/apache/juneau/marshall/xml/XmlFormat.html\" target=\"_blank\">XmlFormat</a>.\nThis annotation can be applied to both classes and bean properties.\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/xml/XmlFormat.html#ATTR\" tar [...]
-{"description": "Let's go back to the example of our original `Person` bean class but add some namespace annotations:\n\n##### Sample Beans\n\n```java\n@Xml(prefix=\"per\")\n@Marshalled(typeName=\"person\")\npublic class Person {\n\n // Bean properties\n public String name;\n @Swap(TemporalCalendarSwap.IsoInstant.class) public Calendar birthDate;\n public List addresses;\n\n // Getters/setters omitted\n}\n\n@Xml(prefix=\"addr\")\n@Marshalled(typeName=\"address\")\npublic c [...]
+{"description": "Let's go back to the example of our original `Person` bean class but add some namespace annotations:\n\n##### Sample Beans\n\n```java\n@Xml(prefix=\"per\")\n@Marshalled(typeName=\"person\")\npublic class Person {\n\n // Bean properties\n public String name;\n @MarshalledProp(calendarFormat=CalendarFormat.ISO_INSTANT) public Calendar birthDate;\n public List addresses;\n\n // Getters/setters omitted\n}\n\n@Xml(prefix=\"addr\")\n@Marshalled(typeName=\"addres [...]
{"description": "Juneau supports converting arbitrary POJOs to and from HTML.\nBuilt on top of the existing XML parser, it also uses a STaX parser and creates POJOs directly without intermediate DOM\nobjects.\n\nThe primary use case for HTML serialization is rendering POJOs in easy-to-read format in REST interfaces.", "id": "topic:89000b6dc4fc", "module": "28", "related_ids": [], "source_path": "pages/topics/02.28.01.HtmlBasics.md", "source_type": "topic", "summary": "Juneau supports con [...]
{"description": "The following examples show how different data types are represented in HTML.\nThey mirror how the data structures are represented in JSON.\n\n##### Simple types\n\nThe representation for simple types mirror those produced by the XML serializer.\nTags are added to help differentiate data types when they cannot be inferred through reflection.\nThese tags are ignored by browsers and treated as plain text.\n\n<table class=\"code-table\">\n<tr>\n<th>Data type</th>\n<th>JSON [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlSerializer.html\" target=\"_blank\">HtmlSerializer</a> class is used to serialize POJOs into\nHTML.\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlDocSerializer.html\" target=\"_blank\">HtmlDocSerializer</a> class is the same but wraps the\nserialized POJO inside a document template consisting of header, nav, aside, and footer sections.\n\nThe class hierarchy for the builder of this seriali [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlParser.html\" target=\"_blank\">HtmlParser</a> class is used to parse HTML into POJOs.\nThey can also parse the contents produced by <a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlDocSerializer.html\" target=\"_blank\">HtmlDocSerializer</a>.\n\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder. [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/html/Html.html\" target=\"_blank\">@Html</a> annotation can be used to customize how POJOs are\nserialized to HTML on a per-class/field/method basis.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/marshall/html/Html.html\" target=\"_blank\">Html</a></java-annotation></node-0>\n<node-1><javac-method-annotation><a href=\"/site/apidocs/org/apache/juneau/marshall/html/Html.html#anchorText() [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/html/Html.html#render()\" target=\"_blank\">@Html(render)</a> annotation allows for custom\nrendering of bean property values when serialized as HTML.\nUsing this class, you can alter the CSS style and HTML content of the bean property.\n\nThe following example shows two render classes that customize the appearance of the `pctFull` and `status` columns in\nthe code below:\n\n```java\nimport static org.apache.juneau.b [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/html/Html.html#render()\" target=\"_blank\">@Html(render)</a> annotation allows for custom\nrendering of bean property values when serialized as HTML.\nUsing this class, you can alter the CSS style and HTML content of the bean property.\n\nThe following example shows two render classes that customize the appearance of the `pctFull` and `status` columns in\nthe code below:\n\n```java\nimport static org.apache.juneau.b [...]
{"description": "<a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlDocSerializer.html\" target=\"_blank\">HtmlDocSerializer</a> is an extension of <a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlSerializer.html\" target=\"_blank\">HtmlSerializer</a> that wraps serialized POJOs in a complete HTML document.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.htm [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/html/BasicHtmlDocTemplate.html\" target=\"_blank\">BasicHtmlDocTemplate</a> class defines a default\ntemplate for HTML documents created by <a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlDocSerializer.html\" target=\"_blank\">HtmlDocSerializer</a>.\n\nThe HTML document created by this template consists of the following structure:\n\n```xml\n<html>\n <head>\n <style type='text/css'>\n [...]
{"description": "Custom page templates can be created by implementing the <a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlDocTemplate.html\" target=\"_blank\">HtmlDocTemplate</a> interface and associating it with your <a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlDocSerializer.html\" target=\"_blank\">HtmlDocSerializer</a> using the <a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlDocSerializer.Builder.html#template(java.lang.Class)\" target=\"_blank\ [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlSchemaSerializer.html\" target=\"_blank\">HtmlSchemaSerializer</a> class is the HTML-equivalent\nto the <a href=\"/site/apidocs/org/apache/juneau/marshall/json/JsonSchemaSerializer.html\" target=\"_blank\">JsonSchemaSerializer</a> class.\nIt's used to generate HTML versions of JSON-Schema documents that describe the output generated by the <a href=\"/site/apidocs/org/apache/juneau/marshall/json/JsonSerialize [...]
-{"description": "Juneau supports converting arbitrary POJOs to and from UON strings using ultra-efficient serializers and parsers.\n\nThe serializer converts POJOs directly to UON strings without the need for intermediate DOM objects using a\nhighly-efficient state machine.\nLikewise, the parser creates POJOs directly from UON strings without the need for intermediate DOM objects.\n\nJuneau uses UON (URL-Encoded Object Notation) for representing POJOs.\n\nThe UON specification can be fou [...]
-{"description": "#### General methodology:\n\n<table class=\"code-table\">\n<tr>\n<th>Java type</th>\n<th>JSON equivalent</th>\n<th>UON</th>\n</tr>\n<tr>\n<td>`Maps`/beans</td>\n<td>OBJECT</td>\n<td>\n\n```\na1=(b1=x1,b2=x2)\na1=(b1=(c1=x1,c2=x2))\n```\n\n</td>\n</tr>\n<tr>\n<td>`Collections`/arrays</td>\n<td>ARRAY</td>\n<td>\n\n```\na1=@(x1,x2)\na1=@(@(x1,x2),@(x3,x4))\na1=@((b1=x1,b2=x2),(c1=x1,c2=x2))\n```\n\n</td>\n</tr>\n<tr>\n<td>Booleans</td>\n<td>BOOLEAN</td>\n<td>\n\n```\na1=tru [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from UON strings using ultra-efficient serializers and parsers.\n\nThe serializer converts POJOs directly to UON strings without the need for intermediate DOM objects using a\nhighly-efficient state machine.\nLikewise, the parser creates POJOs directly from UON strings without the need for intermediate DOM objects.\n\nJuneau uses UON (URL-Encoded Object Notation) for representing POJOs.\n\nThe UON specification can be fou [...]
+{"description": "### General methodology:\n\n<table class=\"code-table\">\n<tr>\n<th>Java type</th>\n<th>JSON equivalent</th>\n<th>UON</th>\n</tr>\n<tr>\n<td>`Maps`/beans</td>\n<td>OBJECT</td>\n<td>\n\n```\na1=(b1=x1,b2=x2)\na1=(b1=(c1=x1,c2=x2))\n```\n\n</td>\n</tr>\n<tr>\n<td>`Collections`/arrays</td>\n<td>ARRAY</td>\n<td>\n\n```\na1=@(x1,x2)\na1=@(@(x1,x2),@(x3,x4))\na1=@((b1=x1,b2=x2),(c1=x1,c2=x2))\n```\n\n</td>\n</tr>\n<tr>\n<td>Booleans</td>\n<td>BOOLEAN</td>\n<td>\n\n```\na1=true [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/uon/UonSerializer.html\" target=\"_blank\">UonSerializer</a> class is used to serialize POJOs into UON.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Marshall [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/uon/UonParser.html\" target=\"_blank\">UonParser</a> class is used to parse UON into POJOs.\n\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/MarshallingContextable.B [...]
-{"description": "Juneau supports converting arbitrary POJOs to and from URL-encoded strings using ultra-efficient serializers and\nparsers.\n\nThe serializer converts POJOs directly to URL-encoded strings without the need for intermediate DOM objects using a\nhighly-efficient state machine.\nLikewise, the parser creates POJOs directly from URL-encoded strings without the need for intermediate DOM objects.\n\nJuneau uses UON (URL-Encoded Object Notation) for representing POJOs as URL-Enco [...]
-{"description": "#### General methodology:\n\n<table class=\"code-table\">\n<tr>\n<th>Java type</th>\n<th>JSON equivalent</th>\n<th>UON</th>\n</tr>\n<tr>\n<td>`Maps`/beans</td>\n<td>OBJECT</td>\n<td>\n\n```\na1=(b1=x1,b2=x2)\na1=(b1=(c1=x1,c2=x2))\n```\n\n</td>\n</tr>\n<tr>\n<td>`Collections`/arrays</td>\n<td>ARRAY</td>\n<td>\n\n```\na1=@(x1,x2)\na1=@(@(x1,x2),@(x3,x4))\na1=@((b1=x1,b2=x2),(c1=x1,c2=x2))\n```\n\n</td>\n</tr>\n<tr>\n<td>Booleans</td>\n<td>BOOLEAN</td>\n<td>\n\n```\na1=tru [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from URL-encoded strings using ultra-efficient serializers and\nparsers.\n\nThe serializer converts POJOs directly to URL-encoded strings without the need for intermediate DOM objects using a\nhighly-efficient state machine.\nLikewise, the parser creates POJOs directly from URL-encoded strings without the need for intermediate DOM objects.\n\nJuneau uses UON (URL-Encoded Object Notation) for representing POJOs as URL-Enco [...]
+{"description": "### General methodology:\n\n<table class=\"code-table\">\n<tr>\n<th>Java type</th>\n<th>JSON equivalent</th>\n<th>UON</th>\n</tr>\n<tr>\n<td>`Maps`/beans</td>\n<td>OBJECT</td>\n<td>\n\n```\na1=(b1=x1,b2=x2)\na1=(b1=(c1=x1,c2=x2))\n```\n\n</td>\n</tr>\n<tr>\n<td>`Collections`/arrays</td>\n<td>ARRAY</td>\n<td>\n\n```\na1=@(x1,x2)\na1=@(@(x1,x2),@(x3,x4))\na1=@((b1=x1,b2=x2),(c1=x1,c2=x2))\n```\n\n</td>\n</tr>\n<tr>\n<td>Booleans</td>\n<td>BOOLEAN</td>\n<td>\n\n```\na1=true [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/urlencoding/UrlEncodingSerializer.html\" target=\"_blank\">UrlEncodingSerializer</a> class is used to\nserialize POJOs into URL-Encoding.\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/ap [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/urlencoding/UrlEncodingParser.html\" target=\"_blank\">UrlEncodingParser</a> class is used to parse\nURL-Encoding into POJOs.\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/urlencoding/UrlEncoding.html\" target=\"_blank\">@UrlEncoding</a> annotation is used to\noverride the behavior of <a href=\"/site/apidocs/org/apache/juneau/marshall/urlencoding/UrlEncodingSerializer.html\" target=\"_blank\">UrlEncodingSerializer</a>\non individual bean classes or properties.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/marshall/urlencoding/UrlEncoding.html\" target=\" [...]
-{"description": "Juneau supports converting arbitrary POJOs to and from MessagePack using ultra-efficient serializers and parsers.\nMessagePack is a compact binary form of JSON.\n\nThe serialization support for MessagePack mirrors that of JSON.\n\n## Media types\n\nThe serializer emits `Content-Type: application/msgpack` (the RFC 6838-conforming value, matching the constant\n`org.apache.juneau.http.header.ContentType.APPLICATION_MSGPACK`).\nThe parser accepts both `application/msgpack` a [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from MessagePack using ultra-efficient serializers and parsers.\nMessagePack is a compact binary form of JSON.\n\nThe serialization support for MessagePack mirrors that of JSON.\n\n## Media types\n\nThe serializer emits `Content-Type: application/msgpack` (the RFC 6838-conforming value, matching the constant\n`org.apache.juneau.http.header.ContentType.APPLICATION_MSGPACK`).\nThe parser accepts both `application/msgpack` a [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/msgpack/MsgPackSerializer.html\" target=\"_blank\">MsgPackSerializer</a> class is used to serialize POJOs\ninto MessagePack.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/a [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/msgpack/MsgPackParser.html\" target=\"_blank\">MsgPackParser</a> class is used to parse MessagePack into\nPOJOs.\n\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Mar [...]
{"description": "Juneau supports converting arbitrary POJOs to and from strings using OpenAPI-based schema rules.\n\nThe relevant classes for using OpenAPI-based serialization are:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/marshall/oapi/OpenApiSerializer.html\" target=\"_blank\">OpenApiSerializer</a></java-class> - Converts POJOs to strings.</node-0>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/marshall/oapi/OpenApiParser.html\" target=\"_ [...]
@@ -207,7 +210,7 @@
{"description": "Juneau supports converting arbitrary POJOs to and from the **Protobuf Text Format** using native serializers and parsers implemented without any external dependencies. This is the human-readable text format (not the binary wire format) used for protobuf configuration files, debugging, and interop with tools like `protoc --decode`. The <a href=\"/site/apidocs/org/apache/juneau/marshall/prototext/PrototextSerializer.html\" target=\"_blank\">PrototextSerializer</a> converts [...]
{"description": "The `org.apache.juneau.marshall.parquet` package provides Juneau serializer and parser implementations for the\n[Apache Parquet](https://parquet.apache.org/docs/file-format/) columnar storage format.\n\nThe `ParquetSerializer` and `ParquetParser` classes integrate with the standard Juneau\n`Serializer` / `Parser` APIs and support the `@Parquet` and `@ParquetConfig` annotations for\nformat-specific configuration.\n\n##### External-read interop\n\nThe parser reads spec-com [...]
{"description": "Juneau supports converting arbitrary POJOs to and from the Protocol Buffers **binary** wire format using native, bean-driven serializers and parsers. No `.proto` schema file or code generation is required — the field-number/type schema is derived directly from Juneau bean metadata.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/protobuf/ProtobufSerializer.html\" target=\"_blank\">ProtobufSerializer</a> converts POJOs directly to protobuf binary bytes, an [...]
-{"description": "Juneau supports converting arbitrary POJOs to and from YAML using native serializers and parsers implemented\nwithout any external dependencies.\nThe YAML serializer converts POJOs directly to YAML block-style output using indentation-based structure.\nThe YAML parser creates POJOs directly from YAML using an indentation-aware state machine.\n\nThe following example shows YAML for a typical bean:\n\n##### Sample Beans\n\n```java\npublic class Person {\n\n // Bean prop [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from YAML using native serializers and parsers implemented\nwithout any external dependencies.\nThe YAML serializer converts POJOs directly to YAML block-style output using indentation-based structure.\nThe YAML parser creates POJOs directly from YAML using an indentation-aware state machine.\n\nThe following example shows YAML for a typical bean:\n\n##### Sample Beans\n\n```java\npublic class Person {\n\n // Bean prop [...]
{"description": "The YAML data type produced depends on the Java object type being serialized.\n\n- Primitives and primitive objects are converted to YAML scalars.\n- Beans and `Maps` are converted to YAML block mappings.\n- `Collections` and arrays are converted to YAML block sequences.\n- Anything else is converted to YAML string scalars (with quoting if necessary).\n\n##### Data type conversions:\n\n| POJO type | YAML type | Example | Serialized form |\n|-----------|-----------|------ [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/yaml/YamlSerializer.html\" target=\"_blank\">YamlSerializer</a> class is used to serialize POJOs into\nYAML.\n\nThe class hierarchy for the builder of this serializer is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Mar [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/yaml/YamlParser.html\" target=\"_blank\">YamlParser</a> class is used to parse YAML into POJOs.\n\nThe class hierarchy for the builder of this parser is:\n\n<tree>\n<node-0><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/Context.Builder.html\" target=\"_blank\">Context.Builder</a></java-abstract-class></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/juneau/MarshallingContextab [...]
@@ -218,24 +221,24 @@
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/markdown/package-summary.html\" target=\"_blank\">org.apache.juneau.marshall.markdown</a>\npackage provides Markdown serialization and parsing for POJOs. Output is optimized for human readability and LLM/AI consumption.\n\n##### Maven Dependency\n\nMarkdown support is included in `juneau-marshall`:\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-marshall</artifactId>\n <ve [...]
{"description": "Juneau supports converting arbitrary POJOs to and from JSONL (JSON Lines, also called NDJSON) using native serializers and parsers. JSONL is a text format where each line is a valid JSON value, separated by newlines. It is the standard format for LLM fine-tuning datasets, streaming AI inference, log aggregation, and bulk data pipelines.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/jsonl/JsonlSerializer.html\" target=\"_blank\">JsonlSerializer</a> converts PO [...]
{"description": "Juneau supports converting arbitrary POJOs to and from JSON5L \u2014 a combination of the relaxed [JSON5](/docs/topics/Json5) dialect and [JSONL](/docs/topics/JsonlBasics)'s newline-delimited framing (one document per line). JSON5L is a good fit for human-edited line-delimited config and data files: it keeps JSONL's \"one record per line\" streaming model while tolerating comments, unquoted keys, single-quoted strings, and trailing commas on each line.\n\nThe <a href=\"/ [...]
-{"description": "Juneau supports converting arbitrary POJOs to and from Hjson (Human JSON) using native serializers and parsers. Hjson is a syntax extension of JSON designed for human-friendly configuration files and hand-edited data. It extends JSON with quoteless strings, multiline strings, comments, optional commas, and unquoted keys.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/hjson/HjsonSerializer.html\" target=\"_blank\">HjsonSerializer</a> converts POJOs directly to [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from Hjson (Human JSON) using native serializers and parsers. Hjson is a syntax extension of JSON designed for human-friendly configuration files and hand-edited data. It extends JSON with quoteless strings, multiline strings, comments, optional commas, and unquoted keys.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/hjson/HjsonSerializer.html\" target=\"_blank\">HjsonSerializer</a> converts POJOs directly to [...]
{"description": "Juneau supports converting arbitrary POJOs to canonical JSON per [RFC 8785](https://www.rfc-editor.org/rfc/rfc8785) (JCS - JSON Canonicalization Scheme) using a native serializer. JCS produces a deterministic, byte-for-byte representation suitable for cryptographic operations such as hashing and digital signing.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/json/JcsSerializer.html\" target=\"_blank\">JcsSerializer</a> converts POJOs to canonical JSON. The <a [...]
{"description": "Juneau supports converting arbitrary POJOs to and from BSON (Binary JSON) using native serializers and parsers. BSON is the binary serialization format used by MongoDB, extending JSON with typed integers (int32/int64), native datetime, decimal128, and binary data. It uses little-endian byte order and length-prefixed documents.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/bson/BsonSerializer.html\" target=\"_blank\">BsonSerializer</a> converts POJOs directly [...]
{"description": "Juneau supports converting arbitrary POJOs to and from CBOR (Concise Binary Object Representation) per RFC 8949 using native serializers and parsers. CBOR is a compact binary format designed for extremely small code size, very small message size, and extensibility. It is widely used in IoT, constrained environments, COSE (CBOR Object Signing and Encryption), and WebAuthn.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/cbor/CborSerializer.html\" target=\"_blank [...]
-{"description": "Juneau supports converting arbitrary POJOs to and from HOCON (Human-Optimized Config Object Notation) using native serializers and parsers. HOCON is a superset of JSON used extensively in the JVM ecosystem (Akka, Play Framework, sbt, Apache Spark, Kafka, Flink) for configuration files. It extends JSON with path expressions, `=` as key-value separator, unquoted strings, object merging, substitutions (`${var}`), triple-quoted multi-line strings, and optional root braces.\n [...]
+{"description": "Juneau supports converting arbitrary POJOs to and from HOCON (Human-Optimized Config Object Notation) using native serializers and parsers. HOCON is a superset of JSON used extensively in the JVM ecosystem (Akka, Play Framework, sbt, Apache Spark, Kafka, Flink) for configuration files. It extends JSON with path expressions, `=` as key-value separator, unquoted strings, object merging, substitutions (`${var}`), triple-quoted multi-line strings, and optional root braces.\n [...]
{"description": "The `org.apache.juneau.marshall.ini` package provides Juneau serializer and parser implementations for the INI\nconfiguration file format.\n\nThe `IniSerializer` and `IniParser` classes integrate with the standard Juneau `Serializer` / `Parser` APIs and\nsupport the `@Ini` and `@IniConfig` annotations for format-specific configuration.\n\n:::note\nFull documentation for the INI serializer/parser is coming soon. In the meantime, refer to the\n[Marshallers overview](/docs/ [...]
{"description": "Juneau supports the [Server-Sent Events (SSE)](https://html.spec.whatwg.org/multipage/server-sent-events.html)\nwire format (`text/event-stream`) via native serializer and parser implementations under\n`org.apache.juneau.marshall.sse`. SSE is the one-way push channel used by browsers (`EventSource`) and\nmost LLM streaming APIs (OpenAI, Anthropic, etc.) for progress events, partial responses,\nheartbeats, and other long-lived telemetry feeds.\n\nThe <a href=\"/site/apido [...]
{"description": "Juneau exposes a public low-level streaming API that complements the POJO databind path\n(<code>Serializer.serialize(...)</code> / <code>Parser.parse(...)</code>) with cursor-based\npush and pull primitives. Two surfaces, layered:\n\n##### Surfaces at a glance\n\n| Surface | Returns | Methods | When to use |\n|---|---|---|---|\n| <a href=\"/site/apidocs/org/apache/juneau/marshall/stream/RecordReader.html\" target=\"_blank\">RecordReader</a> / <a href=\"/site/apidocs/org/ [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/stream/RecordReader.html\" target=\"_blank\">RecordReader</a> /\n<a href=\"/site/apidocs/org/apache/juneau/marshall/stream/RecordWriter.html\" target=\"_blank\">RecordWriter</a>\nsurface yields one whole-value record per call. It works uniformly across every Juneau format\nthat implements the <a href=\"/site/apidocs/org/apache/juneau/marshall/stream/RecordReadable.html\" target=\"_blank\">RecordReadable</a> /\n<a hre [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/stream/TokenReader.html\" target=\"_blank\">TokenReader</a> /\n<a href=\"/site/apidocs/org/apache/juneau/marshall/stream/TokenWriter.html\" target=\"_blank\">TokenWriter</a>\nsurface exposes structural events one at a time \u2014 `START_OBJECT`, `FIELD_NAME`, `VALUE_STRING`,\n`END_OBJECT`, etc. \u2014 for formats whose wire encoding is already token-shaped.\n\nAvailable on formats that implement the <a href=\"/site/a [...]
-{"description": "The `parseArrayRecords(...)` / `serializeArrayRecords(...)` factories \u2014 declared by the\n<a href=\"/site/apidocs/org/apache/juneau/marshall/stream/ArrayRecordReadable.html\" target=\"_blank\">ArrayRecordReadable</a> /\n<a href=\"/site/apidocs/org/apache/juneau/marshall/stream/ArrayRecordWritable.html\" target=\"_blank\">ArrayRecordWritable</a>\nroles \u2014 yield a multi-record cursor over the **elements of a top-level wire array**, without\nmaterializing the whole [...]
-{"description": "`TokenReader`, `TokenWriter`, `RecordReader`, and `RecordWriter` are first-class\n`@RestOp`-method parameter types. Declare one in your method signature and the framework picks\nthe matching parser/serializer based on the request `Content-Type` / response `Accept` and\nhands you the cursor.\n\n> See the <a href=\"/site/topics/TokenStreamingBasics#per-format-capability-matrix\">per-format capability matrix</a>\n> for which formats can satisfy a `RecordReader` / `TokenRead [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/stream/RecordReader.html\" target=\"_blank\">RecordReader</a> /\n<a href=\"/site/apidocs/org/apache/juneau/marshall/stream/RecordWriter.html\" target=\"_blank\">RecordWriter</a>\nsurface yields one whole-value record per call. It works uniformly across every Juneau format\nthat implements the <a href=\"/site/apidocs/org/apache/juneau/marshall/stream/RecordReadable.html\" target=\"_blank\">RecordReadable</a> /\n<a hre [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/stream/TokenReader.html\" target=\"_blank\">TokenReader</a> /\n<a href=\"/site/apidocs/org/apache/juneau/marshall/stream/TokenWriter.html\" target=\"_blank\">TokenWriter</a>\nsurface exposes structural events one at a time \u2014 `START_OBJECT`, `FIELD_NAME`, `VALUE_STRING`,\n`END_OBJECT`, etc. \u2014 for formats whose wire encoding is already token-shaped.\n\nAvailable on formats that implement the <a href=\"/site/a [...]
+{"description": "The `parseArrayRecords(...)` / `serializeArrayRecords(...)` factories \u2014 declared by the\n<a href=\"/site/apidocs/org/apache/juneau/marshall/stream/ArrayRecordReadable.html\" target=\"_blank\">ArrayRecordReadable</a> /\n<a href=\"/site/apidocs/org/apache/juneau/marshall/stream/ArrayRecordWritable.html\" target=\"_blank\">ArrayRecordWritable</a>\nroles \u2014 yield a multi-record cursor over the **elements of a top-level wire array**, without\nmaterializing the whole [...]
+{"description": "`TokenReader`, `TokenWriter`, `RecordReader`, and `RecordWriter` are first-class\n`@RestOp`-method parameter types. Declare one in your method signature and the framework picks\nthe matching parser/serializer based on the request `Content-Type` / response `Accept` and\nhands you the cursor.\n\n> See the <a href=\"/docs/topics/TokenStreamingBasics#per-format-capability-matrix\">per-format capability matrix</a>\n> for which formats can satisfy a `RecordReader` / `TokenRead [...]
{"description": "- Reuse instances of serializers and parsers whenever possible. \nThey are designed to be thread safe and maintain internal caches of bean metadata to increase performance.\n\n- The <a href=\"/site/apidocs/org/apache/juneau/MarshallingTraverseContext.Builder.html#detectRecursions()\" target=\"_blank\">MarshallingTraverseContext.Builder.detectRecursions()</a> option can cause a performance penalty of around 20%.\nTherefore, it's recommended that this option be used only [...]
-{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-marshall-rdf</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-marshall-rdf-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.marshall.marshaller.rdf_0.0.0.jar\n```\n\n#### Contents/Features\n\nThe `juneau-marshall-rdf` library provides additional serializers and parsers for RDF.\nT [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-marshall-rdf</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-marshall-rdf-0.0.0.jar\n```\n\n### OSGi Module\n\n```text\norg.apache.juneau.marshall.marshaller.rdf_0.0.0.jar\n```\n\n### Contents/Features\n\nThe `juneau-marshall-rdf` library provides additional serializers and parsers for RDF.\nThese [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/marshaller/package-summary.html\" target=\"_blank\">org.apache.juneau.marshall.marshaller</a> and\n<a href=\"/site/apidocs/org/apache/juneau/marshall/jena/package-summary.html\" target=\"_blank\">org.apache.juneau.marshall.jena</a> packages provide\nRDF (Resource Description Framework) serializers and parsers for converting POJOs to and from RDF formats.\nThese rely on the Apache Jena library and support both text-ba [...]
{"description": "The RDF serializers convert POJOs into RDF representations. The module provides both character-based serializers (text formats) and stream-based serializers (RDF/THRIFT and RDF/PROTO binary formats).\n\n##### Text-Based Serializers\n\n| Class | Format | Output |\n|---|---|---|\n| <a href=\"/site/apidocs/org/apache/juneau/marshall/jena/RdfXmlSerializer.html\" target=\"_blank\">RdfXmlSerializer</a> | RDF/XML | String |\n| <a href=\"/site/apidocs/org/apache/juneau/marshall/ [...]
{"description": "The RDF parsers convert RDF input (text or binary) into POJOs. The module provides character-based parsers for all text RDF formats and stream-based parsers for RDF/THRIFT and RDF/PROTO binary formats.\n\n##### Text-Based Parsers\n\n| Class | Format | Input |\n|---|---|---|\n| <a href=\"/site/apidocs/org/apache/juneau/marshall/jena/RdfXmlParser.html\" target=\"_blank\">RdfXmlParser</a> | RDF/XML | String, Reader |\n| <a href=\"/site/apidocs/org/apache/juneau/marshall/jen [...]
-{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-bean</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-bean-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.bean_0.0.0.jar\n```\n\n#### Contents/Features\n- Predefined POJOs for generating commonly-used document types.", "id": "topic:94e763732154", "module": "01", "related_ids": [ [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-bean</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-bean-0.0.0.jar\n```\n\n### OSGi Module\n\n```text\norg.apache.juneau.bean_0.0.0.jar\n```\n\n### Contents/Features\n- Predefined POJOs for generating commonly-used document types.", "id": "topic:94e763732154", "module": "01", "related_ids": [], " [...]
{"description": "The Juneau HTML5 DTO beans are simply beans with fluent-style setters that allow you to quickly construct HTML fragments as\nJava objects.\nThese object can then be serialized to HTML using one of the existing HTML serializers, or to other languages such as\nJSON using the JSON serializers.\nThe <a href=\"/site/apidocs/org/apache/juneau/bean/html5/HtmlBuilder.html\" target=\"_blank\">HtmlBuilder</a> class is a utility class with predefined\nstatic methods that allow you [...]
{"description": "The Juneau ATOM feed DTO beans are simply beans with fluent-style setters.\n\nThe following code shows a feed being created programmatically using the <a href=\"/site/apidocs/org/apache/juneau/bean/atom/AtomBuilder.html\" target=\"_blank\">AtomBuilder</a> class.\n\n```java\nimport static org.apache.juneau.bean.atom.AtomBuilder.*;\n\nFeed feed =\n feed(\"tag:juneau.apache.org\", \"Juneau ATOM specification\", \"2016-01-02T03:04:05Z\")\n .setSubtitle(text(\"html\").s [...]
{"description": "# juneau-bean-jsonschema\n\nThe `juneau-bean-jsonschema` module provides Java beans for working with JSON Schema documents following the **JSON Schema Draft 2020-12** specification.\n\n## Overview\n\nThis module contains predefined POJOs for representing and manipulating JSON Schema documents programmatically. These beans can be serialized to any format supported by Juneau (JSON, XML, HTML, etc.), making it easy to generate and consume JSON Schema documents in your appli [...]
@@ -247,7 +250,7 @@
{"description": "# juneau-bean-hal\n\nThe `juneau-bean-hal` module provides Java beans for the [HAL (Hypertext Application Language)](https://stateless.group/hal_specification.html) hypermedia format, also described in [draft-kelly-json-hal-08](https://datatracker.ietf.org/doc/html/draft-kelly-json-hal-08). HAL is a JSON-based wire format that lets a REST API describe its resources alongside the links and embedded sub-resources that surround them.\n\n## Overview\n\nHAL standardises two r [...]
{"description": "# juneau-bean-jsonapi\n\nThe `juneau-bean-jsonapi` module provides Java beans for the [JSON:API v1.1](https://jsonapi.org/format/) wire format, used by APIs that serve `application/vnd.api+json`. JSON:API standardises a document shape, resource objects, relationships, errors, and link semantics so clients and servers can interoperate without ad-hoc per-API conventions.\n\n## Overview\n\nThis module models the JSON:API wire format as typed `@Marshalled` POJOs that round-t [...]
{"description": "# juneau-bean-jsonpatch\n\nThe `juneau-bean-jsonpatch` module provides Java beans for [JSON Patch (RFC 6902)](https://datatracker.ietf.org/doc/html/rfc6902), the canonical patch document format used by `application/json-patch+json`. A JSON Patch document is a JSON array of operation objects describing changes (add, remove, replace, move, copy, test) to apply to a target JSON document.\n\n## Overview\n\nThis module models the JSON Patch wire format as typed `@Marshalled` [...]
-{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-config</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-config-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.config_0.0.0.jar\n```\n\n#### Contents/Features\n\nThe `juneau-config` library contains a powerful API for creating and using INI-style config files.\n\n**Key Capabiliti [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-config</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-config-0.0.0.jar\n```\n\n### OSGi Module\n\n```text\norg.apache.juneau.config_0.0.0.jar\n```\n\n### Contents/Features\n\nThe `juneau-config` library contains a powerful API for creating and using INI-style config files.\n\n**Key Capabilities:* [...]
{"description": "The `juneau-config` library contains a powerful API for creating and using INI-style config files.\n\n:::tip Example configuration file\n```ini\n# A set of entries\n[Section1]\n\n# An integer\nkey1 = 1\n\n# A boolean\nkey2 = true\n\n# An array\nkey3 = 1,2,3\n\n# A POJO\nkey4 = http://bar\n```\n:::\n\nConfig files are accessed through the <a href=\"/site/apidocs/org/apache/juneau/config/Config.html\" target=\"_blank\">Config</a> class which are \ncreated through the <a hr [...]
{"description": "Each config file contains zero or more sections containing zero or more entries:\n\n```ini\n[Section1]\nkey1 = 1\n\n[Section2]\nkey1 = 2\n```\n\nUnicode escapes can be used in values.\n\n```ini\nkey1 = \\u0070\\u0075\\u0062\\u006c\\u0069\\u0063\n```\n\nComment lines start with the '#' character and can be placed on lines before sections and entries:\n\n```ini\n# A comment about this section\n[Section1]\n\n# A comment about this entry\nkey1 = 1\n```\n\nComments can also b [...]
{"description": "Configuration files can contain entries for anything from primitive types up to complex hierarchies of POJOs consisting\nof `Maps`, `Collections`, and/or beans.\n\nEntries are accessed via the <a href=\"/site/apidocs/org/apache/juneau/config/Config.html#get(java.lang.String)\" target=\"_blank\">Config.get(String)</a> method\nwhich returns the following bean:\n\n<tree>\n<node-0><javac-class><a href=\"/site/apidocs/org/apache/juneau/config/Entry.html\" target=\"_blank\">En [...]
@@ -269,67 +272,70 @@
{"description": "Configurations can import values from other configurations using the following syntax:\n\n```ini\n# Import values from configuration 'ParentConfig'\n<ParentConfig>\n\n# Our normal section\n[Section1]\n...\n```\n\nA configuration can contain zero or more imports anywhere in the file.\nHowever, for clarity, imports should normally be placed in the default section of the configuration file.\nThe resolved configuration is retrieved from the configuration store used for the c [...]
{"description": "Configuration files are stored in entities called Stores.\n\nThe methods that need to be implemented on a store are:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/store/ConfigStore.html\" target=\"_blank\">ConfigStore</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/store/ConfigStore.html#read(java.lang.String)\" target=\"_blank\">read(String)</a></java-method></node-1>\n<node-1><java-metho [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/config/store/MemoryStore.html\" target=\"_blank\">MemoryStore</a> class is simply an in-memory storage\nlocation for configuration files.\n\nThere is no hard persistence and is used primarily for testing purposes.\nHowever, the implementation provides a good idea on how stores work (especially the write method):\n\n```java\npublic class MemoryStore extends ConfigStore {\n\n // Some methods ommitted.\n\n private final Co [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/config/store/FileStore.html\" target=\"_blank\">FileStore</a> is the typical store used for configuration\nfiles.\n\nIt provides the following configurable settings:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/store/FileStore.Builder.html\" target=\"_blank\">FileStore.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/store/FileStore.Bui [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/config/store/FileStore.html\" target=\"_blank\">FileStore</a> is the typical store used for configuration\nfiles.\n\nIt provides the following configurable settings:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/store/FileStore.Builder.html\" target=\"_blank\">FileStore.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/store/FileStore.Bui [...]
{"description": "The `ConfigStore` API has been written to allow easy development of custom configuration storage classes.\nThe example below shows a starting point for an implementation based on polling a relational database.\nThe source can be found here: <a href=\"/site/apidocs/org/apache/juneau/examples/core/config/store/SqlStore.html\" target=\"_blank\">SqlStore</a>.\n\nCompleting it is left as an exercise:\n\n:::tip Example Store Class\n```java\npublic class SqlStore extends Config [...]
{"description": "The `ConfigStore` class has the following listener methods:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/store/ConfigStore.html\" target=\"_blank\">ConfigStore</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/store/ConfigStore.html#register(java.lang.String,org.apache.juneau.config.store.ConfigStoreListener)\" target=\"_blank\">register(String,ConfigStoreListener)</a></java-method></node-1 [...]
{"description": "The following settings can be used to create read-only `Config` objects:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/Config.Builder.html\" target=\"_blank\">Config.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/Config.Builder.html#readOnly()\" target=\"_blank\">readOnly()</a></java-method></node-1>\n</tree>\n\n:::tip Example\n```java\n// Create a read-only config\nConfig config [...]
{"description": "In general, it's good practice to close Config if you're only creating them temporarily so that their listeners get\nunregistered from the underlying storage APIs.\n\n:::tip Example\n```java\n// Create a transient config.\nConfig config = Config.create(\"MyConfig.cfg\").build();\n\n// Do stuff with it.\n\n// Then close the config to unregister the listeners.\nconfig.close();\n```\n:::", "id": "topic:2edb2acc6c2e", "module": "13", "related_ids": [], "source_path": "pages/ [...]
{"description": "Each JVM has a system default config.\nThis is a configuration file that serves as the default configuration for the system.\nIt's accessed using the following static methods:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/config/Config.html\" target=\"_blank\">Config</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/config/Config.html#getSystemDefault()\" target=\"_blank\">getSystemDefault()</a></java-met [...]
-{"description": "# YAML Config Files\n\n`juneau-config` now supports YAML config files as an alternative to INI/CFG files.\n\n## Enabling YAML\n\nUse a `.yml` or `.yaml` config name to auto-select YAML format:\n\n```java\nConfig c = Config.create()\n\t.name(\"MyConfig.yaml\")\n\t.build();\n```\n\nYou can also force YAML explicitly:\n\n```java\nConfig c = Config.create()\n\t.name(\"MyConfig.cfg\")\n\t.yaml()\n\t.build();\n```\n\n## Section path mapping\n\nINI section paths map directly to [...]
-{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-commons</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-commons-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.common_0.0.0.jar\n```\n\n#### Contents/Features\n\nThe `juneau-commons` module provides common utilities and APIs used across the Juneau ecosystem.\n\n**Key Packages:* [...]
-{"description": "The `org.apache.juneau.commons.collections` package provides enhanced collection utilities that extend the standard Java Collections Framework with fluent APIs, specialized collection types, and caching capabilities.\n\n## Key Classes\n\n### Collection Builders\n\n#### <java-class><a href=\"/site/apidocs/org/apache/juneau/commons/collections/Lists.html\" target=\"_blank\">Lists</a></java-class>\nFluent builder for constructing `List` instances with various configuration [...]
+{"description": "`juneau-config` now supports YAML config files as an alternative to INI/CFG files.\n\n## Enabling YAML\n\nUse a `.yml` or `.yaml` config name to auto-select YAML format:\n\n```java\nConfig c = Config.create()\n\t.name(\"MyConfig.yaml\")\n\t.build();\n```\n\nYou can also force YAML explicitly:\n\n```java\nConfig c = Config.create()\n\t.name(\"MyConfig.cfg\")\n\t.yaml()\n\t.build();\n```\n\n## Section path mapping\n\nINI section paths map directly to nested YAML maps:\n\n` [...]
+{"description": "Starting in **10.0.0**, Juneau's config system supports two cloud-native ergonomics borrowed from the Spring Boot\nworld: **environment profiles** (`<name>-<profile>` config overlays) and **relaxed binding** (one logical key\nresolvable from any common environment-variable spelling). Both are opt-in-friendly and change no existing behavior\nby default.\n\n## Config profiles\n\nA *profile* layers an environment-specific overlay (`dev` / `stage` / `prod`, etc.) on top of a [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-commons</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-commons-0.0.0.jar\n```\n\n### OSGi Module\n\n```text\norg.apache.juneau.common_0.0.0.jar\n```\n\n### Contents/Features\n\nThe `juneau-commons` module provides common utilities and APIs used across the Juneau ecosystem.\n\n**Key Packages:**\n\ [...]
+{"description": "The `org.apache.juneau.commons.collections` package provides enhanced collection utilities that extend the standard Java Collections Framework with fluent APIs, specialized collection types, and caching capabilities.\n\n## Key Classes\n\n### Collection Builders\n\n### <java-class><a href=\"/site/apidocs/org/apache/juneau/commons/collections/Lists.html\" target=\"_blank\">Lists</a></java-class>\nFluent builder for constructing `List` instances with various configuration o [...]
{"description": "The `org.apache.juneau.commons.utils` package provides general-purpose utility classes for common operations including string manipulation, collection operations, class utilities, file operations, and more.\n\n## Key Classes\n\n### <java-class><a href=\"/site/apidocs/org/apache/juneau/commons/utils/Utils.html\" target=\"_blank\">Utils</a></java-class>\nCommon utility methods for working with collections, strings, objects, and other common operations.\n\n```java\nimport s [...]
{"description": "The `org.apache.juneau.commons.reflect` package provides comprehensive reflection utilities for working with classes, methods, fields, constructors, and annotations in a more convenient and type-safe way than the standard Java reflection APIs.\n\n## Key Classes\n\n### <java-class><a href=\"/site/apidocs/org/apache/juneau/commons/reflect/ReflectionUtils.html\" target=\"_blank\">ReflectionUtils</a></java-class>\nUtility class providing convenient static methods for creatin [...]
{"description": "The `org.apache.juneau.commons.settings` package provides a thread-safe way to access system properties with support for global and per-thread overrides, making it useful for unit tests and configuration management.\n\n## Key Classes\n\n### <java-class><a href=\"/site/apidocs/org/apache/juneau/commons/settings/Settings.html\" target=\"_blank\">Settings</a></java-class>\nEncapsulates Java system properties with support for global and per-thread overrides.\n\n```java\n// G [...]
-{"description": "The `org.apache.juneau.commons.lang` package provides language utilities including value wrappers, version management, string formatting, state enums, and other common language constructs.\n\n## Key Classes\n\n### <java-class><a href=\"/site/apidocs/org/apache/juneau/commons/lang/Value.html\" target=\"_blank\">Value</a></java-class>\nA generic mutable value wrapper.\n\n```java\n// Basic usage\nValue<String> name = Value.of(\"John\");\nname.set(\"Jane\");\nString result = [...]
+{"description": "The `org.apache.juneau.commons.lang` package provides language utilities including value wrappers, version management, string formatting, state enums, and other common language constructs.\n\n## Key Classes\n\n### <java-class><a href=\"/site/apidocs/org/apache/juneau/commons/lang/Value.html\" target=\"_blank\">Value</a></java-class>\nA generic mutable value wrapper.\n\n```java\n// Basic usage\nValue<String> name = Value.of(\"John\");\nname.set(\"Jane\");\nString result = [...]
{"description": "The `org.apache.juneau.commons.io` package provides file and stream utilities, console support, MIME type detection, and path builders for working with files and I/O operations.\n\n## Key Classes\n\n### <java-class><a href=\"/site/apidocs/org/apache/juneau/commons/io/LocalFile.html\" target=\"_blank\">LocalFile</a></java-class>\nRepresents a file that can be located either on the classpath or in the file system.\n\n```java\n// Classpath file\nLocalFile classpathFile = ne [...]
{"description": "The `org.apache.juneau.commons.inject` package provides Juneau's lightweight injection model. The framework is **JSR-330\u2013aligned** (`jakarta.inject` / `javax.inject`) and layers a small set of Spring-flavored conveniences (`@Bean`, `@Configuration`, `@Primary`, `@Order`, `@Conditional`) on top \u2014 all under Juneau-owned annotations, and **without a compile-time dependency on `jakarta.inject-api` or `jakarta.annotation-api`**.\n\n> Juneau supports JSR-330 (`jakart [...]
-{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-assertions</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-assertions-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.assertions_0.0.0.jar\n```\n\n#### Contents/Features\n\nThe <a href=\"/site/apidocs/org/apache/juneau/assertions/package-summary.html\" target=\"_blank\">org.apac [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/assertions/package-summary.html\" target=\"_blank\">org.apache.juneau.assertions</a> package in Juneau is a powerful API for performing\nfluent style assertions.\nIt is used throughout the REST client and server APIs for performing inline assertions on REST requests and responses.\n\n:::tip Example\n```java\n// Create a basic REST client with JSON support and download a bean.\nMyBean bean = RestClient.create()\n .json5()\n [...]
-{"description": "# Bean-Centric Testing Framework\n\nA powerful and intuitive testing framework that extends JUnit with streamlined assertion methods for Java objects. BCT eliminates verbose test code while providing comprehensive object introspection and comparison capabilities.\n\n## \ud83d\udccb Table of Contents\n\n- [Overview](#overview)\n- [Quick Start](#quick-start)\n- [Core Assertion Methods](#core-assertion-methods)\n- [Nested Property Access](#nested-property-access)\n- [Advanc [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-test</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-test-0.0.0.jar\n```\n\n### OSGi Module\n\n```text\norg.apache.juneau.test_0.0.0.jar\n```\n\n### Contents/Features\n\nThe <a href=\"/site/apidocs/org/apache/juneau/test/assertions/package-summary.html\" target=\"_blank\">org.apache.juneau.test.as [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/test/assertions/package-summary.html\" target=\"_blank\">org.apache.juneau.test.assertions</a> package in Juneau is a powerful API for performing\nfluent style assertions.\nIt is used throughout the REST client and server APIs for performing inline assertions on REST requests and responses.\n\n:::tip Example\n```java\n// Create a basic REST client with JSON support and download a bean.\nMyBean bean = RestClient.create()\n [...]
+{"description": "# Bean-Centric Testing Framework\n\nA powerful and intuitive testing framework that extends JUnit with streamlined assertion methods for Java objects. BCT eliminates verbose test code while providing comprehensive object introspection and comparison capabilities.\n\n## \ud83d\udccb Table of Contents\n\n- [Overview](#overview)\n- [Quick Start](#quick-start)\n- [Core Assertion Methods](#core-assertion-methods)\n- [Nested Property Access](#nested-property-access)\n- [Advanc [...]
{"description": "# Custom Error Messages\n\nCustom error messages allow you to provide contextual information when BCT assertions fail. This makes test failures more informative and helps identify issues faster during debugging.\n\n## Overview\n\nBCT supports custom error messages through a `Supplier<String>` parameter in all assertion methods. This provides:\n- **Lazy evaluation** - Messages are only generated when assertions fail\n- **Format support** - Use `Utils.fs()` for convenient [...]
-{"description": "# Customization\n\nBCT provides flexible customization options through the `@BctConfig` annotation and the `BctConfiguration` class. These tools allow you to configure assertion behavior, customize property access, and extend BCT's capabilities to match your testing needs.\n\n## \ud83d\udccb Table of Contents\n\n- [@BctConfig Annotation](#bctconfig-annotation)\n- [BctConfiguration Class](#bctconfiguration-class)\n- [Configuration Properties](#configuration-properties)\n- [...]
+{"description": "# Customization\n\nBCT provides flexible customization options through the `@BctConfig` annotation and the `BctConfiguration` class. These tools allow you to configure assertion behavior, customize property access, and extend BCT's capabilities to match your testing needs.\n\n## \ud83d\udccb Table of Contents\n\n- [@BctConfig Annotation](#bctconfig-annotation)\n- [BctConfiguration Class](#bctconfiguration-class)\n- [Configuration Properties](#configuration-properties)\n- [...]
{"description": "# Stringifiers\n\nStringifiers define how specific types should be converted to strings for comparison in BCT assertions. They provide flexible, customizable string representations that can be tailored to your testing needs.\n\n## Built-in Stringifiers\n\nBCT comes with comprehensive built-in stringifiers for common Java types:\n\n```java\n// Array types\nchar[] chars = {'H', 'e', 'l', 'l', 'o'};\nassertString(\"Hello\", chars); // Uses charArrayStringifier()\n\nbyte[] [...]
{"description": "# Listifiers\n\nListifiers convert collection-like objects into lists for use in BCT assertions. They provide a unified way to work with various collection types, iterators, streams, and other iterable data structures.\n\n## Built-in Listifiers\n\nBCT comes with comprehensive built-in listifiers for collection-like Java types:\n\n```java\n// Collection types\nList<String> list = List.of(\"a\", \"b\", \"c\");\nassertList(list, \"a\", \"b\", \"c\"); // Uses collectionList [...]
{"description": "# Swappers\n\nSwappers transform objects before they are processed by BCT assertions. They provide a way to unwrap, evaluate, or transform objects into more testable forms. Swappers are particularly useful for wrapper types like Optional, Supplier, and Future.\n\n## Built-in Swappers\n\nBCT comes with built-in swappers for common wrapper and lazy-evaluation types:\n\n```java\n// Optional types\nOptional<String> optional = Optional.of(\"Hello\");\nassertString(\"Hello\", [...]
{"description": "# Property Extractors\n\nProperty extractors define custom property access logic for objects that don't follow standard JavaBean patterns or require specialized property extraction. They provide a flexible way to access properties from any object structure.\n\n## Overview\n\nProperty extractors are used when:\n- Objects don't follow JavaBean getter conventions\n- You need to compute properties dynamically\n- You want to provide custom property names or aliases\n- Objects [...]
-{"description": "`juneau-rest-common` ships as two sibling Maven artifacts:\n\n| Artifact | Contents | Apache HttpClient 4.5 dependency? |\n|---|---|---|\n| `juneau-rest-common` | Transport-neutral types under `org.apache.juneau.http.*` and `org.apache.juneau.http.remote.*` \u2014 annotations, lazy header beans, remote-proxy meta, transport-neutral parts. Used by every `juneau-rest-*` module. | **No.** Zero `org.apache.httpcomponents:*` on the classpath. |\n| `juneau-rest-common-classic` [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/header/package-summary.html\" target=\"_blank\">org.apache.juneau.http.header</a> package contains various convenience classes for creating\nstandard HTTP components using static imports.\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/http/HttpHeaders.html\" target=\"_blank\">HttpHeaders</a></java-class> - Utility class for standard HTTP headers.</node-0>\n<node-0><java-class><a href=\"/site/api [...]
+{"description": "# JUnit 5 Extensions\n\nThe `juneau-test` module bundles a small JUnit 5 extension (formerly the standalone `juneau-junit5` module) for **test-time bean injection** \u2014 swapping production beans with test doubles inside a Juneau `BeanStore` for the duration of a JUnit 5 test, without modifying production code and without proxying. It is the Juneau-flavored answer to Spring's `@TestConfiguration` / `@MockBean`.\n\nThe extension lives in the <a href=\"/site/apidocs/org/ [...]
+{"description": "`juneau-rest-common` ships as two sibling Maven artifacts:\n\n| Artifact | Contents | Apache HttpClient 4.5 dependency? |\n|---|---|---|\n| `juneau-rest-common` | Transport-neutral types under `org.apache.juneau.http.*` and `org.apache.juneau.http.remote.*` \u2014 annotations, lazy header beans, remote-proxy meta, transport-neutral parts. Used by every `juneau-rest-*` module. | **No.** Zero `org.apache.httpcomponents:*` on the classpath. |\n| `juneau-rest-common-classic` [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/header/package-summary.html\" target=\"_blank\">org.apache.juneau.http.header</a> package contains various convenience classes for creating\nstandard HTTP components using static imports.\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/http/HttpHeaders.html\" target=\"_blank\">HttpHeaders</a></java-class> - Utility class for standard HTTP headers.</node-0>\n<node-0><java-class><a href=\"/site/api [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/package-summary.html\" target=\"_blank\">org.apache.juneau.http</a> package contains annotations for defining both\nserver and client side APIs.\n\nThe server-side APIs also use it for producing auto-generated Swagger documentation through the REST API itself.\n\n<tree>\n<node-0><javac-annotation><a href=\"/site/apidocs/org/apache/juneau/http/Contact.html\" target=\"_blank\">Contact</a></javac-annotation> <javac-annotati [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/header/package-summary.html\" target=\"_blank\">org.apache.juneau.http.header</a> package contains implementations of\n`org.apache.http.Header` for all common HTTP headers.\n\n<tree>\n<node-0><javac-class><a href=\"/site/apidocs/org/apache/juneau/http/header/Accept.html\" target=\"_blank\">Accept</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/http/header/AcceptCharset.html\" target=\"_blank\">Ac [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/part/package-summary.html\" target=\"_blank\">org.apache.juneau.http.part</a> package contains implementations of\n`org.apache.http.NameValuePair` to be used for query/form-data/path parts and part lists.\n\n<tree>\n<node-0><java-interface><a href=\"https://hc.apache.org/httpcomponents-core-4.4.x/current/httpcore/apidocs/org/apache/http/NameValuePair.html\" target=\"_blank\">NameValuePair</a></java-interface></node-0>\n< [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/part/package-summary.html\" target=\"_blank\">org.apache.juneau.http.part</a> package contains implementations of\n`org.apache.http.NameValuePair` to be used for query/form-data/path parts and part lists.\n\n<tree>\n<node-0><java-interface><a href=\"https://hc.apache.org/httpcomponents-core-4.4.x/current/httpcore/apidocs/org/apache/http/NameValuePair.html\" target=\"_blank\">NameValuePair</a></java-interface></node-0>\n< [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/entity/package-summary.html\" target=\"_blank\">org.apache.juneau.http.entity</a> package contains implementations of\n`org.apache.http.HttpEntity`.\nThese are entities that can be sent or received with an HTTP message.\nThey consist of a message body and the headers `Content-Type`, `Content-Length`, and `Content-Encoding`.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/http/resource/package-summary.html\" target=\"_bl [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/response/package-summary.html\" target=\"_blank\">org.apache.juneau.http.response</a> package contains predefined\n`org.apache.http.HttpResponse` implementations for most standard HTTP responses.\n\n<tree>\n<node-0><javac-class><a href=\"/site/apidocs/org/apache/juneau/http/response/Accepted.html\" target=\"_blank\">Accepted</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/http/response/AlreadyRep [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/remote/package-summary.html\" target=\"_blank\">org.apache.juneau.http.remote</a> package contains the annotations used for defining\nclient-side remote proxies.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/Remote.html\" target=\"_blank\">Remote</a></java-annotation></node-0>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteGet.html\" targe [...]
-{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-server</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-rest-server-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.rest.server_0.0.0.jar\n```\n\nThe `juneau-rest-server` library allows you to quickly wrap POJOs and expose them as full-fledged REST resources served up\nin a [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-server</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-rest-server-0.0.0.jar\n```\n\n### OSGi Module\n\n```text\norg.apache.juneau.rest.server_0.0.0.jar\n```\n\nThe `juneau-rest-server` library allows you to quickly wrap POJOs and expose them as full-fledged REST resources served up\nin a ser [...]
{"description": "A REST resource is simply a Java class annotated with <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html\" target=\"_blank\">@Rest</a>.\nThe most common case is a class that extends <a href=\"/site/apidocs/org/apache/juneau/rest/server/servlet/BasicRestServlet.html\" target=\"_blank\">BasicRestServlet</a>, which itself is simply an extension of <a href=\"https://jakarta.ee/specifications/servlet/6.0/apidocs/jakarta/servlet/http/HttpServlet.html\" target=\"_b [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html\" target=\"_blank\">@Rest</a> annotation is the primary way of defining and\nconfiguring REST resource classes.\n\nThe functionality of the class itself is covered in detail in the topics later.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html\" target=\"_blank\">Rest</a></java-annotation></node-0>\n<node-1><javac-method-annotation><a href=\"/site/apidoc [...]
{"description": "The following example represents the bare-minimum needed for deploying a top-level REST endpoint with basic JSON\nmarshalling support:\n\n```java\n@Rest(\n path=\"/mypath\",\n serializers=JsonSerializer.class,\n parsers=JsonParser.class\n)\npublic class MyResource extends RestServlet {\n\n @RestGet(path=\"/\")\n public Object getPojo() {\n ...\n }\n}\n```\n\nThe <a href=\"/site/apidocs/org/apache/juneau/rest/server/servlet/RestServlet.html\" targ [...]
-{"description": "Child Resources are REST servlets or objects that are linked to parent resources through the <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html#children()\" target=\"_blank\">@Rest(children)</a> annotation.\n\n:::tip Example\n```java\n/** Parent Resource */\n@Rest(\n path=\"/parent\",\n children={MyChildResource.class}\n)\npublic MyRootResources extends BasicRestServletGroup {...}\n```\n\n```java\n/** Child Resource */\n@Rest(\n path=\"/child\" // [...]
+{"description": "Child Resources are REST servlets or objects that are linked to parent resources through the <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html#children()\" target=\"_blank\">@Rest(children)</a> annotation.\n\n:::tip Example\n```java\n/** Parent Resource */\n@Rest(\n path=\"/parent\",\n children={MyChildResource.class}\n)\npublic MyRootResources extends BasicRestServletGroup {...}\n```\n\n```java\n/** Child Resource */\n@Rest(\n path=\"/child\" // [...]
{"description": "The path can contain variables that get resolved to <a href=\"/site/apidocs/org/apache/juneau/http/Path.html\" target=\"_blank\">@Path</a>\nparameters or access through the <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestRequest.html#getPathParams()\" target=\"_blank\">RestRequest.getPathParams()</a> method.\n\n:::tip Example\n```java\n@Rest(\n path=\"/myResource/{foo}/{bar}\"\n)\npublic class MyResource extends BasicRestServlet {\n\n @RestPost(\"/{baz}\" [...]
{"description": "REST resources are deployed in the following ways:\n\n- Deployed in a J2EE container as a servlet.\n- Deployed in a Spring Boot environment as a servlet.\n- Deployed as a child of another REST resource.\n\nWhen deployed in a J2EE container, you MUST extend from one of the servlet classes.\n\n:::note\nWhen deployed as a child of another resource, you MAY extend from one of the servlet classes but it's not necessary.\nThe only requirement is that the class be annotated wit [...]
-{"description": "Lifecycle hooks allow you to hook into lifecycle events of the servlet/resource creation and REST calls.\n\nFor example, if you want to add an initialization method to your resource:\n\n```java\n@Rest(...)\npublic class MyResource extends BasicRestObject {\n\n // Our database.\n private Map myDatabase;\n\n @RestInit\n public void initMyDatabase() throws Exception {\n myDatabase = new LinkedHashMap();\n }\n}\n```\n\n:::note 9.5 change\nAny lifecycle [...]
+{"description": "Lifecycle hooks allow you to hook into lifecycle events of the servlet/resource creation and REST calls.\n\nFor example, if you want to add an initialization method to your resource:\n\n```java\n@Rest(...)\npublic class MyResource extends BasicRestResource {\n\n // Our database.\n private Map myDatabase;\n\n @RestInit\n public void initMyDatabase() throws Exception {\n myDatabase = new LinkedHashMap();\n }\n}\n```\n\n:::note 9.5 change\nAny lifecycl [...]
{"description": "REST Java methods are identified on REST servlets using the <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html\" target=\"_blank\">@RestOp</a> annotation.\n\nThe annotation allows the framework to identify the available REST methods through reflection.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html\" target=\"_blank\">RestOp</a></java-annotation></node-0>\n<node-1><javac-method-annotation><a href=\"/si [...]
{"description": "When the `name` and/or `path` values are not specified, their values are inferred from the Java method name.\n\nThe HTTP method can be inferred from the Java method by starting the method name with any of the following:\n\n- `get`\n- `put`\n- `post`\n- `delete`\n- `options`\n- `head`\n- `trace`\n- `patch`\n\nIf `path` is not defined, it's inferred from the Java method name (minus the prefix above).\n\n:::tip Examples\n```java\n// Method=\"GET\", path=\"/foo\"\n@RestOp\np [...]
{"description": "Java methods can contain any of the following parameters in any order:\n\n<tree>\n<node-0>**Parameters based on class types:**</node-0>\n<node-1>**Request objects:**</node-1>\n<node-2><javac-class>`AsyncContext`</javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/rest/server/arg/CookieList.html\" target=\"_blank\">CookieList</a></javac-class> <javac-class>`DispatcherType`</javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/httppart/HttpP [...]
-{"description": "The return type of the Java method can be any serializable POJO as defined in [POJO Categories](/docs/topics/PojoCategories).\n\nIt can also be void if the method is not sending any output (e.g a request redirect) or is setting the output using the <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestResponse.html#setContent(java.lang.Object)\" target=\"_blank\">RestResponse.setContent(Object)</a> method.\n\n:::tip Example\n```java\n@RestGet\npublic String doGet() [...]
-{"description": "Annotated Java methods can throw any of the following:\n\n#### Standard HTTP response beans:\n\n<tree>\n<node-0><javac-class><a href=\"/site/apidocs/org/apache/juneau/http/response/BadRequest.html\" target=\"_blank\">BadRequest</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/http/response/Conflict.html\" target=\"_blank\">Conflict</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/http/response/ExpectationFailed.html\" targe [...]
+{"description": "The return type of the Java method can be any serializable POJO as defined in [POJO Categories](/docs/topics/PojoCategories).\n\nIt can also be void if the method is not sending any output (e.g a request redirect) or is setting the output using the <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestResponse.html#setContent(java.lang.Object)\" target=\"_blank\">RestResponse.setContent(Object)</a> method.\n\n:::tip Example\n```java\n@RestGet\npublic String doGet() [...]
+{"description": "Annotated Java methods can throw any of the following:\n\n### Standard HTTP response beans:\n\n<tree>\n<node-0><javac-class><a href=\"/site/apidocs/org/apache/juneau/http/response/BadRequest.html\" target=\"_blank\">BadRequest</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/http/response/Conflict.html\" target=\"_blank\">Conflict</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/juneau/http/response/ExpectationFailed.html\" target [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html#path()\" target=\"_blank\">@RestOp(path)</a> annotation allows you to define\nURL path patterns to match against.\nThese patterns can contain variables of the form `{xxx}` that can be passed in directly to the Java methods as extra\nparameters.\n\nIn the following example, 3 separate GET request handlers are defined with different path patterns.\nNote how the variables are passed in as additional argum [...]
{"description": "<a href=\"/site/apidocs/org/apache/juneau/rest/server/matcher/RestMatcher.html\" target=\"_blank\">RestMatchers</a> are used to allow multiple Java methods to\nbe tied to the same HTTP method and path but differentiated by some request attribute such as a specific header value.\n\n:::tip Example\n```java\n// GET method that gets invoked for administrators\n@RestGet(path=\"/*\", matchers=IsAdminMatcher.class)\npublic Object doGetForAdmin() {\n ...\n}\n\n// GET method t [...]
{"description": "Through the use of the built-in `method` GET parameter, you can implement requests beyond the basic REST http method\ntypes.\n\nFor example, the URL `/sample/foo?method=BAR` will cause the following method to be invoked...\n\n```java\n@RestOp(method=\"BAR\")\npublic void doBar(RestRequest req, RestResponse res) {\n // Handle BAR requests\n}\n```\n\nTo support overloaded methods, the <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html#allowedMethodParams()\ [...]
{"description": "Refer to the following Javadocs for more information:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/server/RestRequest.html\" target=\"_blank\">RestRequest</a></java-class></node-0>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/server/RestResponse.html\" target=\"_blank\">RestResponse</a></java-class></node-0>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/server/httppart/RequestContent.html\" tar [...]
-{"description": "In previous examples we showed the ability to pass in annotated parameters on <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html\" target=\"_blank\">RestOp</a>-annotated methods to parse standard HTTP parts:\n\n:::tip Example\n```java\n@RestGet(\"/example1/{a1}/*\")\npublic String doGetExample1(\n @Path(\"a1\") String a1,\n @Query(\"p1\") int p1,\n @HasQuery(\"p2\") boolean hasP3,\n @Path(\"/*\") String remainder,\n @Header(\"Accept-Language [...]
+{"description": "In previous examples we showed the ability to pass in annotated parameters on <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html\" target=\"_blank\">RestOp</a>-annotated methods to parse standard HTTP parts:\n\n:::tip Example\n```java\n@RestGet(\"/example1/{a1}/*\")\npublic String doGetExample1(\n @Path(\"a1\") String a1,\n @Query(\"p1\") int p1,\n @HasQuery(\"p2\") boolean hasP3,\n @Path(\"/*\") String remainder,\n @Header(\"Accept-Language [...]
{"description": "Juneau comes with three basic marshaller types for serializing and parsing Header, Query, Form, and Path parts:\n\n<tree>\n<node-0><java-interface><a href=\"/site/apidocs/org/apache/juneau/httppart/HttpPartSerializer.html\" target=\"_blank\">HttpPartSerializer</a></java-interface></node-0>\n<node-1><java-class><a href=\"/site/apidocs/org/apache/juneau/httppart/SimplePartSerializer.html\" target=\"_blank\">SimplePartSerializer</a></java-class> - Serializes directly to str [...]
-{"description": "The following annotations allow for defining part schemas based on the OpenAPI standard.\n\n#### Request annotations:\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/Request.html\" target=\"_blank\">Request</a></java-annotation></node-0>\n<node-1><javac-method-annotation><a href=\"/site/apidocs/org/apache/juneau/http/Request.html#on()\" target=\"_blank\">on</a></javac-method-annotation> <javac-method-annotation><a href=\"/site/apidocs/o [...]
+{"description": "The following annotations allow for defining part schemas based on the OpenAPI standard.\n\n### Request annotations:\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/Request.html\" target=\"_blank\">Request</a></java-annotation></node-0>\n<node-1><javac-method-annotation><a href=\"/site/apidocs/org/apache/juneau/http/Request.html#on()\" target=\"_blank\">on</a></javac-method-annotation> <javac-method-annotation><a href=\"/site/apidocs/or [...]
{"description": "By default, HTTP parts that don't have value (such as missing query parameters) end up with null values:\n\n```java\n@RestPost(\"/example\")\npublic String doGetExample1(\n @Query(\"p1\") int p1,\n @FormData(\"f1\") MyBean f1,\n @Header(\"Accept-Language\") AcceptLanguage h1\n) {\n if (p1 == null) p1 = -1;\n if (f1 == null) f1 = DEFAULT_BEAN;\n if (h1 == null) h1 = AcceptLanguage.of(\"en\");\n}\n```\n\nYou have several options to provide default values [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/Request.html\" target=\"_blank\">@Request</a> annotation can used to define proxy\ninterfaces against HTTP requests in combination with the following annotations used on methods:\n\n<tree>\n<node-0><javac-annotation><a href=\"/site/apidocs/org/apache/juneau/http/Header.html\" target=\"_blank\">Header</a></javac-annotation> <javac-annotation><a href=\"/site/apidocs/org/apache/juneau/http/Query.html\" target=\"_blank\">Que [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/Response.html\" target=\"_blank\">Response</a> annotation can be used to define beans that\nreturn HTTP response parts via annotations and methods.\n\nThey are used in combination with the following annotations:\n\n<tree>\n<node-0><javac-annotation><a href=\"/site/apidocs/org/apache/juneau/http/StatusCode.html\" target=\"_blank\">StatusCode</a></javac-annotation> <javac-annotation><a href=\"/site/apidocs/org/apache/junea [...]
{"description": "Request HTTP parts can also be retrieved programmatically through the following classes that can be passed in as\nparameters or access through <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestRequest.html\" target=\"_blank\">RestRequest</a> bean:\n\n<tree>\n<node-0><javac-class><a href=\"/site/apidocs/org/apache/juneau/rest/server/httppart/RequestHeaders.html\" target=\"_blank\">RequestHeaders</a></javac-class> <javac-class><a href=\"/site/apidocs/org/apache/jun [...]
-{"description": "HTTP parts can be automatically validated against their schema definitions using format validation and Jakarta Bean Validation constraints.\n\n## Format Validation\n\nJuneau supports comprehensive format validation for HTTP parts based on JSON Schema Draft 2020-12 and OpenAPI 3.x specifications. When a `format` is specified in a `@Schema` annotation, the value is automatically validated against that format.\n\n### Supported Formats\n\nThe following format types are suppo [...]
+{"description": "HTTP parts can be automatically validated against their schema definitions using format validation and Jakarta Bean Validation constraints.\n\n## Format Validation\n\nJuneau supports comprehensive format validation for HTTP parts based on JSON Schema Draft 2020-12 and OpenAPI 3.x specifications. When a `format` is specified in a `@Schema` annotation, the value is automatically validated against that format.\n\n### Supported Formats\n\nThe following format types are suppo [...]
{"description": ":::warning Outdated examples (9.5)\nExamples on this page using `RestContext.Builder` is pre-9.5 and kept only for historical context.\nUse `@Rest(...serializers/parsers...)`, `@RestOp(...)`, or `@Bean(name=\"serializers\"|\"parsers\")`\nwith fully built sets. See the [v9.5 Migration Guide](/docs/release-notes/9.5.0).\n:::\n\nJuneau uses <a href=\"/site/apidocs/org/apache/juneau/marshall/parser/Parser.html\" target=\"_blank\">Parsers</a> and <a href=\"/site/apidocs/org/a [...]
-{"description": "HTTP form posts can be handled two ways:\n\n- By parsing the entire HTTP body into a POJO using the registered <a href=\"/site/apidocs/org/apache/juneau/marshall/urlencoding/UrlEncodingParser.html\" target=\"_blank\">UrlEncodingParser</a>\n- By access the form post entries as HTTP parts.\n\nThe following example shows the first approach of handling an `application/x-www-form-urlencoded` request of the form `aString=foo&aNumber=123&aDate=2001-07-04T15:30:45Z` and loading [...]
-{"description": "Juneau REST servers ship two complementary composition / mounting primitives on the class-level\n[`@Rest`](/site/apidocs/org/apache/juneau/rest/server/Rest.html) annotation:\n\n- **`@Rest(mixins=Class<?>[])`** \u2014 *inline composition with per-mixin sub-contexts.* Graft every\n `@RestOp`-group method (`@RestGet`, `@RestPost`, `@RestPut`, `@RestPatch`, `@RestDelete`,\n `@RestOptions`, `@RestOp`) from a listed class into the importing resource's operation tree.\n Loca [...]
+{"description": "HTTP form posts can be handled two ways:\n\n- By parsing the entire HTTP body into a POJO using the registered <a href=\"/site/apidocs/org/apache/juneau/marshall/urlencoding/UrlEncodingParser.html\" target=\"_blank\">UrlEncodingParser</a>\n- By access the form post entries as HTTP parts.\n\nThe following example shows the first approach of handling an `application/x-www-form-urlencoded` request of the form `aString=foo&aNumber=123&aDate=2001-07-04T15:30:45Z` and loading [...]
+{"description": "Juneau REST servers ship two complementary composition / mounting primitives on the class-level\n[`@Rest`](/site/apidocs/org/apache/juneau/rest/server/Rest.html) annotation:\n\n- **`@Rest(mixins=Class<?>[])`** \u2014 *inline composition with per-mixin sub-contexts.* Graft every\n `@RestOp`-group method (`@RestGet`, `@RestPost`, `@RestPut`, `@RestPatch`, `@RestDelete`,\n `@RestOptions`, `@RestOp`) from a listed class into the importing resource's operation tree.\n Loca [...]
{"description": "`@Rest(mixins=...)` got a structural upgrade in 9.5.0. The user-facing API is unchanged\n(`@Rest(mixins=Foo.class, Bar.class)` still grafts the listed classes' `@RestOp` methods into the\nimporting resource's operation tree), but the *implementation* now elevates each mixin from a\n\"method library absorbed into the host's `RestContext`\" to an \"embedded sub-resource with its own\n`RestContext` parent-linked to the host's.\"\n\nPre-9.5.0, mixin endpoints resolved serial [...]
+{"description": "Juneau offers two ways to compose one resource's operations into another:\n[`@Rest(children=...)`](/docs/topics/ChildResources) and\n[`@Rest(mixins=...)`](/docs/topics/RestServerCompositionMixinsAndPaths) (plus its host-side override\nform [`@Rest(mixinDefs=@Mixin(...))`](/docs/topics/RestServerMixinSubContexts#host-side-overrides-with-mixin-1000)).\nThey look superficially similar \u2014 both pull a second class's `@RestOp` methods into a parent \u2014 but\nthey are **o [...]
{"description": "Several of Juneau's bundled `Basic*Resource` classes are **dual-use**: they're useful both as a\n*mixin* composed into a host resource via [`@Rest(mixins=...)`](/docs/topics/RestServerCompositionMixinsAndPaths)\n*and* as a *standalone* top-level servlet deployed on their own. Starting in 9.5.0 each dual-use\nresource ships a thin standalone **`Basic*Servlet`** companion so both deployment styles are\nfirst-class and behave identically.\n\n## The two shapes\n\n### Mixin f [...]
{"description": "A Juneau servlet can declare *where it wants to be mounted* via the top-level path chain \u2014\n[`@Rest(paths=...)`](/docs/topics/RestServerCompositionMixinsAndPaths) or a `getPaths()` override \u2014\nrather than having the deployer hard-code a URL pattern at registration time. Three mechanisms read\nthat self-declaration and register the servlet accordingly, one per runtime.\n\nAll three resolve the mount path through the **same** resolver:\n\n```java\nString[] paths [...]
{"description": "As of 10.0, every REST resource class can be configured entirely in code \u2014 without placing a `@Rest` annotation on it\n\u2014 through the `RestBuilder<SELF>` / `AbstractRestBuilder<R, SELF>` CRTP builder API.\n\n## Overview\n\nThe `RestBuilder<SELF>` interface is a public, fluent, self-typed configuration surface covering every `@Rest`\nannotation member. `AbstractRestBuilder<R, SELF>` provides the single shared implementation: each fluent setter writes\ninto a back [...]
@@ -339,7 +345,7 @@
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html#messages()\" target=\"_blank\">@Rest(messages)</a> annotation identifies the\nlocation of the resource bundle for a <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html\" target=\"_blank\">@Rest</a>-annotated class if it's different from the class name.\n\nBy default, the resource bundle name is assumed to match the class name.\nFor example, given the class `MyClass.java`, the resource bundle [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html#encoders()\" target=\"_blank\">@Rest(encoders)</a> annotation can be used to\nassociate character encoders with a servlet class.\nEncoders can be used to enable various kinds of compression (e.g. `gzip`) on requests and responses based on the request\n`Accept-Encoding` and `Content-Encoding` headers.\n\n:::tip Example\n```java\n// Servlet with automated support for GZIP compression\n@Rest(encoders={GzipE [...]
{"description": ":::warning Outdated examples (9.5)\nExamples on this page using `RestContext.Builder` is pre-9.5 and kept only for historical context.\nUse `Config` parameter injection in `@RestOp` methods, `@Bean` beans, or `RestContext.getConfig()`\nfrom a supported `@RestInit` parameter. See the [v9.5 Migration Guide](/docs/release-notes/9.5.0).\n:::\n\nThe Server API provides methods for associating configuration files with REST servlets so that configuration properties\ncan be defi [...]
-{"description": ":::warning Outdated examples (9.5)\nExamples on this page using `RestContext.Builder` / `builder.vars(...)` is pre-9.5 and kept only\nfor historical context. Register custom vars through `@Bean(name=\"varResolver\")` with a\n`VarResolver` (or `VarResolver.Builder`) supplier. See the\n[v9.5 Migration Guide](/docs/release-notes/9.5.0).\n:::\n\nIn the previous examples, there were several cases where embedded variables were contained within annotation values:\n\n```java\n@R [...]
+{"description": ":::warning Outdated examples (9.5)\nExamples on this page using `RestContext.Builder` / `builder.vars(...)` is pre-9.5 and kept only\nfor historical context. Register custom vars through `@Bean(name=\"varResolver\")` with a\n`VarResolver` (or `VarResolver.Builder`) supplier. See the\n[v9.5 Migration Guide](/docs/release-notes/9.5.0).\n:::\n\nIn the previous examples, there were several cases where embedded variables were contained within annotation values:\n\n```java\n@R [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/server/servlet/BasicRestServlet.html\" target=\"_blank\">BasicRestServlet</a> and <a href=\"/site/apidocs/org/apache/juneau/rest/server/servlet/BasicRestResource.html\" target=\"_blank\">BasicRestResource</a> classes come with built-in support for serving up static files through the <a href=\"/site/apidocs/org/apache/juneau/rest/server/ops/HtdocMixin.html\" target=\"_blank\">HtdocMixin</a> op-mixin, which provides the fo [...]
{"description": "The Juneau REST server ships with a\n[`BasicStaticFilesResource`](/site/apidocs/org/apache/juneau/rest/server/staticfile/BasicStaticFilesResource.html)\nmixin in the [`org.apache.juneau.rest.server.staticfile`](/site/apidocs/org/apache/juneau/rest/server/staticfile/package-summary.html)\npackage that wraps the existing [`BasicStaticFiles`](/site/apidocs/org/apache/juneau/rest/server/staticfile/BasicStaticFiles.html)\nplumbing (a `StaticFiles` implementation, not a servle [...]
{"description": "The Juneau REST server ships with a four-class **convention-endpoints mixin pack** in\n[`org.apache.juneau.rest.server.convention`](/site/apidocs/org/apache/juneau/rest/server/convention/package-summary.html)\ncovering the small set of de-facto-standard URLs that every public-facing service eventually has\nto wire up by hand: the browser favicon, the SEO contracts (`robots.txt`, `sitemap.xml`), a\nJSON deployment-introspection endpoint, and the RFC 8615 `/.well-known/*` [...]
@@ -351,19 +357,19 @@
{"description": "Client version headers are used to support backwards compatibility for breaking REST interface changes.\nUsing them, you're able to return different responses based on which client is making a request.\n\nThe APIs involved with defining client version headers are:\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html\" target=\"_blank\">Rest</a></java-annotation></node-0>\n<node-1><java-method-annotation><a href=\"/site/apido [...]
{"description": "One of the most useful features of Juneau is the ability to generate Swagger-based OPTIONS pages for self-documenting\ndesigns (i.e.\nREST interfaces that document themselves).\n\nAs described previously, the `PetStore` example provides an example of auto-generated Swagger JSON:\n\n\n\nUsing <a href=\"/site/apidocs/org/apache/juneau/bean/swagger/ui/SwaggerUI.html\" target=\"_blank\">SwaggerUI</a>, we're able to render t [...]
{"description": "> **Migrating from 9.4.x?** The `@Rest(apiFormat=\u2026)` annotation member, the\n> `juneau.rest.apiFormat` system property, the `RestContext.getApiFormat()` accessor, and the\n> `?Swagger` / `?OpenApi` query mirrors on group resources are all **removed in 9.5.0**. Both\n> Swagger v2 and OpenAPI 3.1 are now always mounted via the four-class api-docs mixin pack on\n> `BasicRestServlet` / `BasicRestResource`. See the\n> [V9.5 Migration Guide](/docs/release-notes/9.5.0) for [...]
-{"description": "The Juneau REST server ships with a four-class **api-docs mixin pack** in\n[`org.apache.juneau.rest.server.docs`](/site/apidocs/org/apache/juneau/rest/server/docs/package-summary.html)\nthat drives every built-in Swagger / OpenAPI / Redoc endpoint on `BasicRestServlet` and\n`BasicRestObject`. Each class is a single-purpose `@Rest`-annotated resource designed to be\ngrafted into your servlet via [`@Rest(mixins=...)`](/docs/topics/RestServerCompositionMixinsAndPaths)\n&mda [...]
-{"description": "Let's look at the various parts of the `Petstore` application Swagger UI to see how they are defined.\n\nThe top part of the page shows general information about the REST interface:\n\n\n\nThe information is pulled from the <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html#swagger()\" target=\"_blank\">@Rest(swagger)</a>\nannotation.\n\n#### org.apache.juneau.petstore.rest.PetStoreResource\n\n```j [...]
-{"description": "Tags allow you to group operations into general categories.\nIn the user interface, these can be expanded/collapsed by clicking on the tag sections.\n\nIn the example below, the `pet` and `store` tag sections are collapsed and the `user` section is not:\n\n\n\nTags are also defined in the <a href=\"/site/apidocs/org/apache/juneau/rest/server/Swagger.html\" target=\"_blank\">@Swagger</a> annotation\n\n#### PetStoreResource [...]
-{"description": "<a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html\" target=\"_blank\">@RestOp</a>-annotated methods automatically get rendered as Swagger operations.\n\nThe following shows the annotations defined on the `GET /pet` operation:\n\n#### PetStoreResource.getPets()\n\n```java\n@RestGet(\n path=\"/pet\",\n summary=\"All pets in the store\",\n swagger=@OpSwagger(\n tags=\"pet\",\n ...\n ),\n ...\n)\npublic Collection getPets() throws [...]
+{"description": "The Juneau REST server ships with a four-class **api-docs mixin pack** in\n[`org.apache.juneau.rest.server.docs`](/site/apidocs/org/apache/juneau/rest/server/docs/package-summary.html)\nthat drives every built-in Swagger / OpenAPI / Redoc endpoint on `BasicRestServlet` and\n`BasicRestResource`. Each class is a single-purpose `@Rest`-annotated resource designed to be\ngrafted into your servlet via [`@Rest(mixins=...)`](/docs/topics/RestServerCompositionMixinsAndPaths)\n&m [...]
+{"description": "Let's look at the various parts of the `Petstore` application Swagger UI to see how they are defined.\n\nThe top part of the page shows general information about the REST interface:\n\n\n\nThe information is pulled from the <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html#swagger()\" target=\"_blank\">@Rest(swagger)</a>\nannotation.\n\n### org.apache.juneau.petstore.rest.PetStoreResource\n\n```ja [...]
+{"description": "Tags allow you to group operations into general categories.\nIn the user interface, these can be expanded/collapsed by clicking on the tag sections.\n\nIn the example below, the `pet` and `store` tag sections are collapsed and the `user` section is not:\n\n\n\nTags are also defined in the <a href=\"/site/apidocs/org/apache/juneau/rest/server/Swagger.html\" target=\"_blank\">@Swagger</a> annotation\n\n### PetStoreResource. [...]
+{"description": "<a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html\" target=\"_blank\">@RestOp</a>-annotated methods automatically get rendered as Swagger operations.\n\nThe following shows the annotations defined on the `GET /pet` operation:\n\n### PetStoreResource.getPets()\n\n```java\n@RestGet(\n path=\"/pet\",\n summary=\"All pets in the store\",\n swagger=@OpSwagger(\n tags=\"pet\",\n ...\n ),\n ...\n)\npublic Collection getPets() throws [...]
{"description": "Expanding operations shows you a list of parameters.\n\nParameter information can be defined in a couple of ways.\nThe typical way is through annotations on parameters being passed to your <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html\" target=\"_blank\">@RestOp</a>-annotated method, like so:\n\n```java\n@RestGet\npublic Collection getPets(\n @Query(\n name=\"s\",\n schema=@Schema(\n description={\n [...]
{"description": "Under the input parameters are listed the possible responses for the resource.\n\nThe `200` response is determined by the return type on the method, in this case a collection of `Pet` objects:\n\n```java\n@RestGet(\n path=\"/pet\",\n summary=\"All pets in the store\",\n ...\n)\npublic Collection getPets() throws NotAcceptable {\n return store.getPets();\n}\n```\n\nNote that additional responses can be specified by throwing exceptions annotated with the <a hre [...]
-{"description": ":::warning Outdated examples (9.5)\nExamples on this page using `@HookEvent(INIT)` or `RestContext.Builder` is pre-9.5 and kept only\nfor historical context. Configure schema generation through\n`@Bean(name=\"jsonSchemaGenerator\")` with a fully built `JsonSchemaGenerator`. See the\n[v9.5 Migration Guide](/docs/release-notes/9.5.0).\n:::\n\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/jsonschema/JsonSchemaGenerator.Builder.html#useBeanDefs()\" target=\"_blank\" [...]
+{"description": ":::warning Outdated examples (9.5)\nExamples on this page using `@HookEvent(INIT)` or `RestContext.Builder` is pre-9.5 and kept only\nfor historical context. Configure schema generation through\n`@Bean(name=\"jsonSchemaGenerator\")` with a fully built `JsonSchemaGenerator`. See the\n[v9.5 Migration Guide](/docs/release-notes/9.5.0).\n:::\n\nThe <a href=\"/site/apidocs/org/apache/juneau/marshall/jsonschema/JsonSchemaGenerator.Builder.html#useBeanDefs()\" target=\"_blank\" [...]
{"description": "The look-and-feel of the Swagger UI is controlled via a single CSS file: `SwaggerUI.css`.\n\nIn the microservice template, this file is located in the `files/htdocs/styles` directory.\n\nIt's a simple straightforward file consisting of less than 350 lines.\n\nThis file can be modified to change the look-and-feel of your Swagger UI.", "id": "topic:b779ce3faaa0", "module": "29", "related_ids": [], "source_path": "pages/topics/10.29.10.SwaggerStylesheet.md", "source_type": [...]
{"description": "<a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html\" target=\"_blank\">Rest</a>-annotated classes get automated timing and error\nstatistic information for all <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html\" target=\"_blank\">@RestOp</a> and lifecycle-event annotated methods on the class.\nIf you extend from <a href=\"/site/apidocs/org/apache/juneau/rest/server/servlet/BasicRestServlet.html\" target=\"_blank\">BasicRestServlet</a> or <a h [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlDocConfig.html\" target=\"_blank\">@HtmlDocConfig</a> annotation is used to customize\nthe HTML view of POJOs serialized by <a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlDocSerializer.html\" target=\"_blank\">HtmlDocSerializer</a>.\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlDocConfig.html\" target=\"_blank\">HtmlDocConfig</a></java-annotation>< [...]
{"description": "An important distinction needs to be made about the HTML representations produced by the REST API.\nThese should not be considered User Interfaces but rather Developer Interfaces.\nUIs should hide the end-user from the underlying architecture.\nThe audience generally consists of non-technical people not interested in how the UI works.\nDIs, on the other hand, should NOT hide the end-user from the underlying architecture.\nInstead, it's a thin veneer over the REST interfa [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/server/widget/Widget.html\" target=\"_blank\">Widget</a> class allows you to add arbitrary HTML, CSS, and\nJavascript to HTML pages.\n\nThey are registered in the following location:\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/marshall/html/HtmlDocConfig.html\" target=\"_blank\">HtmlDocConfig</a></java-annotation></node-0>\n<node-1><java-method-annotation><a href=\"/site/apidocs/org/apac [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/server/widget/package-summary.html\" target=\"_blank\">org.apache.juneau.rest.server.widget</a> package contains predefined reusable widgets.\n\n<tree>\n<node-0><java-package><a href=\"/site/apidocs/org/apache/juneau/rest/server/widget/package-summary.html\" target=\"_blank\">org.apache.juneau.rest.server.widget</a></java-package></node-0>\n<node-1><javac-class><a href=\"/site/apidocs/org/apache/juneau/rest/server/widget [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/server/widget/package-summary.html\" target=\"_blank\">org.apache.juneau.rest.server.widget</a> package contains predefined reusable widgets.\n\n<tree>\n<node-0><java-package><a href=\"/site/apidocs/org/apache/juneau/rest/server/widget/package-summary.html\" target=\"_blank\">org.apache.juneau.rest.server.widget</a></java-package></node-0>\n<node-1><javac-class><a href=\"/site/apidocs/org/apache/juneau/rest/server/widget [...]
{"description": "The HTML views of POJOs can somewhat be considered a rudimentary User Interface.\nIn reality, a better term for them would be a Developer Interface as they're meant to be used primarily by developers\nand not end users.\nDespite that distinction, it is possible to 'brand' the HTML page to whatever you desire.\n\nThe sample root page below includes some default branding for Juneau and Apache:\n\n```text\nhttp://localhost:10000/helloWorld\n```\n\nThe Juneau REST framework [...]
{"description": "The sample root page renders in the default \"devops\" look-and-feel:\n\n\n\n```text\nhttp://localhost:10000\n```\n\nThe sample root page provides a dropdown widget to try out the other default look-and-feels: For example, the \"light\"\nlook-and-feel:\n\n\n\n```text\nhttp://localhost:10000/?stylesheet=styles%2Flight.css\n```\n\nAnd the \"dark\" look-and-fee [...]
{"description": "The REST APIs provides supports enabling logging of HTTP requests and responses through the following annotations:\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html\" target=\"_blank\">Rest</a></java-annotation></node-0>\n<node-1><java-method-annotation><a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html#debug()\" target=\"_blank\">debug</a></java-method-annotation></node-1>\n<node-1><java-method-annotation><a [...]
@@ -371,51 +377,55 @@
{"description": "Juneau REST servers can emit machine-readable [RFC 7807 \u2014 Problem Details for HTTP APIs](https://www.rfc-editor.org/rfc/rfc7807) responses (`application/problem+json`) end-to-end. The feature couples three pieces:\n\n- The typed `Problem` bean from [juneau-bean-rfc7807](/docs/topics/JuneauBeanRfc7807) \u2014 the wire shape.\n- An opt-in flag (`problemDetails`) on `@Rest` and every `@RestOp`-group annotation \u2014 turns on `application/problem+json` rendering of err [...]
{"description": "Juneau REST servers ship a minimal but complete [RFC 7232 \u2014 Conditional Requests](https://www.rfc-editor.org/rfc/rfc7232) helper layer so handlers no longer need to hand-roll `ETag` / `Last-Modified` / `If-None-Match` / `If-Match` plumbing. The feature couples three pieces:\n\n- A handful of fluent setters on <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestResponse.html\" target=\"_blank\">RestResponse</a> \u2014 `eTag(...)`, `lastModified(...)`, `cacheCon [...]
{"description": "Juneau REST servers ship two small, opt-in primitives for operational hardening:\n\n- A token-bucket [RestGuard](/site/apidocs/org/apache/juneau/rest/server/guard/RestGuard.html) \u2014 `RateLimitGuard` \u2014 that throttles inbound traffic per key (default: client IP) and answers with `429 Too Many Requests` + `Retry-After` when the bucket empties.\n- A `@RestStartCall`-friendly filter \u2014 `RequestIdFilter` \u2014 that mints (or honors) an `X-Request-Id` per request, [...]
-{"description": "`juneau-junit5` provides a small JUnit 5 extension for swapping production beans with test doubles (mocks/fakes) inside a Juneau `BeanStore` for the duration of a JUnit 5 test \u2014 without modifying production code and without proxying. It's the Juneau-flavored answer to Spring's `@TestConfiguration` / `@MockBean`.\n\nThe mechanism rests on three pieces:\n\n- A new module \u2014 [`juneau-junit5`](https://search.maven.org/artifact/org.apache.juneau/juneau-junit5) \u2014 [...]
+{"description": "The `juneau-test` module provides a small JUnit 5 extension for swapping production beans with test doubles (mocks/fakes) inside a Juneau `BeanStore` for the duration of a JUnit 5 test \u2014 without modifying production code and without proxying. It's the Juneau-flavored answer to Spring's `@TestConfiguration` / `@MockBean`.\n\nThe mechanism rests on three pieces:\n\n- The [`juneau-test`](https://search.maven.org/artifact/org.apache.juneau/juneau-test) module \u2014 con [...]
{"description": "Juneau REST servers ship two opt-in authentication (AuthN) guards in `org.apache.juneau.rest.server.auth` plus an `@Auth Principal` argument resolver. A separate, optional sub-module \u2014 `juneau-rest-server-auth-jwt` \u2014 adds JWT verification on top via [nimbus-jose-jwt](https://connect2id.com/products/nimbus-jose-jwt). The core `juneau-rest-server` jar stays JWT-free; teams that don't want JWT pay zero classpath cost.\n\nAll three pieces are purely additive \u2014 [...]
{"description": "**Validation is opt-in and disabled by default.** To enable, mark a `@Content`, `@FormData`, or `@Request`-bound parameter with `@jakarta.validation.Valid`. With no marker anywhere on a resource, validation never runs \u2014 no `Validator` is instantiated, no constraint check is invoked, and no per-request cost is paid, even when `jakarta.validation-api` and a concrete provider (e.g. Hibernate Validator) are sitting on the classpath.\n\nThis is a deliberate departure fro [...]
+{"description": "The `juneau-rest-server-metrics-micrometer` module bridges every `@RestOp` call to a Micrometer\n[`MeterRegistry`](https://micrometer.io/docs/concepts#_registry), enabling Prometheus / Grafana\ndashboards, StatsD, Datadog, New Relic, and any other Micrometer-backed backend with a single bean\nregistration.\n\nThis page covers the module-specific classes and wiring patterns. The shared opt-in contract,\nthe `MetricsRecorder` SPI, the per-resource / per-operation annotati [...]
+{"description": "The `juneau-rest-server-tracing-otel` module bridges every `@RestOp` call to an OpenTelemetry\n[`Tracer`](https://opentelemetry.io/docs/specs/otel/trace/api/), opening a `SERVER` span per\nrequest, propagating incoming W3C trace context, and injecting the resulting `traceparent` header\non the response.\n\nThis page covers the module-specific classes and wiring patterns. The shared opt-in contract, the\n`TracerHook` SPI, per-resource / per-operation annotation overrides [...]
{"description": "**Observability is opt-in and disabled by default.** A fresh `RestContext` built with no `MetricsRecorder` or `TracerHook` bean registered never records a metric sample, never opens a span, and never adds a per-request cost \u2014 even when `io.micrometer:micrometer-core` and `io.opentelemetry:opentelemetry-api` are sitting on the classpath. Opt in by registering a `@Bean MetricsRecorder` and / or `@Bean TracerHook` on the resource. Same non-negotiable contract as [Jakar [...]
{"description": "`@RestOp` handler methods may return `CompletableFuture<T>` (or any `CompletionStage<T>`); the framework unwraps the value through the standard response-processor chain when the future resolves. A separate, opt-in `@Rest(virtualThreads=true)` flag dispatches handler invocation onto Java 21+ virtual threads with graceful degradation on Java 17.\n\nThe two features compose: a `CompletableFuture` return on a `virtualThreads=true` resource gives you the high-throughput \"no- [...]
+{"description": "The `RestAuthenticator` SPI provides an ergonomic, **in-resource** way to resolve a request's `Principal` and roles for `@Rest` resources \u2014 so `roleGuard`, `RoleBasedRestGuard`, `@Auth Principal` injection, and `req.isUserInRole(...)` all \"just work\" without container-managed security or a servlet-layer filter.\n\nIt **complements** the [AuthN Filter Framework](/docs/topics/AuthFilterFramework): that framework authenticates at the servlet-container layer (before J [...]
{"description": "The `org.apache.juneau.rest.server.auth` package provides a pluggable servlet-filter authentication framework that runs **at the servlet container layer** \u2014 before Juneau's request routing \u2014 so a single URL can support multiple overlapping authentication schemes, short-circuit on the first success, and aggregate roles when more than one scheme succeeds.\n\nThis framework is the natural peer of the [AuthN Guards](/docs/topics/RestServerAuthGuards) that ship in F [...]
-{"description": "The opt-in `juneau-rest-server-auth-saml` module adds SAML 2.0 single-sign-on (Web Browser SSO Profile) to `juneau-rest-server` by wrapping [OpenSAML 5.x](https://shibboleth.atlassian.net/wiki/spaces/OS30) behind the [AuthFilter](/docs/topics/AuthFilterFramework) / [TokenValidator](/docs/topics/AuthGuards) SPIs that ship in `juneau-rest-server`.\n\nOpenSAML is an Apache 2.0-licensed library maintained by [Shibboleth](https://shibboleth.atlassian.net/). It is declared in [...]
-{"description": "The opt-in `juneau-rest-server-auth-oauth` module adds OAuth 2.0 + OIDC bearer-token validation, RFC 7662 token introspection, RFC 6749 client-side grant flows, and OIDC discovery to `juneau-rest-server` by wrapping the [Nimbus OAuth 2.0 SDK](https://connect2id.com/products/nimbus-oauth-openid-connect-sdk) (`com.nimbusds:oauth2-oidc-sdk`) behind the [AuthFilter](/docs/topics/AuthFilterFramework) / [TokenValidator](/docs/topics/AuthGuards) SPIs.\n\nThe Nimbus SDK is Apach [...]
+{"description": "The opt-in `juneau-rest-server-auth-saml` module adds SAML 2.0 single-sign-on (Web Browser SSO Profile) to `juneau-rest-server` by wrapping [OpenSAML 5.x](https://shibboleth.atlassian.net/wiki/spaces/OS30) behind the [AuthFilter](/docs/topics/AuthFilterFramework) / [TokenValidator](/docs/topics/RestServerAuthGuards) SPIs that ship in `juneau-rest-server`.\n\nOpenSAML is an Apache 2.0-licensed library maintained by [Shibboleth](https://shibboleth.atlassian.net/). It is de [...]
+{"description": "The opt-in `juneau-rest-server-auth-oauth` module adds OAuth 2.0 + OIDC bearer-token validation, RFC 7662 token introspection, RFC 6749 client-side grant flows, and OIDC discovery to `juneau-rest-server` by wrapping the [Nimbus OAuth 2.0 SDK](https://connect2id.com/products/nimbus-oauth-openid-connect-sdk) (`com.nimbusds:oauth2-oidc-sdk`) behind the [AuthFilter](/docs/topics/AuthFilterFramework) / [TokenValidator](/docs/topics/RestServerAuthGuards) SPIs.\n\nThe Nimbus SD [...]
{"description": "The opt-in `juneau-rest-server-auth-oidc-rp` module turns a Juneau REST server into a complete OpenID Connect **Relying Party** — the \"Log in with Google / Okta / Entra ID / Keycloak\" end-to-end glue. It orchestrates the interactive browser login dance (authorization redirect → callback → session) on top of the building blocks in [juneau-rest-server-auth-oauth](/docs/topics/OAuthAuthSupport), wrapping the [Nimbus OAuth 2.0 SDK](https://connect2id.com/pr [...]
{"description": "`@RestOp` handler methods may return reactive-streams values. **The feature is fully opt-in by adding a module to the classpath** \u2014 a bare `juneau-rest-server` has zero reactive behavior and its `DefaultConfig` wires no reactive processor.\n\nTwo layers stack on top of core:\n\n| Classpath | Enables |\n|---|---|\n| bare `juneau-rest-server` | *(no reactive behavior \u2014 a `Flow.Publisher` return is serialized as an ordinary object)* |\n| `+ juneau-rest-server-reac [...]
{"description": "The following URL parameters have special meaning and can be passed in through the URL of the request:\n\n| GET Parameter | Description |\n|---------------|-------------|\n| `&plainText=true` | Response will always be `Content-Type: text/plain` and the returned text will be human-readable (<a href=\"/site/apidocs/org/apache/juneau/marshall/serializer/WriterSerializer.Builder.html#useWhitespace()\" target=\"_blank\">WriterSerializer.Builder.useWhitespace()</a> enabled).<b [...]
{"description": "Juneau REST supports overriding serializer and parser session properties on a per-request basis via HTTP headers or query parameters. This allows clients to control aspects of marshalling (such as whitespace formatting, bean type annotations, etc.) without server-side code changes.\n\n## Overview\n\nThe feature works at two levels:\n\n1. **Server-side**: Configure which properties clients are allowed to override using `@Rest` or `@RestOp` annotations.\n2. **Client-side** [...]
-{"description": "Since REST servlets are basically just `HttpServlets`, incorporating them into an OSGi environment is pretty\nstraightforward.\n\nThe following code shows how to register your REST servlets in an OSGi Activator:\n\n```java\npackage org.apache.juneau.examples.rest;\n\nimport org.osgi.framework.*;\nimport org.osgi.service.http.*;\nimport org.osgi.util.tracker.*;\n\nimport org.apache.juneau.rest.server.samples.*;\n\n/**\n* Activator class used when running samples as a bund [...]
+{"description": "Since REST servlets are basically just `HttpServlets`, incorporating them into an OSGi environment is pretty\nstraightforward.\n\nThe following code shows how to register your REST servlets in an OSGi Activator:\n\n```java\npackage org.apache.juneau.examples.rest;\n\nimport org.osgi.framework.*;\nimport org.osgi.service.http.*;\nimport org.osgi.util.tracker.*;\n\nimport org.apache.juneau.rest.server.samples.*;\n\n/**\n* Activator class used when running samples as a bund [...]
{"description": ":::warning Outdated examples (9.5)\nExamples on this page using `RestContext.Builder` (constructor injection or `@RestInit` parameter\ninjection) is pre-9.5 and kept only for historical context. The Builder-injection protocol was\nremoved; migrate to `@Rest(...)` / `@RestOp(...)` attributes, `@Bean(name=\"...\")` bean\nsuppliers, and `new RestContext(RestContextInit)` for programmatic bootstrap. See the\n[v9.5 Migration Guide](/docs/release-notes/9.5.0).\n:::\n\nThe <a h [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOpContext.html\" target=\"_blank\">RestOpContext</a> object is the workhorse class for an\nindividual <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html\" target=\"_blank\">RestOp</a>-annotated method.\nEvery class annotated with <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html\" target=\"_blank\">@RestOp</a> ends up with an instance of this object.\n\nSimilar to <a href=\"/site [...]
{"description": "The REST Server API uses the concept of registered response processors for converting objects returned by REST methods\nor set through <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestResponse.html#setContent(java.lang.Object)\" target=\"_blank\">RestResponse.setContent(Object)</a> into appropriate HTTP responses.\nBy default, REST resource classes are registered with the following response processors:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/a [...]
-{"description": "The REST/RPC (RPC over REST) API allows the creation of client-side remote proxy interfaces for calling methods on\nserver-side POJOs using entirely REST.\n\n:::note\nThis is not to be confused with REST Proxies which are entirely client-side driven Java interfaces\nagainst arbitrary backend REST interfaces.\n:::\n\n#### Remote Interfaces\n\nThe following example shows a remote interface:\n\n```java\n@RemoteInterface // Annotation is optional\npublic interface IAddressBo [...]
+{"description": "The REST/RPC (RPC over REST) API allows the creation of client-side remote proxy interfaces for calling methods on\nserver-side POJOs using entirely REST.\n\n:::note\nThis is not to be confused with REST Proxies which are entirely client-side driven Java interfaces\nagainst arbitrary backend REST interfaces.\n:::\n\n### Remote Interfaces\n\nThe following example shows a remote interface:\n\n```java\n@RemoteInterface // Annotation is optional\npublic interface IAddressBoo [...]
{"description": "Juneau serializers have sophisticated support for transforming relative URIs to absolute form.\nThe following example shows a REST method that returns a list of URIs of various forms:\n\n```java\n@Rest(\n uriAuthority=\"http://foo.com:123\",\n uriContext=\"/myContext\"\n)\npublic class MyResource {\n\n @RestGet\n public URI[] getURIs() {\n return new URI[] {\n URI.create(\"http://www.apache.org/f1a\"),\n URI.create(\"/f1b\"),\n [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/server/beans/package-summary.html\" target=\"_blank\">org.apache.juneau.rest.server.beans</a> package contains a set of reusable utility beans meant to\nhelp with putting together explorable REST interfaces.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/examples/rest/UtilityBeansResource.html\" target=\"_blank\">UtilityBeansResource</a> class shows how these\nbeans are used.\n\nThe resource class is hosted in the exam [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/server/beans/package-summary.html\" target=\"_blank\">org.apache.juneau.rest.server.beans</a> package contains a set of reusable utility beans meant to\nhelp with putting together explorable REST interfaces.\n\nThe <a href=\"/site/apidocs/org/apache/juneau/examples/rest/UtilityBeansResource.html\" target=\"_blank\">UtilityBeansResource</a> class shows how these\nbeans are used.\n\nThe resource class is hosted in the exam [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/examples/rest/HtmlBeansResource.html\" target=\"_blank\">HtmlBeansResource</a> class shows how <a href=\"/site/apidocs/org/apache/juneau/bean/html5/package-summary.html\" target=\"_blank\">HTML5 beans</a> can be used to generate arbitrary HTML on REST endpoints.\n\n##### table\n\nThe <a href=\"/site/apidocs/org/apache/juneau/examples/rest/HtmlBeansResource.html#aTable()\" target=\"_blank\">aTable()</a> method shows an example [...]
{"description": "- Subclasses can use either <a href=\"https://jakarta.ee/specifications/servlet/6.0/apidocs/jakarta/servlet/http/HttpServlet.html#init(ServletConfig)\" target=\"_blank\">HttpServlet.init(ServletConfig)</a> or <a href=\"https://jakarta.ee/specifications/servlet/6.0/apidocs/jakarta/servlet/http/HttpServlet.html#init()\" target=\"_blank\">HttpServlet.init()</a> for initialization just like any other servlet.\n- The `X-Response-Headers` header can be used to pass through hea [...]
-{"description": "The REST API uses Java logging by default.\n\nIf you wish to use LOG4J logging, you simple need to add the following to your JVM arguments and maven dependencies:\n\n#### Command-line argument\n\n```text\n-Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager\n```\n\n#### Maven dependency\n\n```xml\n<dependency>\n <groupId>org.apache.logging.log4j</groupId>\n <artifactId>log4j-jul</artifactId>\n</dependency>\n```", "id": "topic:908aa499adaa", "module": [...]
+{"description": "The REST API uses Java logging by default.\n\nIf you wish to use LOG4J logging, you simple need to add the following to your JVM arguments and maven dependencies:\n\n### Command-line argument\n\n```text\n-Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager\n```\n\n### Maven dependency\n\n```xml\n<dependency>\n <groupId>org.apache.logging.log4j</groupId>\n <artifactId>log4j-jul</artifactId>\n</dependency>\n```", "id": "topic:908aa499adaa", "module": " [...]
+{"description": "The `juneau-rest-server-management-logging` module ships opt-in `LogBackend` adapters that let the `/loggers`\nmanagement endpoint drive **Logback** or **Log4j2** instead of the built-in `java.util.logging` default.\n\n## Background: the `/loggers` endpoint\n\nThe `/loggers` runtime log-level management endpoint is built into `juneau-rest-server` \u2014 no extra module is\nneeded to expose it. It surfaces as:\n\n| Method | Path | Effect |\n|---|---|---|\n| `GET` | `/logg [...]
{"description": "# juneau-rest-server-mcp\n\nThe `juneau-rest-server-mcp` module exposes a stateless [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) JSON-RPC endpoint built on `juneau-rest-server` and the [`juneau-bean-mcp`](/docs/topics/JuneauBeanMcp) wire beans.\n\n## Overview\n\nMCP is a JSON-RPC 2.0 protocol that lets AI assistants discover and invoke external **tools**, **prompts**, and **resources**. This module provides:\n\n- A transport-agnostic **dispatcher** th [...]
-{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-server-springboot</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-rest-server-springboot-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.rest.server.springboot_0.0.0.jar\n```\n\n#### Contents/Features\n\nThe `juneau-rest-server-springboot` library provides classes to make i [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-server-springboot</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-rest-server-springboot-0.0.0.jar\n```\n\n### OSGi Module\n\n```text\norg.apache.juneau.rest.server.springboot_0.0.0.jar\n```\n\n### Contents/Features\n\nThe `juneau-rest-server-springboot` library provides classes to make it ea [...]
{"description": "The Juneau REST servlet APIs are designed to work seamlessly with the Spring Boot framework.\n\nThe only restriction is that your top-level REST resource must extend from one of the following classes:\n\n<tree>\n<node-0><java-package><a href=\"/site/apidocs/org/apache/juneau/rest/server/springboot/package-summary.html\" target=\"_blank\">org.apache.juneau.rest.server.springboot</a></java-package></node-0>\n<node-1><java-abstract-class><a href=\"/site/apidocs/org/apache/j [...]
-{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-client</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-rest-client-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.rest.client_0.0.0.jar\n```\n\n#### Contents/Features\n\nBuilt upon the feature-rich Apache HttpClient library, the Juneau RestClient API adds support for fluen [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-client</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-rest-client-0.0.0.jar\n```\n\n### OSGi Module\n\n```text\norg.apache.juneau.rest.client_0.0.0.jar\n```\n\n### Contents/Features\n\nBuilt upon the feature-rich Apache HttpClient library, the Juneau RestClient API adds support for fluent-st [...]
{"description": "By default, JSON support is provided for HTTP request and response bodies.\n\nOther languages can be specified using any of the following builder methods:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html#json()\" target=\"_blank\">json()</a></java-me [...]
{"description": "Per-client or per-request HTTP parts (headers, query/form data, path parameters) can be manipulated via the following\nmethods that return back builders for those parts:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a></java-class></node-0>\n<node-1><javac-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html#headers()\" target=\"_blank\"> [...]
{"description": "The request body can either be passed in with the client creator method (e.g. <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.html#post(java.lang.Object)\" target=\"_blank\">post(uri,body)</a>), or can be specified via the following methods:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestRequest.html\" target=\"_blank\">RestRequest</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache [...]
{"description": "After execution using <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestRequest.html#run()\" target=\"_blank\">RestRequest.run()</a> or <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestRequest.html#complete()\" target=\"_blank\">RestRequest.complete()</a>, the following methods can be used to get the response status:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestResponse.html\" target=\"_blank\">RestResponse</a> [...]
{"description": "Response headers are accessed through the following methods:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestResponse.html\" target=\"_blank\">RestResponse</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestResponse.html#getHeader(java.lang.String)\" target=\"_blank\">getHeader(String)</a></java-method> \u2192 <a href=\"/site/apidocs/org/apache/juneau/rest/client/ResponseHeade [...]
{"description": "The response body is accessed through the following method:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestResponse.html\" target=\"_blank\">RestResponse</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestResponse.html#getContent()\" target=\"_blank\">getContent()</a></java-method> \u2192 <a href=\"/site/apidocs/org/apache/juneau/rest/client/ResponseContent.html\" target=\"_b [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestCallHandler.html\" target=\"_blank\">RestCallHandler</a> interface provides the ability to\nprovide custom handling of requests.\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html#callHandle [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestCallHandler.html\" target=\"_blank\">RestCallHandler</a> interface provides the ability to\nprovide custom handling of requests.\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html#callHandle [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestCallInterceptor.html\" target=\"_blank\">RestCallInterceptor</a> API provides a quick way\nof intercepting and manipulating requests and responses beyond the existing <a href=\"https://hc.apache.org/httpcomponents-core-4.4.x/current/httpcore/apidocs/org/apache/http/HttpRequestInterceptor.html\" target=\"_blank\">HttpRequestInterceptor</a> and <a href=\"https://hc.apache.org/httpcomponents-core-4.4.x/current/ht [...]
{"description": "One of the more powerful features of the REST client class is the ability to produce Java interface proxies against\narbitrary 3rd party REST resources.\n\nThe methods to retrieve remote interfaces are:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.html\" target=\"_blank\">RestClient</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.html#getRemote(java.lang.Cl [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/remote/Remote.html\" target=\"_blank\">@Remote</a> annotation is used on your interface class to\nidentify it as a REST proxy interface.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/Remote.html\" target=\"_blank\">Remote</a></java-annotation></node-0>\n<node-1><javac-method-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/Remote.html#path()\" target=\"_blank\"> [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a> annotation is applied to methods of\n@Remote-annotated interfaces to identify REST endpoints.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">RemoteOp</a></java-annotation></node-0>\n<node-1><java-method-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html#method()\" [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/remote/Remote.html\" target=\"_blank\">@Remote</a> annotation is used on your interface class to\nidentify it as a REST proxy interface.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/Remote.html\" target=\"_blank\">Remote</a></java-annotation></node-0>\n<node-1><javac-method-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/Remote.html#path()\" target=\"_blank\"> [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a> annotation is applied to methods of\n@Remote-annotated interfaces to identify REST endpoints.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">RemoteOp</a></java-annotation></node-0>\n<node-1><java-method-annotation><a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html#method()\" [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/Content.html\" target=\"_blank\">@Content</a> annotation can be applied to arguments of\n<a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated methods to denote that they are the HTTP body of the request.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/Content.html\" target=\"_blank\">Content</a></java-annotation></node-0>\n<node [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/FormData.html\" target=\"_blank\">@FormData</a> annotation can be applied to arguments of\n<a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated methods to denote that they are form-data parameters on the request.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/FormData.html\" target=\"_blank\">@FormData</a></java-annotation></no [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/Query.html\" target=\"_blank\">@Query</a> annotation can be applied to arguments of\n<a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated methods to denote that they are query parameters on the request.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/Query.html\" target=\"_blank\">@Query</a></java-annotation></node-0>\n<node-1>< [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/Header.html\" target=\"_blank\">@Header</a> annotation can be applied to arguments of\n<a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated methods to denote that they are header parameters on the request.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/Header.html\" target=\"_blank\">@Header</a></java-annotation></node-0>\n<nod [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/Path.html\" target=\"_blank\">@Path</a> annotation can be applied to arguments of\n<a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated methods to denote that they are path parameters on the request.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/Path.html\" target=\"_blank\">@Path</a></java-annotation></node-0>\n<node-1><java- [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/Request.html\" target=\"_blank\">@Request</a> annotation can be applied to a type of a\n<a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated method to identify it as a bean for setting HTTP parts through a bean-like interface.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/Request.html\" target=\"_blank\">Request</a></java-anno [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/Request.html\" target=\"_blank\">@Request</a> annotation can be applied to a type of a\n<a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated method to identify it as a bean for setting HTTP parts through a bean-like interface.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/Request.html\" target=\"_blank\">Request</a></java-anno [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/http/Response.html\" target=\"_blank\">@Response</a> annotation can be applied to types\nreturned by <a href=\"/site/apidocs/org/apache/juneau/http/remote/RemoteOp.html\" target=\"_blank\">@RemoteOp</a>-annotated methods.\n\n<tree>\n<node-0><java-annotation><a href=\"/site/apidocs/org/apache/juneau/http/Response.html\" target=\"_blank\">Response</a></java-annotation></node-0>\n<node-1><java-method-annotation><a href=\"/site/a [...]
-{"description": "A common coding practice is to use the same Java interface to define both your server and client side REST interfaces.\nThe advantage to this approach is that changes that you make to your REST interface can be reflected in both places at\nthe same time, reducing the chances for compatibility mistakes.\n\nWhat makes this possible is that method-level annotations such as <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html\" target=\"_blank\">@RestOp</a> and [...]
+{"description": "A common coding practice is to use the same Java interface to define both your server and client side REST interfaces.\nThe advantage to this approach is that changes that you make to your REST interface can be reflected in both places at\nthe same time, reducing the chances for compatibility mistakes.\n\nWhat makes this possible is that method-level annotations such as <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html\" target=\"_blank\">@RestOp</a> and [...]
{"description": "The following methods provide logging of requests and responses:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html#logger(java.util.logging.Logger)\" target=\"_blank\">logger(Logger)</a></java-method></node-1>\n<node-1><java-method><a href=\"/site/api [...]
{"description": "Several methods are provided for customizing the underlying HTTP client and client builder classes:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html#httpClientBuilder(org.apache.http.impl.client.HttpClientBuilder)\" target=\"_blank\">httpClientBuilde [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.html\" target=\"_blank\">RestClient</a> API has been designed to allow for the ability to be easily extended.\n\nThe following example that overrides the primary run method shows how this can be done.\n\n:::tip Example\n```java\npublic class MyRestClient extends RestClient {\n\n // Must provide this constructor!\n public MyRestClient(ContextProperties ps) {\n super(ps);\n }\n\n @Overr [...]
@@ -424,41 +434,58 @@
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a> class does not itself\nprovide FORM-based authentication since there is no standard way of providing such support.\nTypically, to perform FORM-based or other types of authentication, you'll want to create your own subclass of <a href=\"/site/apidocs/org/apache/juneau/rest/client/RestClient.Builder.html\" target=\"_blank\">RestClient.Builder</a> and [...]
{"description": "The following example shows an implementation of a client that performs OIDC authentication against the IBM Jazz\nplatform.\n\n```java\n/**\n* Constructor.\n*/\npublic JazzRestClient.Builder(URI jazzUri, String user, String pw) throws IOException {\n ...\n}\n\n/**\n* Override the createHttpClient() method to return an authenticated client.\n*/\n@Override /* RestClient.Builder */\nprotected CloseableHttpClient createHttpClient() throws Exception {\n CloseableHttpCli [...]
{"description": ":::warning Beta API\nThe canonical types in `org.apache.juneau.rest.client.*`, `org.apache.juneau.rest.mock.*`, and\n`org.apache.juneau.http.*` are **beta**. Source- and binary-incompatible changes may appear in the\nnext major Juneau release. For production deployments that require strict binary stability, use the\nclassic stack in `juneau-rest-client-classic` (`org.apache.juneau.rest.client.classic.*`) \u2014 it\nremains the supported, HC4.5-based `RestClient` for the [...]
-{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-mock</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-rest-mock-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.rest.mock_0.0.0.jar\n```\n\n#### Contents/Features\n\nThe `juneau-rest-mock` module contains convenience APIs for performing serverless unit testing of your REST A [...]
-{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/mock/classic/MockRestClient.html\" target=\"_blank\">MockRestClient</a> class is used for performing\nserverless unit testing of <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html\" target=\"_blank\">@Rest</a>-annotated and <a href=\"/site/apidocs/org/apache/juneau/http/remote/Remote.html\" target=\"_blank\">@Remote</a>-annotated classes.\n\n:::info Two flavors of `MockRestClient`\n- `org.apache.juneau.rest. [...]
-{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-microservice</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-microservice-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.microservice_0.0.0.jar\n```\n\n#### Contents/Features\n\nJuneau Microservice is an API for creating stand-alone executable jars with automatic support for Ju [...]
-{"description": "The Microservice API consists of a base class for defining executable microservices.\n\nFeatures include:\n\n- A builder-based API for defining and starting microservices.\n- An extensible API that allows you to hook into various lifecycle events.\n- Simple-to-use APIs for accessing manifest file entries, command-line arguments, and external configuration file properties.\n\nThe Microservice API consists of the following packages and classes:\n\n<tree>\n<node-0>Microserv [...]
-{"description": "Command-line arguments can be associated with a microservice using the <a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html#args(java.lang.String...)\" target=\"_blank\">args()</a> method.\n\n:::tip Example\n```java\npublic static void main(String[] args) {\n Microservice\n .create() // Create builder.\n .args(args) // Pass in args.\n .build() // Create microservice.\n .start() [...]
+{"description": ":::warning Beta API\nThis module is part of the [next-generation REST client](/docs/topics/NextGenRestClient). It is\n**beta**: source- and binary-incompatible changes may appear before a stable release.\n:::\n\n## Maven Dependencies\n\nAdd the Juneau transport module and Apache HttpClient 4.5 to your project:\n\n```xml\n<!-- Juneau transport adapter -->\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-client-apache-httpclient-45</arti [...]
+{"description": ":::warning Beta API\nThis module is part of the [next-generation REST client](/docs/topics/NextGenRestClient). It is\n**beta**: source- and binary-incompatible changes may appear before a stable release.\n:::\n\n## Maven Dependencies\n\n```xml\n<!-- Juneau transport adapter -->\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-client-apache-httpclient-50</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n\n<!-- Apach [...]
+{"description": ":::warning Beta API\nThis module is part of the [next-generation REST client](/docs/topics/NextGenRestClient). It is\n**beta**: source- and binary-incompatible changes may appear before a stable release.\n:::\n\n## Maven Dependencies\n\n```xml\n<!-- Juneau transport adapter -->\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-client-okhttp</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n\n<!-- OkHttp 5 (transitiv [...]
+{"description": ":::warning Beta API\nThis module is part of the [next-generation REST client](/docs/topics/NextGenRestClient). It is\n**beta**: source- and binary-incompatible changes may appear before a stable release.\n:::\n\n## Maven Dependencies\n\n```xml\n<!-- Juneau transport adapter -->\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-client-jetty</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n\n<!-- Jetty 12 HTTP Client [...]
+{"description": ":::warning Beta API\nThe transport adapter framework described here is part of the\n[next-generation REST client](/docs/topics/NextGenRestClient). It is **beta**: source- and\nbinary-incompatible changes may appear before a stable release.\n:::\n\n## Overview\n\nThe canonical `RestClient` in `org.apache.juneau.rest.client` is transport-agnostic. Every HTTP\ncall is routed through an `HttpTransport` SPI, which is responsible for executing a fully-resolved\n`TransportReque [...]
+{"description": "The `Marshaller` class exposes streaming methods that let you consume a REST response as a\nlazy cursor instead of materializing the full response body into a single POJO. This is the\nclient-side complement of the server-side\n<a href=\"/docs/topics/RestStreamingIntegration\">REST Streaming Integration</a> page.\n\n:::warning Beta API\nThese methods are part of the next-generation REST client (`org.apache.juneau.marshall.ng.*`).\nThe API is not yet frozen; source- and [...]
+{"description": "`RestClient` supports multi-format content negotiation: it automatically sets `Accept` and\n`Content-Type` headers based on its configured serializer/parser registry, and selects the\nright parser for each response based on the server's `Content-Type` reply.\n\n:::warning Beta API\nThe `RestClient` described here is part of the next-generation stack (`org.apache.juneau.marshall.ng.*`).\nThe API is not yet frozen.\n:::\n\n> See <a href=\"/docs/topics/SerializerSetsParserS [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-rest-mock</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-rest-mock-0.0.0.jar\n```\n\n### OSGi Module\n\n```text\norg.apache.juneau.rest.mock_0.0.0.jar\n```\n\n### Contents/Features\n\nThe `juneau-rest-mock` module contains convenience APIs for performing serverless unit testing of your REST APIs. [...]
+{"description": "The <a href=\"/site/apidocs/org/apache/juneau/rest/mock/classic/MockRestClient.html\" target=\"_blank\">MockRestClient</a> class is used for performing\nserverless unit testing of <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html\" target=\"_blank\">@Rest</a>-annotated and <a href=\"/site/apidocs/org/apache/juneau/http/remote/Remote.html\" target=\"_blank\">@Remote</a>-annotated classes.\n\n:::info Two flavors of `MockRestClient`\n- `org.apache.juneau.rest. [...]
+{"description": "# Microservice Support\n\nJuneau microservices are **self-contained, deployable REST servers** built on top of the Juneau REST\nserver framework. A microservice packages your REST resources, configuration, and an embedded HTTP container\ninto a single executable jar (or WAR) that you can start with a plain `java -jar` command.\n\nThe microservice layer builds on top of the full Juneau stack:\n\n<tree>\n<node-0>Juneau Microservice Stack</node-0>\n<node-1>juneau-microservi [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-microservice</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-microservice-0.0.0.jar\n```\n\n### OSGi Module\n\n```text\norg.apache.juneau.microservice_0.0.0.jar\n```\n\n### Contents/Features\n\nJuneau Microservice is an API for creating stand-alone executable jars with automatic support for Juneau [...]
+{"description": "The Microservice API consists of a base class for defining executable microservices.\n\nFeatures include:\n\n- A builder-based API for defining and starting microservices.\n- An extensible API that allows you to hook into various lifecycle events.\n- Simple-to-use APIs for accessing manifest file entries, command-line arguments, and external configuration file properties.\n\nThe Microservice API consists of the following packages and classes:\n\n<tree>\n<node-0>Microserv [...]
+{"description": "Command-line arguments can be associated with a microservice using the <a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html#args(java.lang.String...)\" target=\"_blank\">args()</a> method.\n\n:::tip Example\n```java\npublic static void main(String[] args) {\n Microservice\n .create() // Create builder.\n .args(args) // Pass in args.\n .build() // Create microservice.\n .start() [...]
{"description": "The <a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html#manifest(java.lang.Object)\" target=\"_blank\">Microservice.Builder.manifest(Object)</a>\nmethod can be used to specify the contents or location of of the main manifest file of the executable jar.\nIf you do not specify the location/contents of the manifest file, the microservice will attempt to resolve it through\nthe following methods: - Looking on the file system for a file at `META-I [...]
{"description": "As a convenience, the `SystemProperties` section of your configuration file can be used to define system properties to\nset during initialization of your microservice:\n\n```ini\n#=======================================================================================================================\n# System properties\n#-----------------------------------------------------------------------------------------------------------------------\n# These are arbitrary system pr [...]
-{"description": "The Microservice API incorporates the [Simple Variable Language](/docs/topics/SimpleVariableLanguageBasics) API.\nThe variable resolver can be augmented through the following methods:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html\" target=\"_blank\">Microservice.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html#vars(java [...]
+{"description": "The Microservice API incorporates the [Simple Variable Language](/docs/topics/SimpleVariableLanguageBasics) API.\nThe variable resolver can be augmented through the following methods:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html\" target=\"_blank\">Microservice.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html#vars(java [...]
{"description": "The Microservice API provides support for simple console commands.\n\n```java\npublic static void main(String[] args) {\n Microservice\n .create()\n .args(args)\n .build()\n .start()\n .startConsole() // Start console.\n .join()\n ;\n}\n```\n\nWhen started, the console renders the following output:\n\n```bash\nRunning class 'Microservice' using config file 'my-microservice.cfg'.\n\nList of available commands:\n exit - [...]
{"description": "As mentioned previously, the lifecycle methods for the <a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html\" target=\"_blank\">Microservice</a> class are explicitly defined as non-final so that they can be overridden by subclasses.\nIn addition to this support, an interface for defining event listeners for your microservice:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html\" target=\"_bla [...]
{"description": "Starting with **9.5.0**, the <a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html\" target=\"_blank\">Microservice</a>\nclass is **inject-aware**. Every microservice owns an internal\n<a href=\"/site/apidocs/org/apache/juneau/commons/inject/WritableBeanStore.html\" target=\"_blank\">WritableBeanStore</a> (accessible via\n<a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html#getBeanStore()\" target=\"_blank\">getBeanStore()</a>),\np [...]
-{"description": "#### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-microservice-jetty</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n#### Java Library\n\n```text\njuneau-microservice-jetty-0.0.0.jar\n```\n\n#### OSGi Module\n\n```text\norg.apache.juneau.microservice.jetty_0.0.0.jar\n```\n\n#### Contents/Features\n\nJuneau Microservice Jetty is an API for creating stand-alone executable jars that [...]
+{"description": "`@MicroserviceTest` is a JUnit 5 extension that boots a **whole `Microservice`** \u2014 config, lifecycle, and an embedded Jetty server on an ephemeral port \u2014 for the duration of a test class, then stops it cleanly. It's the standalone-microservice analog of Spring's `@SpringBootTest`, and it composes the existing [`@TestBean` mock-bean substrate](/docs/topics/RestServerTestBeanInjection) for collaborator substitution.\n\nIt ships in a small dedicated support module [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-microservice-jetty</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-microservice-jetty-0.0.0.jar\n```\n\n### OSGi Module\n\n```text\norg.apache.juneau.microservice.jetty_0.0.0.jar\n```\n\n### Contents/Features\n\nJuneau Microservice Jetty is an API for creating stand-alone executable jars that can [...]
{"description": "The Jetty Microservice API consists of a combination of the Juneau Core, Server, and Client APIs and an embedded Eclipse\nJetty Servlet Container.\n\nThe API builds upon the [juneau-microservice](JuneauMicroserviceBasics) classes to produce easy-to-create and\neasy-to-use microservices in a standard Java 17+ environment.\n\n> **Renamed in 9.5** \u2014 `juneau-microservice-core` is now published as `juneau-microservice`. The Jetty module is no\n> longer a subclass of `Mi [...]
-{"description": "The lifecycle methods of the <a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html\" target=\"_blank\">Microservice</a> class\nconsists of the following:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html\" target=\"_blank\">Microservice</a></java-class></node-0>\n<node-1><javac-method><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html#start()\" target=\"_blank\">start()</a></ja [...]
+{"description": "The lifecycle methods of the <a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html\" target=\"_blank\">Microservice</a> class\nconsists of the following:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html\" target=\"_blank\">Microservice</a></java-class></node-0>\n<node-1><javac-method><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.html#start()\" target=\"_blank\">start()</a></ja [...]
{"description": "This section describes how to define a top-level REST resource page and deploy it in our microservice.\nThe example is a router page that serves as a jumping off page to child resources.\n\n```java\n@Rest(\n path=\"/*\",\n title=\"My Microservice\",\n description=\"Top-level resources page\",\n htmldoc=@HtmlDoc(\n navlinks={\n \"options: servlet:/?method=OPTIONS\"\n }\n ),\n children={\n HelloWorldResource.class,\n [...]
{"description": "The following predefined resource classes are also provided for easy inclusion into your microservice:\n\n<tree>\n<node-0>Predefined Resource Classes</node-0>\n<node-1><java-class><a href=\"/site/apidocs/org/apache/juneau/microservice/resources/ConfigResource.html\" target=\"_blank\">ConfigResource</a></java-class> - View and modify the external INI config file</node-1>\n<node-1><java-class><a href=\"/site/apidocs/org/apache/juneau/microservice/resources/DirectoryResourc [...]
{"description": "The following methods can be used to define the configuration for your microservice using the powerful `Config` API:\n\n<tree>\n<node-0><java-class><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html\" target=\"_blank\">Microservice.Builder</a></java-class></node-0>\n<node-1><java-method><a href=\"/site/apidocs/org/apache/juneau/microservice/Microservice.Builder.html#config(org.apache.juneau.config.Config)\" target=\"_blank\">config(Config)</ [...]
{"description": "The Jetty microservice comes with a bare-bones `jetty.xml` file which can be modified to suite any needs.\n\nThe `jetty.xml` can be located in either the `.` or `files` working directory or classpath.\n\nIt can also be specified in any of the following ways:\n\n- Supplying a `@Bean JettySettings` whose `jettyXml(Object, boolean resolveVars)` builder method sets the\n raw XML contents (and optionally requests SVL var-resolution).\n\n```java\n@Configuration\npublic class [...]
{"description": "The Microservice project contains a `files/htdocs` folder with predefined stylesheets and images.\nThese files can be used to tailor the look-and-feel of your microservice.\n\n```text\nhttp://localhost:10000/helloWorld\n```\n\nThe REST configuration section of your microservice configuration file can be used to tailor the header and footer on\nthe pages:\n\n```ini\n#========================================================================================================== [...]
-{"description": "As of 10.0, `JettyMicroservice` was reshaped \u2014 the legacy *subclass* form was retired, and a thin static-call facade\nwas introduced to collapse the standard `Microservice` + `JettyConfiguration` bootstrap. See\n[JuneauMicroserviceJettyBasics](/docs/topics/JuneauMicroserviceJettyBasics) for the new entry point.\n\n`juneau-microservice-jetty` contributes a single [JettyConfiguration](MicroserviceJettyOverview) class that wires Jetty\ninto the standard [Microservice]( [...]
+{"description": "As of 10.0, `JettyMicroservice` was reshaped \u2014 the legacy *subclass* form was retired, and a thin static-call facade\nwas introduced to collapse the standard `Microservice` + `JettyConfiguration` bootstrap. See\n[JuneauMicroserviceJettyBasics](/docs/topics/JuneauMicroserviceJettyBasics) for the new entry point.\n\n`juneau-microservice-jetty` contributes a single [JettyConfiguration](MicroserviceJettyOverview) class that wires Jetty\ninto the standard [Microservice]( [...]
{"description": "> **See also:** [REST Server \u2014 Mixins and Multi-Mount Paths](/docs/topics/RestServerCompositionMixinsAndPaths) \u2014 the underlying `@Rest(mixins=...)` and `@Rest(paths=...)` composition primitives this page is built on.\n\nStarting with **9.5.0**, Juneau provides an opt-in probe surface for Jetty microservices:\n\n- `GET /healthz`\n- `GET /readyz`\n- `GET /livez`\n\nProbe routing now has two supported integration styles:\n\n- **Preferred:** mix probe operations in [...]
{"description": "> **See also:** [Health / Readiness / Liveness Probes](/docs/topics/HealthProbes) \u2014 the probe surface (`/healthz`, `/readyz`, `/livez`) this page gates during shutdown.\n\nStarting with **10.0.0**, both embedded-server microservice flavors \u2014 `juneau-microservice-jetty` and `juneau-microservice-tomcat` \u2014 perform a **zero-downtime graceful shutdown** suitable for rolling Kubernetes deployments. The two servers share one identical shutdown contract.\n\nWhen a [...]
+{"description": "> **See also:** [Health / Readiness / Liveness Probes](/docs/topics/HealthProbes) \u2014 the health half of the management surface, and [REST Server \u2014 Mixins and Multi-Mount Paths](/docs/topics/RestServerCompositionMixinsAndPaths) \u2014 the `@Rest(mixins=...)` composition primitives this page builds on.\n\nStarting with **10.0.0**, Juneau ships a coherent, discoverable **Actuator-style management surface** while preserving Juneau's a-la-carte composability. Every e [...]
+{"description": "Apache Juneau ships two packaging aids that make it easy to depend on a coherent, version-aligned slice\nof the framework without hand-maintaining a long list of `<version>` tags:\n\n- A **Bill of Materials (BOM)** \u2014 `org.apache.juneau:juneau-bom` \u2014 for version alignment.\n- A small set of curated **dependency bundles** \u2014 one per deployment shape \u2014 that transitively pull a\n coherent module set.\n\nBoth are deliberately **dependency-only** aids. They [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-microservice-tomcat</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-microservice-tomcat-0.0.0.jar\n```\n\n### OSGi Module\n\n```text\norg.apache.juneau.microservice.tomcat_0.0.0.jar\n```\n\n### Contents/Features\n\n`juneau-microservice-tomcat` is a Tomcat-embedded microservice launcher that mirror [...]
+{"description": "This page covers two packaging concerns for Juneau applications: **Docker image layering** (a concrete recommendation you can apply today) and **GraalVM native-image** support (a feasibility assessment with a forward plan).\n\n## Docker image layering\n\nJuneau itself ships **libraries**, not runnable applications, so there is no Juneau-side fat-jar to layer. Layering happens in *your* deployable application image. Two practical levers:\n\n- **Spring Boot apps** \u2014 ` [...]
+{"description": "The `juneau-sc` group provides a **Git-backed configuration server/client pair** that exposes\n[juneau-config](/docs/topics/JuneauConfigBasics) files stored in a remote Git repository over REST, enabling\ncentralised configuration management across a fleet of microservices.\n\n| Module | Role |\n|--------|------|\n| [juneau-sc-server](/docs/topics/ScServerOverview) | A standalone Juneau/Jetty microservice that clones a remote Git repo and serves `.cfg` files as JSON over [...]
{"description": "# Starter Projects\n\nApache Juneau provides three minimal, clone-and-go **\"Hello World\" starter projects** \u2014 one per\ndeployment type. They are deliberately simpler than the [petstore showcase](/docs/topics/JuneauPetstoreOverview):\nentry-point templates you can build and run in under five minutes, then graduate from.\n\nEach starter is a standalone public GitHub repo with its own docs site:\n\n| Starter | Deployment | Repo | Docs |\n| --- | --- | --- | --- |\n| [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-sc-server</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-sc-server-0.0.0.jar\n```\n\n### Contents/Features\n\n`juneau-sc-server` is the server component of the [juneau-sc](/docs/topics/JuneauScOverview) configuration\nserver. It is a **standalone Juneau microservice** built on `juneau-microservic [...]
+{"description": "### Maven Dependency\n\n```xml\n<dependency>\n <groupId>org.apache.juneau</groupId>\n <artifactId>juneau-sc-client</artifactId>\n <version>${juneau.version}</version>\n</dependency>\n```\n\n### Java Library\n\n```text\njuneau-sc-client-0.0.0.jar\n```\n\n:::note\n**Preview module** \u2014 `juneau-sc-client` is declared as a Maven module in the `juneau-sc` parent POM but\ncontains no Java source yet. The dependency can be declared, but no client API classes are av [...]
+{"description": "Juneau publishes **bundle** artifacts \u2014 `<packaging>pom</packaging>` Maven coordinates that pull a curated,\nversion-aligned set of Juneau modules (and their transitive dependencies) in a single declaration.\n\nBundles are **dependency aggregators only**: they contain no code, register no configurations, and perform no\nclasspath auto-discovery. Every bean, server, and resource still needs to be wired explicitly, exactly as if\nyou had listed the individual modules [...]
{"description": "The **juneau-petstore** family is the canonical Apache Juneau showcase application. It packages a small, complete sample petstore (pets, orders, users) and deploys it under two runtimes \u2014 Jetty/`Microservice` and Spring Boot \u2014 using the *exact same* REST surface, demonstrating that a Juneau service is just a `Servlet` and travels unchanged across deployment containers.\n\n> **In-tree, no external repo.** The petstore lives directly in the Juneau reactor under ` [...]
-{"description": "# juneau-examples-core\n\nThe [juneau-examples-core](https://github.com/apache/juneau/tree/master/juneau-examples/juneau-examples-core) module provides practical examples demonstrating how to use Apache Juneau's core marshalling capabilities for serialization and deserialization of Plain Old Java Objects (POJOs).\n\n## Overview\n\nThis module focuses on the fundamental serialization and deserialization features of Juneau Core, showing developers how to:\n\n- Convert POJO [...]
+{"description": "# juneau-examples-core\n\nThe [juneau-examples-core](https://github.com/apache/juneau/tree/master/juneau-examples/juneau-examples-core) module provides practical examples demonstrating how to use Apache Juneau's core marshalling capabilities for serialization and deserialization of Plain Old Java Objects (POJOs).\n\n## Overview\n\nThis module focuses on the fundamental serialization and deserialization features of Juneau Core, showing developers how to:\n\n- Convert POJO [...]
{"description": "Juneau provides **shaded (uber) JAR artifacts** that bundle multiple Juneau modules into single JAR files. These artifacts simplify dependency management and are especially useful for build systems like Bazel that require explicit dependency declarations.\n\n## What Are Shaded Artifacts?\n\nShaded artifacts use the [Maven Shade Plugin](https://maven.apache.org/plugins/maven-shade-plugin/) to:\n- Bundle multiple Juneau modules into a single JAR\n- Merge service provider f [...]
-{"description": "The `juneau-shaded-core` artifact bundles all core Juneau modules for general marshalling and configuration work. At 2.0 MB, it's the smallest shaded artifact and ideal for applications that don't need REST functionality.\n\n## What's Included\n\nThis artifact includes the following Juneau modules:\n\n- **juneau-commons** - Core utilities and common classes\n- **juneau-assertions** - Fluent-style assertions API\n- **juneau-bct** - Bean-Centric Testing framework\n- **june [...]
+{"description": "The `juneau-shaded-core` artifact bundles all core Juneau modules for general marshalling and configuration work. At 2.0 MB, it's the smallest shaded artifact and ideal for applications that don't need REST functionality.\n\n## What's Included\n\nThis artifact includes the following Juneau modules:\n\n- **juneau-commons** - Core utilities and common classes\n- **juneau-config** - Configuration file API\n- **juneau-marshall** - Serializers and parsers (JSON, XML, HTML, Me [...]
{"description": "The `juneau-shaded-rest-client` artifact bundles all core Juneau modules plus REST client functionality. At 3.8 MB, it provides everything needed for building REST client applications.\n\n## What's Included\n\nThis artifact includes:\n\n- **All modules from [juneau-shaded-core](/docs/topics/JuneauShadedCore)** (marshalling, config, testing)\n- **juneau-rest-common** - REST APIs common to client and server\n- **juneau-rest-client** - Transport-agnostic REST client (no Apa [...]
{"description": "The `juneau-shaded-rest-server` artifact bundles all core Juneau modules plus REST server functionality. At 3.8 MB, it provides everything needed for building REST server applications.\n\n## What's Included\n\nThis artifact includes:\n\n- **All modules from [juneau-shaded-core](/docs/topics/JuneauShadedCore)** (marshalling, config, testing)\n- **juneau-rest-common** - REST APIs common to client and server\n- **juneau-rest-server** - Full-featured REST servlet API\n- **ju [...]
{"description": "The `juneau-shaded-rest-server-springboot` artifact bundles REST server functionality plus Spring Boot integration. At 3.8 MB, it provides everything needed for building Juneau REST services with Spring Boot.\n\n## What's Included\n\nThis artifact includes:\n\n- **All modules from [juneau-shaded-rest-server](/docs/topics/JuneauShadedRestServer)** (core + REST server)\n- **juneau-rest-server-springboot** - Spring Boot auto-configuration and integration\n\n## Use Cases\n\n [...]
-{"description": "The `juneau-shaded-all` artifact is the complete Juneau framework bundled in a single 4.0 MB JAR file. It includes all core modules, REST client, REST server, Spring Boot integration, bean DTOs, and microservice modules.\n\n## What's Included\n\nThis artifact includes **everything**:\n\n### Core Modules\n- **juneau-commons** - Core utilities\n- **juneau-assertions** - Fluent assertions API\n- **juneau-bct** - Bean-Centric Testing framework\n- **juneau-config** - Configur [...]
+{"description": "The `juneau-shaded-all` artifact is the complete Juneau framework bundled in a single 4.0 MB JAR file. It includes all core modules, REST client, REST server, Spring Boot integration, bean DTOs, and microservice modules.\n\n## What's Included\n\nThis artifact includes **everything**:\n\n### Core Modules\n- **juneau-commons** - Core utilities\n- **juneau-config** - Configuration file API\n- **juneau-marshall** - All serializers/parsers (JSON, XML, HTML, MessagePack, etc.) [...]
{"description": "Security is always an ongoing concern in any library.\n\nIf you discover any security vulnerabilities in this code, please refer to the instructions found here: [SECURITY](https://github.com/apache/juneau/blob/master/SECURITY.md)", "id": "topic:b0bd838c7b14", "module": "01", "related_ids": [], "source_path": "pages/topics/22.01.SecurityBasics.md", "source_type": "topic", "summary": "Security is always an ongoing concern in any library.", "tags": ["topic", "01"], "title": [...]
-{"description": "#### Demarshalling vulnerabilities\n\nOne common security vulnerability is the ability to create arbitrary Java object instances through crafted user input.\n\nFor example, support for constructing POJOs based on an input attribute defining a fully-qualified class name like\n`{class:'com.foo.MyBean',...}`\n\nFortunately, Juneau does not support an open-ended `class` attribute.\n\nAs a rule, it should not be possible to create arbitrary POJOs by any of the parsers.\n\nThe [...]
+{"description": "### Demarshalling vulnerabilities\n\nOne common security vulnerability is the ability to create arbitrary Java object instances through crafted user input.\n\nFor example, support for constructing POJOs based on an input attribute defining a fully-qualified class name like\n`{class:'com.foo.MyBean',...}`\n\nFortunately, Juneau does not support an open-ended `class` attribute.\n\nAs a rule, it should not be possible to create arbitrary POJOs by any of the parsers.\n\nThe [...]
{"description": "Care must be used when defining new <a href=\"/site/apidocs/org/apache/juneau/commons/svl/Var.html\" target=\"_blank\">Vars</a> using the SVL API since mistakes\ncould potentially expose system properties, environment variables, or even file system files.\n\nFor recap, the SVL support allows you to embed variables of the form `$X{key}` inside strings that get resolved to other\nstrings.\n\nThe resolved strings themselves can also contain variables that also get recursive [...]
{"description": "Denial of service attacks can be alleviated through the <a href=\"/site/apidocs/org/apache/juneau/rest/server/Rest.html#maxInput()\" target=\"_blank\">maxInput()</a> setting.\n\nArbitrarily-large input will trigger an exception before causing out-of-memory errors.\n\nThe default value for this setting is 100MB.\n\nSince the parsers do not use intermediate DOMs and instead parse directly into Java objects, deeply nested data\nstructures will almost always trigger stack ov [...]
-{"description": "[Content Security Policy (CSP)](https://www.w3.org/TR/CSP3/) is a browser security mechanism that lets a server\ndeclare which content sources a page may load and execute, mitigating cross-site-scripting (XSS) and data-injection\nattacks. Juneau auto-generates HTML with inline `<style>`/`<script>` blocks (the HtmlDoc serializer, the Swagger UI,\nthe OpenAPI UI, and menu-item widgets), so a CSP is the standard way to lock those pages down.\n\nJuneau models a policy as a f [...]
+{"description": "[Content Security Policy (CSP)](https://www.w3.org/TR/CSP3/) is a browser security mechanism that lets a server\ndeclare which content sources a page may load and execute, mitigating cross-site-scripting (XSS) and data-injection\nattacks. Juneau auto-generates HTML with inline `<style>`/`<script>` blocks (the HtmlDoc serializer, the Swagger UI,\nthe OpenAPI UI, and menu-item widgets), so a CSP is the standard way to lock those pages down.\n\nJuneau models a policy as a f [...]
{"description": "The following guide can be used to help migrate your code to v9.0.\nNote that you can also refer to the Release Notes for changes as well.\n| Old | New |\n|-----|-----|\n| <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html\" target=\"_blank\">@RestMethod</a> annotation. | Has been replaced with <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestOp.html\" target=\"_blank\">RestOp</a>, <a href=\"/site/apidocs/org/apache/juneau/rest/server/RestGet.html [...]
{"description": "The following guide can be used to help migrate your code to v10.0.\nNote that you can also refer to the Release Notes for changes as well.\n\nThis guide covers all breaking changes introduced since v9.1, including changes that were\noriginally developed under the v9.5.0 label (a release that was never shipped \u2014 it was\nrenamed to v10.0.0). Teams upgrading from 8.x, 9.1, or any earlier version can use this\nas a single authoritative reference.\n\n## Package Renames\ [...]
diff --git a/static/ai/manifest.json b/static/ai/manifest.json
index dd7676ff67..d3742dbcd1 100644
--- a/static/ai/manifest.json
+++ b/static/ai/manifest.json
@@ -1,10 +1,10 @@
{
- "generated_at": "content-hash:fac31384af5d",
- "record_count": 464,
+ "generated_at": "content-hash:5bf7fc5ebaa8",
+ "record_count": 491,
"schema_version": "1.0.0",
"source_commit": {
- "juneau": "7fc45280c7657982db8eb1a3f1ee1c45ab6dea13",
- "juneau_docs": "c3847ad70e26ba516beb8b3593d34c38703b03de"
+ "juneau": "f925cfecd6ad9e4fbcb5677a839302fdac3550bc",
+ "juneau_docs": "1c84283bfdbac1caf506368aa07a8d60cf93caf4"
},
"version": "10.0.0"
}
diff --git a/static/ai/taxonomy.json b/static/ai/taxonomy.json
index 79000b5c97..74480dd7f1 100644
--- a/static/ai/taxonomy.json
+++ b/static/ai/taxonomy.json
@@ -1,23 +1,24 @@
{
"modules": {
- "01": 23,
- "02": 24,
- "03": 26,
- "04": 33,
+ "00": 1,
+ "01": 28,
+ "02": 28,
+ "03": 27,
+ "04": 34,
"05": 18,
"06": 11,
"07": 12,
"08": 10,
"09": 9,
- "10": 17,
+ "10": 19,
"11": 18,
- "12": 5,
+ "12": 6,
"13": 5,
"14": 7,
"15": 4,
- "16": 2,
- "17": 2,
- "18": 2,
+ "16": 8,
+ "17": 3,
+ "18": 3,
"19": 2,
"20": 2,
"21": 2,
@@ -39,9 +40,9 @@
"37": 2,
"38": 3,
"39": 2,
- "40": 2,
+ "40": 4,
"41": 2,
- "42": 2,
+ "42": 3,
"43": 3,
"44": 2,
"45": 1,
@@ -58,6 +59,7 @@
"56": 1,
"57": 1,
"58": 1,
+ "59": 1,
"api-metadata": 16,
"release-notes": 85
},
@@ -65,6 +67,6 @@
"source_types": {
"api-metadata": 16,
"release-note": 85,
- "topic": 363
+ "topic": 390
}
}