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
The following commit(s) were added to refs/heads/docs by this push:
new c9ec1d734a TODO-249/250: Document marshaller stream static shortcuts +
variant classes (10.0.0)
c9ec1d734a is described below
commit c9ec1d734af7065dd410cad61464d3d10e614982
Author: James Bognar <[email protected]>
AuthorDate: Thu Jul 16 13:28:19 2026 -0400
TODO-249/250: Document marshaller stream static shortcuts + variant classes
(10.0.0)
Feature A (TODO-249): Document the new
Reader/Writer/InputStream/OutputStream
static shortcuts on the marshaller facades in the Marshallers topic page and
a 10.0.0 New-Features release note (incl. IOException-to-unchecked wrapping
and the intentional absence of File overloads).
Feature B (TODO-250): Introduce the variant-class convention (<Format>R =
readable, <Format>C = compact) on the Marshallers, Json5, Hjson, and Ini
topic pages; add New-Feature + Breaking-Change 10.0.0 release notes for the
removal of Json5.DEFAULT_READABLE / Ini.DEFAULT_READABLE /
Hjson.DEFAULT_COMPACT
and the new Json5R / IniR / HjsonC classes. Resolves the stale
Hjson.DEFAULT_COMPACT usage in the Hjson topic and regenerates the AI
knowledge artifacts.
Co-authored-by: Cursor <[email protected]>
---
pages/release-notes/10.0.0.md | 52 ++++++++++++++++++++++++++++
pages/topics/03.01.Marshallers.md | 73 +++++++++++++++++++++++++++++++++++++++
pages/topics/03.25.03.Json5.md | 17 +++++++++
pages/topics/03.40.Hjson.md | 12 +++++--
pages/topics/03.45.Ini.md | 11 +++++-
static/ai/juneau-knowledge.jsonl | 20 +++++------
static/ai/manifest.json | 4 +--
7 files changed, 173 insertions(+), 16 deletions(-)
diff --git a/pages/release-notes/10.0.0.md b/pages/release-notes/10.0.0.md
index 7fadb3145a..4ec341450e 100644
--- a/pages/release-notes/10.0.0.md
+++ b/pages/release-notes/10.0.0.md
@@ -582,6 +582,51 @@ logical types those tools use.
See the [Parquet Basics](/docs/topics/Parquet) topic page for details.
+### Stream-based static marshaller shortcuts
+
+Every marshaller facade now provides **stream-based static shortcuts**
alongside the existing `String` / `byte[]`
+shortcuts, so you can parse from and serialize to streams without going
through a `DEFAULT` instance:
+
+- **Character facades** (`Json`, `Xml`, `Html`, `Yaml`, `Ini`, `Hjson`, …) add
`to(Reader, Class<T>)`,
+ `to(Reader, Type, Type...)`, and `of(Object, Writer)`.
+- **Binary facades** (`MsgPack`, `Cbor`, `Bson`, `Protobuf`, `Parquet`) add
`to(InputStream, Class<T>)`,
+ `to(InputStream, Type, Type...)`, and `of(Object, OutputStream)`.
+
+```java
+MyPojo a = Json.to(reader, MyPojo.class);
+Json.of(myPojo, writer);
+
+MyPojo b = MsgPack.to(inputStream, MyPojo.class);
+MsgPack.of(myPojo, outputStream);
+```
+
+Unlike the instance `read(...)` / `write(...)` methods (which throw a checked
`IOException`), these static
+shortcuts **wrap any underlying `IOException` into an unchecked
`ParseException` (read) or `SerializeException`
+(serialize)**, so they compose cleanly in lambdas and streams. Consistent with
the 10.0.0 stream-only I/O
+narrowing, there are intentionally **no `File` overloads** — open a
`Reader`/`Writer`/`InputStream`/`OutputStream`
+yourself (e.g. via `Files.newBufferedReader(...)`).
+
+See the [Marshallers](/docs/topics/Marshallers) topic page for details.
+
+### Variant marshaller classes (`Json5R` / `IniR` / `HjsonC`)
+
+Three commonly-used non-default marshaller configurations are now first-class
**variant facade classes**, each a
+subclass of its base format facade with its own `DEFAULT` instance and the
full static shortcut surface (including
+the new stream-based shortcuts above) bound to that instance:
+
+- `Json5R` — readable (indented) JSON5, backed by
`Json5Serializer.DEFAULT_READABLE`.
+- `IniR` — readable (spaced) INI, backed by `IniSerializer.DEFAULT_READABLE`.
+- `HjsonC` — compact (single-line) Hjson, backed by
`HjsonSerializer.DEFAULT_COMPACT`.
+
+```java
+String pretty = Json5R.of(myPojo); // readable JSON5
+String compact = HjsonC.of(myPojo); // compact Hjson
+```
+
+These replace the former `Json5.DEFAULT_READABLE`, `Ini.DEFAULT_READABLE`, and
`Hjson.DEFAULT_COMPACT` instance
+constants (see Breaking Changes below). The
[Marshallers](/docs/topics/Marshallers), [JSON5](/docs/topics/Json5),
+[Hjson](/docs/topics/Hjson), and [Ini](/docs/topics/Ini) topic pages were
updated accordingly.
+
### Bug Fixes
_TBD — to be filled in as development continues._
@@ -601,6 +646,13 @@ _TBD — to be filled in as development continues._
- **Static shortcuts (new, on each concrete class):** `Xxx.to(input, type,
...)` parses via `Xxx.DEFAULT.read(...)`; `Xxx.of(object)` serializes via
`Xxx.DEFAULT.write(...)` — e.g. `Json.to(json, MyBean.class)` /
`Json.of(myBean)`.
- **Streaming/record cursors (capability-gated)** — only available when the
underlying serializer/parser implements the corresponding marker interface
(`TokenReadable`/`TokenWritable`, `RecordReadable`/`RecordWritable`,
`ArrayRecordReadable`/`ArrayRecordWritable`): instance
`readTokens`/`writeTokens`, `readRecords`/`writeRecords`,
`readArrayRecords`/`writeArrayRecords`; and their static counterparts
`toTokens`/`ofTokens`, `toRecords`/`ofRecords`,
`toArrayRecords`/`ofArrayRecords`.
+- **Marshaller readable/compact instance constants removed in favor of variant
classes.** The `Json5.DEFAULT_READABLE`, `Ini.DEFAULT_READABLE`, and
`Hjson.DEFAULT_COMPACT` public constants have been removed. Use the new
first-class variant marshaller classes instead (see New Features above):
`Json5R` (readable JSON5), `IniR` (readable INI), and `HjsonC` (compact Hjson).
Each variant is a subclass of its base facade with its own `DEFAULT` and the
full static `of(...)`/`to(...)` shortcut s [...]
+ - `Json5.DEFAULT_READABLE.write(x)` → `Json5R.of(x)` (or `Json5R.DEFAULT`
for an instance).
+ - `Ini.DEFAULT_READABLE.write(x)` → `IniR.of(x)`.
+ - `Hjson.DEFAULT_COMPACT.write(x)` → `HjsonC.of(x)`.
+
+ The in-tree call sites (`BasicSwaggerProviderSession`,
`BasicOpenApiProviderSession`, and the `AtomJsonExample`) were migrated to the
variant classes.
+
Note: the `RecordReader.read()` and `RecordWriter.write()` **cursor**
methods are a separate, unrelated low-level cursor contract — they were never
part of this rename discussion. If you adopted the earlier
`to`/`of`-as-instance-methods preview, revert those call sites back to
`.read(`/`.write(` on the marshaller instance, or switch to the static shortcut
on the concrete class (`Json.to(...)`/`Json.of(...)`) if you don't need a
custom-configured instance.
- **`SerializerSet` / `ParserSet` lookup methods now return `Optional<...>`
(TODO-190).** Every media-type lookup method on `SerializerSet` and `ParserSet`
now returns a `java.util.Optional` instead of `null` on no-match, aligning
these classes with the `Optional`-returning idiom already used by their
consumers (`RestResponse.getSerializerMatch()`,
`RequestContent.getParserMatch()`). Changed signatures:
diff --git a/pages/topics/03.01.Marshallers.md
b/pages/topics/03.01.Marshallers.md
index ad5703cfd8..fbca7a7c47 100644
--- a/pages/topics/03.01.Marshallers.md
+++ b/pages/topics/03.01.Marshallers.md
@@ -83,6 +83,79 @@ String json = Json.of(myPojo);
```
:::
+## Stream-based static shortcuts
+
+In addition to the `String` / `byte[]` static shortcuts shown above, every
marshaller facade also provides
+static shortcuts that read from and write to streams:
+
+- **Character formats** (`Json`, `Xml`, `Html`, `Yaml`, `Ini`, `Hjson`, …) add:
+ - `to(Reader, Class<T>)`
+ - `to(Reader, Type, Type...)`
+ - `of(Object, Writer)`
+- **Binary formats** (`MsgPack`, `Cbor`, `Bson`, `Protobuf`, `Parquet`) add:
+ - `to(InputStream, Class<T>)`
+ - `to(InputStream, Type, Type...)`
+ - `of(Object, OutputStream)`
+
+```java
+// Parse from a Reader / InputStream:
+MyPojo a = Json.to(reader, MyPojo.class);
+MyPojo b = MsgPack.to(inputStream, MyPojo.class);
+
+// Serialize to a Writer / OutputStream:
+Json.of(myPojo, writer);
+MsgPack.of(myPojo, outputStream);
+```
+
+Unlike the instance `read(...)` / `write(...)` methods (which throw a checked
`IOException`), these static
+shortcuts **wrap any `IOException` from the underlying stream** into an
unchecked
+<a href="/site/apidocs/org/apache/juneau/marshall/parser/ParseException.html"
target="_blank">ParseException</a>
+(on the `to(...)` read side) or
+<a
href="/site/apidocs/org/apache/juneau/marshall/serializer/SerializeException.html"
target="_blank">SerializeException</a>
+(on the `of(...)` serialize side), so they can be used directly in lambdas and
streams without a checked-exception burden.
+
+:::note
+There are intentionally **no `File` overloads**. The core I/O surface is
stream-only (see the 10.0.0
+breaking-change note on narrowing serializer/parser I/O to streams). To read
from or write to a file, open the
+`Reader` / `Writer` / `InputStream` / `OutputStream` yourself:
+
+```java
+// Serialize to a file (character format):
+try (Writer w = Files.newBufferedWriter(path)) {
+ Json.of(myPojo, w);
+}
+
+// Parse from a file (binary format):
+try (InputStream in = Files.newInputStream(path)) {
+ MyPojo p = MsgPack.to(in, MyPojo.class);
+}
+```
+:::
+
+## Variant marshaller classes
+
+A handful of formats ship dedicated **variant** facade classes for a
commonly-used non-default configuration.
+Each variant is a subclass of its base format facade with its own `DEFAULT`
instance and the full static
+shortcut surface bound to that instance:
+
+<tree>
+<node-0><javac-class><a
href="/site/apidocs/org/apache/juneau/marshall/marshaller/Json5R.html"
target="_blank">Json5R</a></javac-class> — readable (indented) JSON5, backed by
`Json5Serializer.DEFAULT_READABLE`.</node-0>
+<node-0><javac-class><a
href="/site/apidocs/org/apache/juneau/marshall/marshaller/IniR.html"
target="_blank">IniR</a></javac-class> — readable (spaced) INI, backed by
`IniSerializer.DEFAULT_READABLE`.</node-0>
+<node-0><javac-class><a
href="/site/apidocs/org/apache/juneau/marshall/marshaller/HjsonC.html"
target="_blank">HjsonC</a></javac-class> — compact (single-line) Hjson, backed
by `HjsonSerializer.DEFAULT_COMPACT`.</node-0>
+</tree>
+
+```java
+// Readable JSON5:
+String pretty = Json5R.of(myPojo);
+
+// Compact Hjson:
+String compact = HjsonC.of(myPojo);
+```
+
+These replace the former `Json5.DEFAULT_READABLE`, `Ini.DEFAULT_READABLE`, and
`Hjson.DEFAULT_COMPACT`
+constants (removed in 10.0.0) — a variant class is a first-class facade, so it
exposes the same static
+`of(...)` / `to(...)` shortcut API (including the stream-based shortcuts
above) as any other marshaller.
+
## MarshallUtils
`MarshallUtils` provides a single set of **statically-imported convenience
methods** that cover every
diff --git a/pages/topics/03.25.03.Json5.md b/pages/topics/03.25.03.Json5.md
index a82d8fcb45..13d45815f6 100644
--- a/pages/topics/03.25.03.Json5.md
+++ b/pages/topics/03.25.03.Json5.md
@@ -58,6 +58,23 @@ WriterSerializer serializer = Json5Serializer.DEFAULT;
assertEquals("{foo:'bar',baz:123}", serializer.toString(myPojo));
```
+## Readable output — the `Json5R` variant marshaller
+
+For indented, multi-line JSON5 output, use the dedicated
+<a href="/site/apidocs/org/apache/juneau/marshall/marshaller/Json5R.html"
target="_blank">Json5R</a>
+variant marshaller (backed by `Json5Serializer.DEFAULT_READABLE`). It is a
first-class `Json5` facade, so it
+exposes the same static `of(...)` / `to(...)` shortcut surface as `Json5`
itself:
+
+```java
+// Compact (default):
+String compact = Json5.of(myPojo); // {foo:'bar',baz:123}
+
+// Readable (indented, multi-line):
+String pretty = Json5R.of(myPojo);
+```
+
+(This replaces the former `Json5.DEFAULT_READABLE` constant, removed in
10.0.0.)
+
:::info See Also
<tree>
<node-0><java-class><a
href="/site/apidocs/org/apache/juneau/marshall/json5/Json5Serializer.html"
target="_blank">Json5Serializer</a></java-class></node-0>
diff --git a/pages/topics/03.40.Hjson.md b/pages/topics/03.40.Hjson.md
index e14df1f809..9a9d3c7428 100644
--- a/pages/topics/03.40.Hjson.md
+++ b/pages/topics/03.40.Hjson.md
@@ -52,12 +52,18 @@ Person bob = Hjson.to(rootBraceless, Person.class);
```java
// Readable mode (default) - newlines between members, quoteless strings
-String hjson = Hjson.DEFAULT.of(bean);
+String hjson = Hjson.of(bean);
-// Compact mode - single line, comma-separated
-String compact = Hjson.DEFAULT_COMPACT.of(bean);
+// Compact mode - single line, comma-separated (via the HjsonC variant
marshaller)
+String compact = HjsonC.of(bean);
```
+The compact configuration is exposed as the dedicated
+<a href="/site/apidocs/org/apache/juneau/marshall/marshaller/HjsonC.html"
target="_blank">HjsonC</a>
+variant marshaller (backed by `HjsonSerializer.DEFAULT_COMPACT`). It is a
first-class `Hjson` facade, so it
+exposes the same static `of(...)` / `to(...)` shortcut surface as `Hjson`
itself. (This replaces the former
+`Hjson.DEFAULT_COMPACT` constant, removed in 10.0.0.)
+
## Hjson Syntax Highlights
- **Quoteless strings**: `name: Alice` (no quotes when unambiguous)
diff --git a/pages/topics/03.45.Ini.md b/pages/topics/03.45.Ini.md
index 19e0eab760..31a22c4a35 100644
--- a/pages/topics/03.45.Ini.md
+++ b/pages/topics/03.45.Ini.md
@@ -67,9 +67,18 @@ String ini = IniSerializer.DEFAULT.serialize(myBean);
String pretty = IniSerializer.DEFAULT_READABLE.serialize(myBean);
// Use the marshaller
-String ini2 = Ini.DEFAULT.of(myBean);
+String ini2 = Ini.of(myBean);
+
+// Readable (spaced) output via the IniR variant marshaller
+String pretty2 = IniR.of(myBean);
```
+The readable configuration is exposed as the dedicated
+<a href="/site/apidocs/org/apache/juneau/marshall/marshaller/IniR.html"
target="_blank">IniR</a>
+variant marshaller (backed by `IniSerializer.DEFAULT_READABLE`). It is a
first-class `Ini` facade, so it
+exposes the same static `of(...)` / `to(...)` shortcut surface as `Ini`
itself. (This replaces the former
+`Ini.DEFAULT_READABLE` constant, removed in 10.0.0.)
+
### Bean-to-INI mapping
| Java construct | INI representation |
diff --git a/static/ai/juneau-knowledge.jsonl b/static/ai/juneau-knowledge.jsonl
index 1921e96744..93a28366d7 100644
--- a/static/ai/juneau-knowledge.jsonl
+++ b/static/ai/juneau-knowledge.jsonl
@@ -101,7 +101,7 @@
{"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 data formats and
\ncreating annotation-based REST end-to-end server and client APIs.\n\n## Key
Features\n\n- **Universal Serialization** - Marshal POJOs to 20+ formats from a
single API: JSON (plus JSON5, JSONL, and JSON5L), XML, HTML, URL-Encoding, UON,
OpenAPI, MessagePack, CBOR, BSON, YAML, TOML, HOCON, HJSON, CSV, INI, Markdown,
Parquet, Protobuf, SSE [...]
{"description": "This 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 |\n| **Zero dependencies** [...]
-{"description": "Apache 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 requirements:\n\n**Juneau:**\n``` [...]
+{"description": "Apache 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 requirements:\n\n**Juneau:**\n``` [...]
{"description": "The juneau-commons 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 whenever you\nuse
Juneau.\n\n<DependencyInfo artifact [...]
{"description": "The
[org.apache.juneau.commons.utils](/site/apidocs/org/apache/juneau/commons/utils/package-summary.html)
package provides general-purpose utility classes for common operations
including string manipulation, collection operations, class utilities, file
operations, and more. It contains the most frequently used utility classes in
the codebase \u2014 most notably
[Shorts](/site/apidocs/org/apache/juneau/commons/utils/Shorts.html) (a terse
one-import alias facade) and [Stri [...]
{"description": "The
[org.apache.juneau.commons.collections](/site/apidocs/org/apache/juneau/commons/collections/package-summary.html)
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>\nFlu [...]
@@ -119,7 +119,7 @@
{"description": "The
[org.apache.juneau.commons.http](/site/apidocs/org/apache/juneau/commons/http/package-summary.html)
package provides lightweight, dependency-free primitives for parsing and
modeling HTTP header values \u2014 media types, content-negotiation ranges, and
name/value parameters \u2014 as defined by RFC 2616.\n\n## Media Types and
Negotiation\n\n### <java-class><a
href=\"/site/apidocs/org/apache/juneau/commons/http/MediaType.html\"
target=\"_blank\">MediaType</a></java-cl [...]
{"description": "The
[org.apache.juneau.commons.httppart](/site/apidocs/org/apache/juneau/commons/httppart/package-summary.html)
package provides the shared enumerations and exception used to describe HTTP
\"parts\" (query parameters, path variables, headers, form data, and
request/response bodies) for OpenAPI-schema-based serialization and
parsing.\n\n## Part Enumerations\n\n### <java-enum><a
href=\"/site/apidocs/org/apache/juneau/commons/httppart/HttpPartType.html\"
target=\"_blank\">H [...]
{"description": "The
[org.apache.juneau.commons.concurrent](/site/apidocs/org/apache/juneau/commons/concurrent/package-summary.html)
package provides small concurrency helpers that make locks and atomic
references work cleanly with try-with-resources and `Optional`-style
APIs.\n\n## Auto-Closeable Locks\n\n### <java-class><a
href=\"/site/apidocs/org/apache/juneau/commons/concurrent/SimpleLock.html\"
target=\"_blank\">SimpleLock</a></java-class>\nAn `AutoCloseable` wrapper
around a `java. [...]
-{"description": "The
[org.apache.juneau.commons.logging](/site/apidocs/org/apache/juneau/commons/logging/package-summary.html)
package provides thin extensions over `java.util.logging` that add lazy
message formatting and in-memory log capture for testing.\n\n## Logger\n\n###
<java-class><a
href=\"/site/apidocs/org/apache/juneau/commons/logging/Logger.html\"
target=\"_blank\">Logger</a></java-class>\nAn extended logger that wraps an
underlying `java.util.logging.Logger` and adds convenie [...]
+{"description": "The
[org.apache.juneau.commons.logging](/site/apidocs/org/apache/juneau/commons/logging/package-summary.html)
package provides thin extensions over `java.util.logging` that add lazy
message formatting and in-memory log capture for testing.\n\n## Logger\n\n###
<java-class><a
href=\"/site/apidocs/org/apache/juneau/commons/logging/Logger.html\"
target=\"_blank\">Logger</a></java-class>\nAn extended logger that wraps an
underlying `java.util.logging.Logger` and adds convenie [...]
{"description": "The
[org.apache.juneau.commons.runtime](/site/apidocs/org/apache/juneau/commons/runtime/package-summary.html)
package provides lean accessors for two common runtime inputs: command-line
arguments and JAR manifest files.\n\n## Command-Line Arguments\n\n###
<java-class><a
href=\"/site/apidocs/org/apache/juneau/commons/runtime/Args.html\"
target=\"_blank\">Args</a></java-class>\nA lean parser for command-line
arguments passed to a `main(String[])` method. It supports positi [...]
{"description": "The
[org.apache.juneau.commons.time](/site/apidocs/org/apache/juneau/commons/time/package-summary.html)
package provides a precision-aware date/time type for granular time
operations.\n\n## Granular Date/Time\n\n### <java-class><a
href=\"/site/apidocs/org/apache/juneau/commons/time/GranularZonedDateTime.html\"
target=\"_blank\">GranularZonedDateTime</a></java-class>\nPairs a
`java.time.ZonedDateTime` with a `ChronoField` precision identifier, enabling
granular time opera [...]
{"description": "<DependencyInfo artifact=\"juneau-marshall\"
bundle=\"org.apache.juneau.marshall\" />\n\n## Contents/Features\n\n-
Foundation for all serializers and parsers.\n- Implementations for all
serializers and parsers except RDF languages.\n- Various reusable utilities
used throughout the framework.\n\n## Overview\n\nThe **juneau-marshall**
library includes easy-to-use and highly customizable serializers and parsers
based around a common\nAPI.\nIt allows you to marshall Java POJ [...]
@@ -177,7 +177,7 @@
{"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 | `seriali [...]
{"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/marshall/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/j [...]
-{"description": "The <a
href=\"/site/apidocs/org/apache/juneau/marshall/json5/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\",\ [...]
+{"description": "The <a
href=\"/site/apidocs/org/apache/juneau/marshall/json5/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\",\ [...]
{"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/marshall/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/Ma [...]
{"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 [...]
@@ -236,7 +236,7 @@
{"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<DependencyInfo
artifact=\"juneau-marshall\" mavenOnly note=\"Markdown support is included in
juneau-marshall.\" />\n\n## Two Modes\n\n| Mode | Serializer | Use Case
|\n|---|---|---|\n| **Fragment* [...]
{"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/JsonlSupport)'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/jcs/JcsSerializer.html\"
target=\"_blank\">JcsSerializer</a> converts POJOs to canonical JSON. The <a h
[...]
{"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 [...]
@@ -261,7 +261,7 @@
{"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": "The `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
applications.\n\n### Key Features [...]
{"description": "The `juneau-bean-openapi-v3` module provides Java beans for
working with OpenAPI 3.0 documents and user interfaces.\n\n## Overview\n\nThis
module contains predefined POJOs for:\n\n- OpenAPI 3.0 document structure\n-
API documentation generation\n- OpenAPI UI rendering\n- Schema validation\n\n##
OpenAPI Documents\n\nThe Juneau OpenAPI DTO beans are simply beans with
fluent-style setters that allow you to quickly construct OpenAPI documents as
Java objects. These objects c [...]
-{"description": "The `juneau-bean-common` module provides a small set of
general-purpose Data Transfer Object (DTO) beans in the
`org.apache.juneau.bean` package that don't belong to any single wire-format
module.\n\n## Overview\n\nUnlike the format-specific bean modules
(`juneau-bean-atom`, `juneau-bean-hal`, and so on), this module isn't a base
library that the other `juneau-bean-X` modules build on \u2014 each of those
depends directly on `juneau-marshall`, not on this module. Instead [...]
+{"description": "The `juneau-bean-common` module provides a small set of
general-purpose Data Transfer Object (DTO) beans in the
`org.apache.juneau.bean` package that don't belong to any single wire-format
module.\n\n## Overview\n\nUnlike the format-specific bean modules
(`juneau-bean-atom`, `juneau-bean-hal`, and so on), this module isn't a base
library that the other `juneau-bean-X` modules build on \u2014 each of those
depends directly on `juneau-marshall`, not on this module. Instead [...]
{"description": "The `juneau-bean-swagger-v2` module provides Java beans for
working with [Swagger 2.0](https://swagger.io/specification/v2/) documents and
user interfaces.\n\n## Overview\n\nThis module contains predefined POJOs
for:\n\n- Swagger 2.0 document structure\n- API documentation generation\n-
Swagger UI rendering\n\nThe beans are simply POJOs with fluent-style
`setX(...)` setters, so they can be serialized to JSON using any of the Juneau
JSON serializers, or to other languages [...]
{"description": "The `juneau-bean-mcp` module provides Java beans modelling
the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) wire
format.\n\n## Overview\n\nMCP is a JSON-RPC 2.0 protocol used by AI assistants
and agents to interact with external tools, prompts, and resources. This module
provides a complete set of Juneau `@Marshalled`-annotated POJOs covering the
MCP HTTP wire surface, so you can build MCP servers and clients using any
Juneau serializer/parser (JSON, [...]
{"description": "The `juneau-bean-rfc7807` module provides Java beans for [RFC
7807 \u2014 Problem Details for HTTP
APIs](https://www.rfc-editor.org/rfc/rfc7807), the canonical machine-readable
error format used by `application/problem+json`.\n\n## Overview\n\nRFC 7807
standardises a five-field JSON document for carrying HTTP error details. Most
modern REST stacks ship a `ProblemDetail`-style bean out of the box (Spring's
`ProblemDetail`, ASP.NET's `ProblemDetails`, etc.); this module br [...]
@@ -301,7 +301,7 @@
{"description": "<DependencyInfo artifact=\"juneau-test\"
bundle=\"org.apache.juneau.test\" />\n\n## Contents/Features\n\nThe
**juneau-test** module is a lightweight, self-contained toolkit for writing
readable, expressive\nunit tests. It depends only on JUnit 5 and the core
Juneau commons \u2014 no heavyweight frameworks \u2014 and\nis used throughout
Juneau's own test suite as well as by the built-in assertion methods on the
REST\nclient and server APIs.\n\nIt is organized into three [...]
{"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
(provided by the **juneau-test** module) 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. [...]
{"description": "A 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## 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- [Advanced
Configuration](#advanced-configuration)\n- [Mi [...]
-{"description": "Custom 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 `Shorts.fs()` for
convenient formatted messages with ar [...]
+{"description": "Custom 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 `Shorts.fs()` for
convenient formatted messages with ar [...]
{"description": "BCT 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## Table of Contents\n\n-
[@BctConfig Annotation](#bctconfig-annotation)\n- [BctConfiguration
Class](#bctconfiguration-class)\n- [Configuration
Properties](#configuration-properties)\n- [Custom Bean Converters](#custo [...]
{"description": "Stringifiers 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[] bytes = {0x48, 0x6 [...]
{"description": "Listifiers 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 collectionListifier()\n\nSet<I [...]
@@ -409,8 +409,8 @@
{"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 IAddressBook [...]
{"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/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 of [...]
+{"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/petstore/rest/PetInfoResource.html\"
target=\"_blank\">PetInfoResource</a> class shows how these\nbeans are
used.\n\nThe resource class is hosted in the petstore sampl [...]
+{"description": "The <a
href=\"/site/apidocs/org/apache/juneau/petstore/rest/PetHtmlResource.html\"
target=\"_blank\">PetHtmlResource</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/petstore/rest/PetHtmlResource.html#getPetTable()\"
target=\"_blank\">getPetTable()</a> method shows an exampl [...]
{"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:681a9ac13ee9", "module": "61 [...]
{"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 [...]
@@ -467,8 +467,8 @@
{"description": "<DependencyInfo artifact=\"juneau-microservice-jetty\"
bundle=\"org.apache.juneau.microservice.jetty\" />\n\n###
Contents/Features\n\nJuneau Microservice Jetty is an API for creating
stand-alone executable jars that can be used to start lightweight\nconfigurable
REST interfaces with all the power of the Juneau REST server and client
APIs.\n\n## Zero-config facade\n\nAs of 10.0, `JettyMicroservice` is a **thin
static-call facade** that collapses the standard `Microservice [...]
{"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](JuneauMicroservice)
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 `Microser [...]
{"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": "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 classes are reference/demo resources that
illustrate common microservice admin patterns. They live in the\nunpublished
`juneau-microservice-examples` module (package
`org.apache.juneau.microservice.examples`), not in the\nshipped
`juneau-microservice`/`juneau-microservice-jetty` jars, so they aren't a
dependency you pull in directly \u2014\ntreat them as copy-and-adapt
samples:\n\n<tree>\n<node-0>Predefined Resource
Classes</node-0>\n<node-1><java-class><a [...]
{"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#==========================================================================================================
[...]
diff --git a/static/ai/manifest.json b/static/ai/manifest.json
index 6f0661d661..0c47aeccdb 100644
--- a/static/ai/manifest.json
+++ b/static/ai/manifest.json
@@ -3,8 +3,8 @@
"record_count": 500,
"schema_version": "1.0.0",
"source_commit": {
- "juneau": "9998b7f4c42b248dce4d179719b338e657c1c2a8",
- "juneau_docs": "3fd2c50d6efaf894814e9571fe44e13b3995e488"
+ "juneau": "7fab53f1e852844c6e1776e81a0425942a3bcac5",
+ "juneau_docs": "aaadee212be1908a0a9118b3a97e59bb9e0e8a21"
},
"version": "10.0.0"
}
