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 6a041405e5 docs: document TODO-38 REST client + HTTP stack promotion
and classic module split
6a041405e5 is described below
commit 6a041405e53131847e417326b066ec283e0bb422
Author: James Bognar <[email protected]>
AuthorDate: Tue May 19 09:15:44 2026 -0400
docs: document TODO-38 REST client + HTTP stack promotion and classic
module split
Co-authored-by: Cursor <[email protected]>
---
pages/release-notes/9.5.0.md | 86 +++++++++++++++-------
pages/topics/01.05.RestClient.md | 10 ++-
pages/topics/12.15.NextGenRestClient.md | 103 ++++++++++++++++-----------
pages/topics/13.02.MockRestClientOverview.md | 19 +++--
pages/topics/20.03.JuneauShadedRestClient.md | 9 +--
pages/topics/20.06.JuneauShadedAll.md | 6 +-
pages/topics/23.01.V9.5-migration-guide.md | 64 +++++++++++++++++
7 files changed, 212 insertions(+), 85 deletions(-)
diff --git a/pages/release-notes/9.5.0.md b/pages/release-notes/9.5.0.md
index 3fc09ddb7c..03ecc69d96 100644
--- a/pages/release-notes/9.5.0.md
+++ b/pages/release-notes/9.5.0.md
@@ -2067,53 +2067,87 @@ same path. This covers all sources: `Jetty/servlets`,
`Jetty/servletMap`, and `@
> exact-type, so a bean registered under `MyRestServlet.class` would not be
> visible to the
> auto-mount logic which queries for `Servlet.class`.
-### Next-Generation REST Client and HTTP Stack (Beta)
+### Transport-Agnostic REST Client and HTTP Stack (TODO-38)
-Juneau 9.5.0 introduces a new REST client and HTTP type stack under
`org.apache.juneau.ng.*` that decouples Juneau from Apache HttpClient 4.5. The
new stack is shipped **alongside** the existing `juneau-rest-client` /
`juneau-rest-common` APIs — both continue to work unchanged.
+Juneau 9.5.0 introduces a new REST client and HTTP type stack that **decouples
Juneau from Apache HttpClient 4.5** and promotes it to the canonical names. The
pre-existing HC4.5-based stack continues to ship under explicit `.classic`
packages and a new `juneau-rest-client-classic` module, so existing callers
keep working without source changes other than adding a Maven dependency and
importing from the new package.
-**Beta API**: All public types under `org.apache.juneau.ng.*` are beta and may
change incompatibly in the next major release. For production deployments that
require strict binary stability, continue using the classic `RestClient` /
`juneau-rest-common` APIs until the NG stack is declared stable.
+**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.
-#### `org.apache.juneau.ng.http` (in `juneau-rest-common`)
+#### Canonical names (was `org.apache.juneau.ng.*`)
-A JDK-native replacement for the Apache HttpCore-based types in
`juneau-rest-common`. No `httpcore` dependency in this package — all interfaces
(`HttpHeader`, `HttpPart`, `HttpBody`, `HttpStatusLine`, `HttpResponseMessage`)
use JDK types only.
+The 9.5 cut moves the canonical names off the `org.apache.juneau.ng.*`
placeholder and frees up the historical `org.apache.juneau.*` namespace:
+
+| 9.5 early-snapshot (pre-rename) | 9.5 GA (canonical) |
+|---|---|
+| `org.apache.juneau.ng.http.*` (in `juneau-rest-common`) |
`org.apache.juneau.http.*` (canonical, in `juneau-rest-common`) |
+| `org.apache.juneau.ng.rest.client.*` (in `juneau-rest-client`) |
`org.apache.juneau.rest.client.*` (canonical, in `juneau-rest-client`) |
+| `org.apache.juneau.ng.rest.mock.*` (in `juneau-rest-mock`) |
`org.apache.juneau.rest.mock.*` (canonical, in `juneau-rest-mock`) |
+| `NgRestClient` / `NgRestRequest` / `NgRestResponse` | `RestClient` /
`RestRequest` / `RestResponse` |
+| `NgMockRestClient` | `MockRestClient` |
+| `juneau-ng-rest-client-apache-httpclient-45` (etc.) |
`juneau-rest-client-apache-httpclient-45` (etc.) |
+
+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`)
+
+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.
- Typed header hierarchy (`HttpStringHeader`, `HttpMediaTypeHeader`,
`HttpMediaRangesHeader`, `HttpStringRangesHeader`, `HttpCsvHeader`,
`HttpDateHeader`, `HttpUriHeader`, `HttpIntegerHeader`, `HttpLongHeader`,
`HttpBooleanHeader`, `HttpEntityTagHeader`, `HttpEntityTagsHeader`) with ~73
RFC-named header classes (`Accept`, `ContentType`, `Authorization`, …).
- Entity / body types: `HttpBodyBean`, `StringBody`, `ByteArrayBody`,
`StreamBody`, `FileBody`, `MultipartBody` (RFC 7578 streaming).
- Status / response types: `HttpStatusLineBean`, `BasicHttpResponse`,
`BasicHttpException`, ~50 named status classes (`Ok`, `Created`, `NotFound`,
`InternalServerError`, …).
-- Remote-proxy annotations re-homed under `org.apache.juneau.ng.http.remote`
(`@Remote`, `@RemoteGet`, `@RemotePost`, `@RemotePut`, `@RemotePatch`,
`@RemoteDelete`, `@RemoteOp`, `@RemoteReturn`).
+- Remote-proxy annotations stay under `org.apache.juneau.http.remote`
(`@Remote`, `@RemoteGet`, `@RemotePost`, `@RemotePut`, `@RemotePatch`,
`@RemoteDelete`, `@RemoteOp`, `@RemoteReturn`).
+
+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.ng.rest.client` (in `juneau-rest-client`)
+#### `org.apache.juneau.rest.client` (in `juneau-rest-client`)
-The transport abstraction and the new `NgRestClient` / `NgRestRequest` /
`NgRestResponse`.
+The transport abstraction and the new canonical `RestClient` / `RestRequest` /
`RestResponse`. No `org.apache.http.*` dependency.
- `HttpTransport` — single integration point replacing
`org.apache.http.client.HttpClient`. Provides synchronous
`send(TransportRequest)` and a `sendAsync(...)` default that transports can
override for native async.
- `TransportRequest`, `TransportResponse` (`Closeable` — owns
connection-release hook), `TransportHeader`, `TransportBody`,
`TransportException` — transport-layer DTOs using JDK types only.
- `HttpTransportBuilder` / `HttpTransportProvider` SPI — `ServiceLoader`-based
auto-discovery; passing a fully-built transport or transport builder is also
supported.
-- `NgRestClient` — composes an `HttpTransport`; one
serializer/parser/marshaller per client (no multi-language mode); fluent
`get/post/put/patch/delete/head/options/formPost/multipartPost` API; remote
proxies via `getRemote(Class)`; explicit `shutdown()` (not `Closeable`).
-- `NgRestRequest` — the single `Closeable` in the user-facing API; resolves
URI + path data + query, runs interceptors, serializes the body, calls the
transport.
+- `RestClient` — composes an `HttpTransport`; one serializer/parser/marshaller
per client (no multi-language mode); fluent
`get/post/put/patch/delete/head/options/formPost/multipartPost` API; remote
proxies via `getRemote(Class)`; explicit `shutdown()` (not `Closeable`).
+- `RestRequest` — the single `Closeable` in the user-facing API; resolves URI
+ path data + query, runs interceptors, serializes the body, calls the
transport.
- `CollectionFormat` enum (`COMMA`, `PIPE`, `SPACE`, `TAB`, `REPEATED`) for
`Iterable` / array-valued params.
- `BodyConverter` — pluggable request-body conversion; default chain handles
`HttpBody`, `MultipartBody`, `InputStream`, `byte[]`, `Reader`, `File`,
`PartList`, and falls back to a `SerializedBody` that streams through the
client's serializer.
- `RestCallInterceptor` — `onInit` / `onConnect` / `onClose` lifecycle hooks
(no Apache types).
- `RestLogger` / `RestLogEntry` / `RestLogLevelResolver` / `BasicRestLogger` —
framework-agnostic logging via `java.lang.System.Logger`, with named-template
formatting (`{method}`, `{uri}`, `{status}`, `{reason}`, `{elapsed}`,
`{req.headers}`, `{req.body}`, `{res.headers}`, `{res.body}`, `{error}`) and
configurable per-level templates.
-#### Transport Implementations (new modules)
+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
-Each new module is independent and pulls in only its own native client. The
`HttpTransportProvider` `ServiceLoader` entries let
`NgRestClient.create().build()` auto-discover the highest-priority transport on
the classpath.
+Each transport is an independent module pulling in only its native client. The
`HttpTransportProvider` `ServiceLoader` entries let
`RestClient.create().build()` auto-discover the highest-priority transport on
the classpath.
| Module | Artifact ID | Native client |
|---|---|---|
-| Apache HttpClient 4.5 | `juneau-ng-rest-client-apache-httpclient-45` |
`org.apache.httpcomponents:httpclient:4.5.x` |
-| Apache HttpClient 5 | `juneau-ng-rest-client-apache-httpclient-50` |
`org.apache.httpcomponents.client5:httpclient5` |
-| JDK `HttpClient` | `juneau-ng-rest-client-java-httpclient` |
`java.net.http.HttpClient` (Java 11+) — zero third-party deps |
-| OkHttp | `juneau-ng-rest-client-okhttp` | `com.squareup.okhttp3:okhttp` |
-| Eclipse Jetty client | `juneau-ng-rest-client-jetty` |
`org.eclipse.jetty:jetty-client` |
+| Apache HttpClient 4.5 | `juneau-rest-client-apache-httpclient-45` |
`org.apache.httpcomponents:httpclient:4.5.x` |
+| Apache HttpClient 5 | `juneau-rest-client-apache-httpclient-50` |
`org.apache.httpcomponents.client5:httpclient5` |
+| JDK `HttpClient` | `juneau-rest-client-java-httpclient` |
`java.net.http.HttpClient` (Java 11+) — zero third-party deps |
+| OkHttp | `juneau-rest-client-okhttp` | `com.squareup.okhttp3:okhttp` |
+| Eclipse Jetty client | `juneau-rest-client-jetty` |
`org.eclipse.jetty:jetty-client` |
Each 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.ng.rest.mock`
+#### `juneau-rest-mock` — `org.apache.juneau.rest.mock`
+
+The canonical mock client now matches the new `RestClient`:
- `MockHttpTransport` — routes `TransportRequest` directly to a Juneau
`RestContext` without network I/O.
-- `NgMockRestClient` — extends `NgRestClient` and wires it to
`MockHttpTransport`. Replaces the classic
`MockRestClient`-implements-`HttpClientConnection` shim with a plain
`HttpTransport` implementation.
+- `MockRestClient` — composes `MockHttpTransport` and exposes the standard
`RestClient` builder surface. Use
`MockRestClient.create(MyRestResource.class).marshaller(Json5.DEFAULT).build()`
for serverless integration tests.
+
+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
+
+The pre-existing Apache HttpClient 4.5–based REST client moved into a new
sibling Maven module:
+
+| Artifact | Contents |
+|---|---|
+| `juneau-rest-client` (canonical) | Transport-agnostic NG `RestClient`. No
`org.apache.http.*` dependency. |
+| `juneau-rest-client-classic` (new) | Legacy `RestClient` (extends
`org.apache.http.client.HttpClient`); types live under
`org.apache.juneau.rest.client.classic.*`. Depends on
`org.apache.httpcomponents:httpclient:4.5.14`. |
+
+Both modules can be on the classpath simultaneously — they share
`juneau-rest-common` but expose disjoint packages. The aggregator artifacts
(`juneau-shaded-rest-client`, `juneau-shaded-all`, `juneau-microservice`,
`juneau-rest-mock`, `juneau-distrib`) pull in both flavors so existing
assemblies see no behavioral change.
#### Usage Examples
@@ -2123,7 +2157,7 @@ var serializer = Json5Serializer.create().build();
var parser = Json5Parser.create().build();
// Pick a transport explicitly
-NgRestClient client = NgRestClient.create()
+RestClient client = RestClient.create()
.transportBuilder(ApacheHc45Transport.create()
.connectTimeout(Duration.ofSeconds(10))
.sslContext(mySSLContext)
@@ -2134,7 +2168,7 @@ NgRestClient client = NgRestClient.create()
.build();
// Or let the SPI auto-discover the best transport on the classpath
-NgRestClient zeroConfig = NgRestClient.create()
+RestClient zeroConfig = RestClient.create()
.marshaller(Json5.DEFAULT)
.rootUrl("https://api.example.com";)
.build();
@@ -2157,13 +2191,13 @@ client.shutdown();
#### Migration Path
-The classic `RestClient` / `juneau-rest-common` APIs remain fully supported
with no behavior change. Migration is **opt-in**:
+The classic `RestClient` / `juneau-rest-common` APIs remain fully supported.
Migration is **opt-in** and incremental:
-1. Add the NG transport module for your preferred HTTP stack to your build.
-2. Replace `RestClient.create()` with `NgRestClient.create()` and adapt
builder calls — most configuration (`rootUrl`, default headers/query/form/path,
interceptors, marshaller) maps 1:1.
-3. Use try-with-resources around `NgRestRequest`; call `shutdown()` on the
client at application shutdown.
+1. **Stay on classic** — add a `juneau-rest-client-classic` dependency and
replace `import org.apache.juneau.rest.client.*;` with `import
org.apache.juneau.rest.client.classic.*;` (similar for
`org.apache.juneau.http.*` → `org.apache.juneau.http.classic.*`). No behavior
change.
+2. **Migrate to the new stack** — add a transport module (e.g.
`juneau-rest-client-apache-httpclient-45`), keep `import
org.apache.juneau.rest.client.*;`, and adapt builder calls. Most configuration
(`rootUrl`, default headers/query/form/path, interceptors, marshaller) maps
1:1; per-Apache-HttpClient options (`httpClientBuilder()`,
`connectionManager()`, `defaultRequestConfig()`) move onto the transport
builder.
+3. **Update tests** — use `org.apache.juneau.rest.mock.MockRestClient`
(canonical) for new tests; keep
`org.apache.juneau.rest.mock.classic.MockRestClient` for the legacy fluent
surface (`.json5()`, `.plainText()`, deprecated builder methods).
-The classic stack is **not** deprecated in 9.5; the NG stack will graduate to
stable in a future release, at which point the classic stack may be deprecated
and eventually removed.
+The classic stack is **not** deprecated in 9.5; the canonical stack will
graduate to stable in a future release, at which point the classic stack may be
deprecated and eventually removed.
### juneau-bean-mcp (new module)
diff --git a/pages/topics/01.05.RestClient.md b/pages/topics/01.05.RestClient.md
index 1428cc7ac3..cb19dc70d5 100644
--- a/pages/topics/01.05.RestClient.md
+++ b/pages/topics/01.05.RestClient.md
@@ -3,8 +3,12 @@ title: "REST Client"
slug: RestClient
---
-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.
+Juneau ships two REST client stacks:
+
+- 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.
+- The next-generation `org.apache.juneau.rest.client.RestClient`
(transport-agnostic, no Apache HttpClient dependency) in the
`juneau-rest-client` Maven module — see [Next-Generation REST
Client](/docs/topics/NextGenRestClient).
+
+The remainder of this page shows the classic client. Both clients share the
same fluent style for marshalling POJOs to and from HTTP parts.
:::tip Example
```java
@@ -22,7 +26,7 @@ MyBean bean = RestClient.create()
#### REST Testing Framework
-The <a href="/site/apidocs/org/apache/juneau/rest/mock/MockRestClient.html"
target="_blank">MockRestClient</a> class is used for performing
+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/annotation/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.
It perform full serialization and parsing of the HTTP request and responses,
but bypasses the network layer to
significantly improve speed while still performing real testing.
diff --git a/pages/topics/12.15.NextGenRestClient.md
b/pages/topics/12.15.NextGenRestClient.md
index 0a4ecd2d48..c6d3a814ac 100644
--- a/pages/topics/12.15.NextGenRestClient.md
+++ b/pages/topics/12.15.NextGenRestClient.md
@@ -4,21 +4,23 @@ slug: NextGenRestClient
---
:::warning Beta API
-All public types under `org.apache.juneau.ng.*` are **beta**. Source- and
binary-incompatible changes
-may appear in the next major Juneau release. For production deployments that
require strict
-binary stability, continue using the classic `RestClient` /
`juneau-rest-common` APIs until the
-NG stack is declared stable in a future release.
+The canonical types in `org.apache.juneau.rest.client.*`,
`org.apache.juneau.rest.mock.*`, and
+`org.apache.juneau.http.*` are **beta**. Source- and binary-incompatible
changes may appear in the
+next major Juneau release. For production deployments that require strict
binary stability, use the
+classic stack in `juneau-rest-client-classic`
(`org.apache.juneau.rest.client.classic.*`) — it
+remains the supported, HC4.5-based `RestClient` for the 9.x line.
:::
-Juneau 9.5.0 introduces a next-generation REST client and HTTP type stack under
-`org.apache.juneau.ng.*` that **decouples Juneau from Apache HttpClient 4.5**.
The new stack
-ships alongside the existing `juneau-rest-client` / `juneau-rest-common` APIs
— both continue
-to work unchanged.
+Juneau 9.5.0 promotes the next-generation REST client and HTTP type stack to
the **canonical names**
+under `org.apache.juneau.rest.client.*`, `org.apache.juneau.rest.mock.*`, and
+`org.apache.juneau.http.*`. The pre-existing Apache HttpClient 4.5–based stack
ships unchanged under
+`.classic` packages and the new `juneau-rest-client-classic` Maven module — see
+[v9.5 Migration Guide](/docs/topics/V9.5-migration-guide) for the
import-rename table.
The next-generation stack:
-- Uses **only JDK types** in its API surface (`org.apache.juneau.ng.http`). No
`org.apache.http.*`
- on any signature.
+- Uses **only JDK types** in its API surface (`org.apache.juneau.http`). No
`org.apache.http.*` on
+ any signature.
- Introduces an `HttpTransport` abstraction so you can plug in **any HTTP
client**
(Apache HC 4.5, Apache HC 5, JDK `HttpClient`, OkHttp, Jetty, or a custom
transport)
without changing user code.
@@ -32,9 +34,12 @@ The next-generation stack:
| Package | Module | Role |
|---|---|---|
-| `org.apache.juneau.ng.http` | `juneau-rest-common` | JDK-native HTTP types
(`HttpHeader`, `HttpPart`, `HttpBody`, status types, ~73 RFC-named headers, ~50
named response types, multipart, remote-proxy annotations). No `httpcore`
dependency. |
-| `org.apache.juneau.ng.rest.client` | `juneau-rest-client` | `HttpTransport`
abstraction, `NgRestClient` / `NgRestRequest` / `NgRestResponse`, interceptors,
body converters, `RestLogger`. No `httpcore` dependency. |
-| `org.apache.juneau.ng.rest.mock` | `juneau-rest-mock` | `MockHttpTransport`
and `NgMockRestClient` for in-process testing against a Juneau `RestContext`. |
+| `org.apache.juneau.http` | `juneau-rest-common` | JDK-native HTTP types
(`HttpHeader`, `HttpPart`, `HttpBody`, status types, ~73 RFC-named headers, ~50
named response types, multipart, remote-proxy annotations). No `httpcore`
dependency. |
+| `org.apache.juneau.rest.client` | `juneau-rest-client` | `HttpTransport`
abstraction, canonical `RestClient` / `RestRequest` / `RestResponse`,
interceptors, body converters, `RestLogger`. No `httpcore` dependency. |
+| `org.apache.juneau.rest.mock` | `juneau-rest-mock` | `MockHttpTransport` and
the canonical `MockRestClient` for in-process testing against a Juneau
`RestContext`. |
+| `org.apache.juneau.http.classic` | `juneau-rest-common` | Pre-existing
Apache HttpCore-based types (~170 classes). Kept for the classic stack. |
+| `org.apache.juneau.rest.client.classic` | `juneau-rest-client-classic` (new)
| Pre-existing `RestClient` that implements
`org.apache.http.client.HttpClient`. Apache HttpClient 4.5–based. |
+| `org.apache.juneau.rest.mock.classic` | `juneau-rest-mock` | Pre-existing
`MockRestClient` (extends classic `RestClient` and implements
`HttpClientConnection`) plus its `MockRestRequest` / `MockRestResponse` /
`MockLogger` / `MockConsole` / `MockHttpClientConnectionManager` helpers. |
---
@@ -46,11 +51,11 @@ on the classpath at `build()` time when no explicit
transport is passed.
| Module | Artifact ID | Native client |
|---|---|---|
-| Apache HttpClient 4.5 | `juneau-ng-rest-client-apache-httpclient-45` |
`org.apache.httpcomponents:httpclient:4.5.x` |
-| Apache HttpClient 5 | `juneau-ng-rest-client-apache-httpclient-50` |
`org.apache.httpcomponents.client5:httpclient5` |
-| JDK `HttpClient` | `juneau-ng-rest-client-java-httpclient` |
`java.net.http.HttpClient` (Java 11+) — zero third-party deps |
-| OkHttp | `juneau-ng-rest-client-okhttp` | `com.squareup.okhttp3:okhttp` |
-| Eclipse Jetty client | `juneau-ng-rest-client-jetty` |
`org.eclipse.jetty:jetty-client` |
+| Apache HttpClient 4.5 | `juneau-rest-client-apache-httpclient-45` |
`org.apache.httpcomponents:httpclient:4.5.x` |
+| Apache HttpClient 5 | `juneau-rest-client-apache-httpclient-50` |
`org.apache.httpcomponents.client5:httpclient5` |
+| JDK `HttpClient` | `juneau-rest-client-java-httpclient` |
`java.net.http.HttpClient` (Java 11+) — zero third-party deps |
+| OkHttp | `juneau-rest-client-okhttp` | `com.squareup.okhttp3:okhttp` |
+| Eclipse Jetty client | `juneau-rest-client-jetty` |
`org.eclipse.jetty:jetty-client` |
Each module ships three classes:
@@ -65,8 +70,8 @@ Each module ships three classes:
```java
import org.apache.juneau.json5.*;
-import org.apache.juneau.ng.rest.client.*;
-import org.apache.juneau.ng.rest.client.apachehttpclient45.*;
+import org.apache.juneau.rest.client.*;
+import org.apache.juneau.rest.client.apachehttpclient45.*;
import java.time.*;
// Pre-build the serializer/parser — configure marshalling externally
@@ -74,7 +79,7 @@ var serializer = Json5Serializer.create().build();
var parser = Json5Parser.create().build();
// Choose a transport explicitly and configure it
-NgRestClient client = NgRestClient.create()
+RestClient client = RestClient.create()
.transportBuilder(ApacheHc45Transport.create()
.connectTimeout(Duration.ofSeconds(10))
.maxConnections(50))
@@ -94,11 +99,11 @@ client.shutdown();
### Auto-Discovery
-If you don't pass an explicit transport, `NgRestClient` uses `ServiceLoader`
to pick the
+If you don't pass an explicit transport, `RestClient` uses `ServiceLoader` to
pick the
highest-priority `HttpTransportProvider` on the classpath:
```java
-NgRestClient zeroConfig = NgRestClient.create()
+RestClient zeroConfig = RestClient.create()
.marshaller(Json5.DEFAULT)
.rootUrl("https://api.example.com";)
.build();
@@ -108,13 +113,13 @@ NgRestClient zeroConfig = NgRestClient.create()
## Key Design Differences from the Classic `RestClient`
-| Concern | Classic `RestClient` | `NgRestClient` |
+| Concern | Classic `RestClient` (`...client.classic`) | Canonical
`RestClient` (`...client`) |
|---|---|---|
| HTTP integration | Implements `org.apache.http.client.HttpClient`; bound to
Apache HC 4.5 | Composes an `HttpTransport`; transport-agnostic |
| Serialization model | Multi-language marshallers / format shortcuts
(`json()`, `xml()`, …) | **One pre-built serializer/parser/marshaller per
client**; no multi-language mode |
| Builder surface | 40+ Apache HC passthrough methods | Small builder with
only Juneau-specific concerns |
| Lifecycle | `RestClient.close()` | Explicit `shutdown()` (not `Closeable`) —
signalling app-lifecycle vs per-call |
-| Per-request lifecycle | `RestClient` and `RestResponse` were `Closeable` |
**Only `NgRestRequest` is `Closeable`**; `close()` releases the connection |
+| Per-request lifecycle | `RestClient` and `RestResponse` were `Closeable` |
**Only `RestRequest` is `Closeable`**; `close()` releases the connection |
| Header/part types | Implement `org.apache.http.Header` / `NameValuePair` |
Implement JDK-only `HttpHeader` / `HttpPart` interfaces |
| Schema validation on `@Query`/`@Header`/`@FormData`/`@Path` | Supported |
**Not supported** — `toString()` + `CollectionFormat` only |
@@ -122,7 +127,7 @@ NgRestClient zeroConfig = NgRestClient.create()
## Resource Lifecycle
-`NgRestRequest` is the single `Closeable` in the user-facing API. Close it to
release the
+`RestRequest` is the single `Closeable` in the user-facing API. Close it to
release the
underlying connection and stream:
```java
@@ -135,7 +140,7 @@ try (var req = client.get("/users")) {
client.shutdown();
```
-`NgRestResponse` does **not** implement `Closeable` — its lifecycle is owned
by the request.
+`RestResponse` does **not** implement `Closeable` — its lifecycle is owned by
the request.
---
@@ -171,7 +176,7 @@ and should **not** be used for binary uploads.
Logging is framework-agnostic via `java.lang.System.Logger`:
```java
-NgRestClient client = NgRestClient.create()
+RestClient client = RestClient.create()
.transportBuilder(JavaHttpTransport.create())
.marshaller(Json5.DEFAULT)
.logger(BasicRestLogger.of(System.getLogger("myapp.http")))
@@ -192,11 +197,13 @@ Custom log entries can be built using named templates
## Mock Transport (Serverless Testing)
`MockHttpTransport` routes `TransportRequest` directly to a Juneau
`RestContext` without
-network I/O. Use `NgMockRestClient` for unit tests that exercise
serialization, remote proxies,
-interceptors, and assertions:
+network I/O. Use `org.apache.juneau.rest.mock.MockRestClient` for unit tests
that exercise
+serialization, remote proxies, interceptors, and assertions:
```java
-NgRestClient mock = NgMockRestClient.create(MyRestResource.class)
+import org.apache.juneau.rest.mock.MockRestClient;
+
+RestClient mock = MockRestClient.create(MyRestResource.class)
.marshaller(Json5.DEFAULT)
.pathData("tenantId", "acme")
.build();
@@ -206,32 +213,42 @@ try (var req = mock.get("/users/123")) {
}
```
+For the legacy fluent surface (`.json5()`, `.plainText()`,
`.disableRedirectHandling()`, etc.)
+use `org.apache.juneau.rest.mock.classic.MockRestClient` — see
+[Mock REST Client Overview](/docs/topics/MockRestClientOverview).
+
---
## Migration Path
-The classic `RestClient` and `juneau-rest-common` APIs are **not deprecated**
in 9.5.
-Migration is opt-in and incremental:
-
-1. Add the NG transport module for your preferred HTTP stack as a Maven
dependency.
-2. Replace `RestClient.create()` with `NgRestClient.create()` and adapt
builder calls —
- most builder methods map 1:1 (`rootUrl`, default headers/query/form/path,
interceptors,
- marshaller, `errorCodes`, `executorService`).
+The classic `RestClient` and its supporting `juneau-rest-common` Apache
HttpCore types are
+**not deprecated** in 9.5; they moved to `.classic` packages and the new
+`juneau-rest-client-classic` module. Migration is opt-in and incremental:
+
+1. **Stay on classic** — keep using the same `RestClient` / `MockRestClient`
types you have
+ today; just adjust imports as described in
+ [v9.5 Migration Guide](/docs/topics/V9.5-migration-guide) and add a Maven
dependency on
+ `juneau-rest-client-classic`. No behavioral change.
+2. **Adopt the canonical stack** — add the NG transport module for your
preferred HTTP stack
+ as a Maven dependency. Replace `RestClient.create()` with the canonical
+ `org.apache.juneau.rest.client.RestClient.create()` and adapt builder calls
— most builder
+ methods map 1:1 (`rootUrl`, default headers/query/form/path, interceptors,
marshaller,
+ `errorCodes`, `executorService`).
3. Wrap each request in **try-with-resources**. Call `shutdown()` on the
client at
application shutdown.
4. If you customized Apache HttpClient through `httpClientBuilder()` /
`connectionManager()` /
`defaultRequestConfig()`, move those calls onto the **transport builder**
(e.g. `ApacheHc45TransportBuilder`).
5. If you relied on multi-language marshallers or per-request language
overrides, create
- one `NgRestClient` per language.
+ one `RestClient` per language.
-The NG stack will graduate to stable in a future release, at which point the
classic stack
-may be deprecated and eventually removed.
+The canonical stack will graduate to stable in a future release, at which
point the classic
+stack may be deprecated and eventually removed.
---
## See Also
- [juneau-rest-client Basics](/docs/topics/JuneauRestClientBasics) — the
classic stack
-- [juneau-rest-mock Basics](/docs/topics/JuneauRestMockBasics) — classic mock
client
-- Release notes: [9.5.0](/docs/release-notes/9.5.0) — Next-Generation REST
Client and HTTP Stack
+- [Mock REST Client Overview](/docs/topics/MockRestClientOverview) — both
flavors of mock client
+- Release notes: [9.5.0](/docs/release-notes/9.5.0) — Transport-Agnostic REST
Client and HTTP Stack
diff --git a/pages/topics/13.02.MockRestClientOverview.md
b/pages/topics/13.02.MockRestClientOverview.md
index 8c819edd22..62fbbc982a 100644
--- a/pages/topics/13.02.MockRestClientOverview.md
+++ b/pages/topics/13.02.MockRestClientOverview.md
@@ -3,10 +3,17 @@ title: "Mock REST Client Overview"
slug: MockRestClientOverview
---
-The <a href="/site/apidocs/org/apache/juneau/rest/mock/MockRestClient.html"
target="_blank">MockRestClient</a> class is used for performing
+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/annotation/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.
-The <a href="/site/apidocs/org/apache/juneau/rest/mock/MockRestClient.html"
target="_blank">MockRestClient</a> itself extends from <a
href="/site/apidocs/org/apache/juneau/rest/client/RestClient.html"
target="_blank">RestClient</a> providing it with the rich feature set of that
API.
+:::info Two flavors of `MockRestClient`
+- `org.apache.juneau.rest.mock.classic.MockRestClient` — the legacy mock
client documented on this page. Extends the classic <a
href="/site/apidocs/org/apache/juneau/rest/client/classic/RestClient.html"
target="_blank">RestClient</a> (Apache HttpClient 4.5–based) and exposes the
full fluent surface (`.json5()`, `.plainText()`, deprecated builder methods).
+- `org.apache.juneau.rest.mock.MockRestClient` — the canonical NG mock client,
paired with the transport-agnostic <a
href="/site/apidocs/org/apache/juneau/rest/client/RestClient.html"
target="_blank">RestClient</a>. Use this for new tests that target the new
stack. See [Next-Generation REST Client](/docs/topics/NextGenRestClient) for
examples.
+
+Both classes live in the `juneau-rest-mock` Maven module and can be used in
the same project.
+:::
+
+The classic <a
href="/site/apidocs/org/apache/juneau/rest/mock/classic/MockRestClient.html"
target="_blank">MockRestClient</a> itself extends from <a
href="/site/apidocs/org/apache/juneau/rest/client/classic/RestClient.html"
target="_blank">RestClient</a> providing it with the rich feature set of that
API.
The following shows a simple example of invoking a PUT method on a simple REST
interface and asserting the correct
status code and response body:
@@ -79,7 +86,7 @@ public void testEcho() throws Exception {
```
The concept of the design is simple.
-The <a href="/site/apidocs/org/apache/juneau/rest/mock/MockRestClient.html"
target="_blank">MockRestClient</a> class is used to create instances of <a
href="/site/apidocs/org/apache/juneau/rest/mock/MockServletRequest.html"
target="_blank">MockServletRequest</a> and <a
href="/site/apidocs/org/apache/juneau/rest/mock/MockServletResponse.html"
target="_blank">MockServletResponse</a> which are passed directly to the call
handler on the resource class <a href="/site/apidocs/org/apache/juneau [...]
+The <a
href="/site/apidocs/org/apache/juneau/rest/mock/classic/MockRestClient.html"
target="_blank">MockRestClient</a> class is used to create instances of <a
href="/site/apidocs/org/apache/juneau/rest/mock/MockServletRequest.html"
target="_blank">MockServletRequest</a> and <a
href="/site/apidocs/org/apache/juneau/rest/mock/MockServletResponse.html"
target="_blank">MockServletResponse</a> which are passed directly to the call
handler on the resource class <a href="/site/apidocs/org/apach [...]
In effect, you're fully testing your REST API as if it were running in a live
servlet container, yet not actually having
to run in a servlet container.
All aspects of the client and server side code are tested, yet no servlet
container is required.
@@ -126,7 +133,7 @@ public class MockTest {
}
```
-The <a href="/site/apidocs/org/apache/juneau/rest/mock/MockRestRequest.html"
target="_blank">MockRestRequest</a> object has convenience methods
+The <a
href="/site/apidocs/org/apache/juneau/rest/mock/classic/MockRestRequest.html"
target="_blank">MockRestRequest</a> object has convenience methods
provided to allow you to set properties directly on the underlying <a
href="https://jakarta.ee/specifications/servlet/6.0/apidocs/jakarta/servlet/http/HttpServletRequest.html";
target="_blank">HttpServletRequest</a> object.
The following example shows how this can be used to directly set roles on the
request object to perform security
testing.
@@ -152,7 +159,7 @@ public void mytest() throws Exception {
```
:::
-The <a href="/site/apidocs/org/apache/juneau/rest/mock/MockRestClient.html"
target="_blank">MockRestClient</a> class has a debug mode that will
+The <a
href="/site/apidocs/org/apache/juneau/rest/mock/classic/MockRestClient.html"
target="_blank">MockRestClient</a> class has a debug mode that will
cause your HTTP requests and responses to
be sent to the console:
@@ -164,7 +171,7 @@ MockRestClient client = MockRestClient
.build();
```
-The <a href="/site/apidocs/org/apache/juneau/rest/mock/MockRestClient.html"
target="_blank">MockRestClient</a> class can also be used for testing of <a
href="/site/apidocs/org/apache/juneau/http/remote/Remote.html"
target="_blank">Remote</a>-annotated interfaces against <a
href="/site/apidocs/org/apache/juneau/rest/annotation/Rest.html"
target="_blank">@Rest</a>-annotated resources.
+The <a
href="/site/apidocs/org/apache/juneau/rest/mock/classic/MockRestClient.html"
target="_blank">MockRestClient</a> class can also be used for testing of <a
href="/site/apidocs/org/apache/juneau/http/remote/Remote.html"
target="_blank">Remote</a>-annotated interfaces against <a
href="/site/apidocs/org/apache/juneau/rest/annotation/Rest.html"
target="_blank">@Rest</a>-annotated resources.
:::tip Example
```java
diff --git a/pages/topics/20.03.JuneauShadedRestClient.md
b/pages/topics/20.03.JuneauShadedRestClient.md
index 0b7f14b0e3..32e1593f8e 100644
--- a/pages/topics/20.03.JuneauShadedRestClient.md
+++ b/pages/topics/20.03.JuneauShadedRestClient.md
@@ -11,8 +11,9 @@ This artifact includes:
- **All modules from [juneau-shaded-core](/docs/topics/JuneauShadedCore)**
(marshalling, config, testing)
- **juneau-rest-common** - REST APIs common to client and server
-- **juneau-rest-client** - Full-featured REST client API
-- **juneau-rest-mock** - REST testing utilities
+- **juneau-rest-client** - Transport-agnostic REST client (no Apache
HttpClient dependency)
+- **juneau-rest-client-classic** - Legacy REST client built on Apache
HttpClient 4.5
+- **juneau-rest-mock** - REST testing utilities (canonical and classic flavors)
## Use Cases
@@ -69,10 +70,10 @@ java_binary(
`juneau-shaded-rest-client` requires:
### Required
-- **Apache HttpClient 5.2+** - HTTP client implementation
-- **Apache HttpCore 5.2+** - HTTP core functionality
+- **Apache HttpClient 4.5.x** - bundled via `juneau-rest-client-classic` for
the legacy client. The canonical `juneau-rest-client` artifact itself has **no
Apache HttpClient dependency** — it composes any `HttpTransport` implementation
you put on the classpath (HC 4.5, HC 5, JDK `HttpClient`, OkHttp, Jetty client,
or a custom transport).
### Optional
+- **Apache HttpClient 5.x** / **`java.net.http.HttpClient`** / **OkHttp** /
**Jetty client** - pick one of the `juneau-rest-client-apache-httpclient-50` /
`juneau-rest-client-java-httpclient` / `juneau-rest-client-okhttp` /
`juneau-rest-client-jetty` transport modules to drive the canonical
`RestClient` over a non-HC-4.5 transport.
- **Jakarta XML Bind API 3.0+** - For XML serialization
- **Apache Jena** - For RDF support
diff --git a/pages/topics/20.06.JuneauShadedAll.md
b/pages/topics/20.06.JuneauShadedAll.md
index e54fab28e3..ec8be18572 100644
--- a/pages/topics/20.06.JuneauShadedAll.md
+++ b/pages/topics/20.06.JuneauShadedAll.md
@@ -18,7 +18,8 @@ This artifact includes **everything**:
### REST Modules
- **juneau-rest-common** - Common REST APIs
-- **juneau-rest-client** - REST client API
+- **juneau-rest-client** - REST client API (transport-agnostic, no Apache
HttpClient dependency)
+- **juneau-rest-client-classic** - Legacy REST client built on Apache
HttpClient 4.5
- **juneau-rest-server** - REST server API
- **juneau-rest-server-rdf** - RDF support for servers
- **juneau-rest-server-springboot** - Spring Boot integration
@@ -93,8 +94,7 @@ java_binary(
`juneau-shaded-all` requires the following external dependencies:
### For REST Client
-- **Apache HttpClient 5.2+**
-- **Apache HttpCore 5.2+**
+- **Apache HttpClient 4.5.x** — bundled via `juneau-rest-client-classic` for
the legacy client. The canonical NG `juneau-rest-client` artifact composes any
`HttpTransport` (HC 4.5, HC 5, JDK `HttpClient`, OkHttp, Jetty client) — add
the appropriate transport module separately if you target a non-HC-4.5 backend.
### For REST Server
- **Jakarta Servlet API 6.1+**
diff --git a/pages/topics/23.01.V9.5-migration-guide.md
b/pages/topics/23.01.V9.5-migration-guide.md
index c3da890cd0..003f51ff4b 100644
--- a/pages/topics/23.01.V9.5-migration-guide.md
+++ b/pages/topics/23.01.V9.5-migration-guide.md
@@ -275,5 +275,69 @@ the user adds to
`Microservice.Builder.configurations(...)`. The Java package
| `JettyMicroservice.getInstance().getServer()` |
`Microservice.getInstance().getBeanStore().getBean(JettyServerComponent.class).orElseThrow().getServer()`
| Same for `.getPort()`, `.getURI()`, `.getContextPath()`,
`.getServletContextHandler()`. |
| `JettyMicroservice.Builder.listener(JettyMicroserviceListener)` |
`Microservice.Builder.listener(MicroserviceListener)` or `@Bean
MicroserviceListener` | The builder listener is registered into the bean store
as the unnamed entry and participates in fan-out alongside `@Bean`-supplied
listeners. |
+## REST Client and HTTP Stack Promotion (TODO-38)
+
+Juneau 9.5.0 promotes the next-generation, transport-agnostic REST client to
the canonical names.
+The pre-existing Apache HttpClient 4.5–based stack moves under `.classic`
packages and a new
+`juneau-rest-client-classic` Maven module so existing call sites keep working.
+
+### Maven module changes
+
+| Old | New | Notes |
+|-----|-----|-------|
+| `<artifactId>juneau-rest-client</artifactId>` |
`<artifactId>juneau-rest-client</artifactId>` *(canonical, NG)* **and/or**
`<artifactId>juneau-rest-client-classic</artifactId>` *(legacy)* | The
historical `juneau-rest-client` artifact is now the **transport-agnostic NG**
client with no `org.apache.http.*` dependency. The legacy HC4.5-based
`RestClient` moved into the new `juneau-rest-client-classic` sibling artifact.
Pull in both if you need both flavors; the aggregator artifacts (`jun [...]
+| `<artifactId>juneau-ng-rest-client-apache-httpclient-45</artifactId>` |
`<artifactId>juneau-rest-client-apache-httpclient-45</artifactId>` | Drop the
`ng-` prefix. The 9.5 early-snapshot package layout shipped these NG transport
modules under `juneau-ng-rest-client-*` artifacts; the GA cut renames them.
Same rename applies to `…-apache-httpclient-50`, `…-java-httpclient`,
`…-okhttp`, `…-jetty`. |
+
+### Package renames
+
+| Old | New | Notes |
+|-----|-----|-------|
+| `org.apache.juneau.http.*` *(Apache HttpCore-based types in
`juneau-rest-common`)* | `org.apache.juneau.http.classic.*` | The historical
`juneau-rest-common` types (`HttpHeaders` facade, `Authorization`, `Range`,
`BasicHeader`, `BasicStatusLine`, response/exception classes, etc., ~170 types)
moved under the `.classic` sub-package. Update `import
org.apache.juneau.http.*;` to `import org.apache.juneau.http.classic.*;`. |
+| `org.apache.juneau.ng.http.*` *(9.5 early snapshot only)* |
`org.apache.juneau.http.*` | The new JDK-native types that briefly lived under
`ng.http.*` graduated to the now-free canonical `org.apache.juneau.http.*`
namespace. The `@Remote` / `@RemoteGet` / `@RemotePost` / etc. annotations stay
at `org.apache.juneau.http.remote.*` (unchanged). |
+| `org.apache.juneau.ng.rest.client.*` *(9.5 early snapshot only)* |
`org.apache.juneau.rest.client.*` | The NG client and HTTP transport SPI are
now canonical. The legacy `RestClient` (Apache HttpClient 4.5–based) is at
`org.apache.juneau.rest.client.classic.*` in the new module. |
+| `org.apache.juneau.ng.rest.mock.*` *(9.5 early snapshot only)* |
`org.apache.juneau.rest.mock.*` | Canonical, paired with the NG `RestClient`. |
+
+### Class renames (early-snapshot only)
+
+If you adopted the 9.5 early snapshots that exposed `Ng*` class names, update
to the canonical names. No alias / deprecation shim is provided.
+
+| Old | New | Notes |
+|-----|-----|-------|
+| `NgRestClient` / `NgRestClient.Builder` | `RestClient` /
`RestClient.Builder` (in `org.apache.juneau.rest.client`) | Canonical name. |
+| `NgRestRequest` / `NgRestResponse` | `RestRequest` / `RestResponse` (in
`org.apache.juneau.rest.client`) | Canonical name. |
+| `NgMockRestClient` | `MockRestClient` (in `org.apache.juneau.rest.mock`) |
Canonical name for the NG mock client. The legacy mock client is at
`org.apache.juneau.rest.mock.classic.MockRestClient`. |
+| `import org.apache.juneau.ng.http.*;` | `import org.apache.juneau.http.*;` |
Same for any `ng.http.entity.*` / `ng.http.header.*` / `ng.http.part.*` /
`ng.http.resource.*` / `ng.http.response.*` sub-package. |
+
+### Mock client layout
+
+| Old (single-flavor) | New (split) | Notes |
+|-----|-----|-------|
+| `org.apache.juneau.rest.mock.MockRestClient` *(legacy)* |
`org.apache.juneau.rest.mock.classic.MockRestClient` | Apache HttpClient
4.5–based mock client. Still extends the classic `RestClient` and implements
`HttpClientConnection`. Same fluent surface — only the import changes. |
+| n/a | `org.apache.juneau.rest.mock.MockRestClient` *(new, NG)* |
Transport-agnostic mock client paired with the canonical `RestClient`. Wires
`MockHttpTransport` into a `RestContext`. |
+| `org.apache.juneau.rest.mock.MockRestRequest` / `MockRestResponse` |
`org.apache.juneau.rest.mock.classic.MockRestRequest` / `MockRestResponse` |
Subclasses of the classic `RestRequest` / `RestResponse`. The NG client uses
`org.apache.juneau.rest.client.RestRequest` / `RestResponse` directly — there
are no `Mock*` subclasses on the NG side. |
+| `MockServletRequest` / `MockServletResponse` / `MockHttpSession` /
`MockPathResolver` | `org.apache.juneau.rest.mock.MockServletRequest` /
`…MockServletResponse` / `…MockHttpSession` / `…MockPathResolver` | Shared by
both mock-client flavors. Unchanged location.
`MockServletRequest.debug(boolean)` and `MockServletResponse.getHeaders()` and
`MockPathResolver` were widened from package-private to public so the classic
mock client can reach them across the new package boundary; no source [...]
+| `MockConsole` / `MockLogger` |
`org.apache.juneau.rest.mock.classic.MockConsole` / `MockLogger` | Classic-only
logger helpers. |
+
+### `juneau-rest-common` package renames
+
+The package promotion changes the canonical imports for every
`juneau-rest-common` consumer:
+
+```diff
+-import org.apache.juneau.http.*; // pre-9.5: HC4.5 facade types
+-import org.apache.juneau.http.entity.*; // pre-9.5: SerializedHttpEntity,
BasicHttpEntity, ...
+-import org.apache.juneau.http.header.*; // pre-9.5: BasicHeader,
BasicMediaTypeHeader, Authorization, ...
+-import org.apache.juneau.http.part.*; // pre-9.5: BasicPart, PartList,
...
+-import org.apache.juneau.http.resource.*; // pre-9.5: BasicResource,
ByteArrayResource, ...
+-import org.apache.juneau.http.response.*; // pre-9.5: Ok, Created,
NotFound, BasicHttpException, ...
++import org.apache.juneau.http.classic.*;
++import org.apache.juneau.http.classic.entity.*;
++import org.apache.juneau.http.classic.header.*;
++import org.apache.juneau.http.classic.part.*;
++import org.apache.juneau.http.classic.resource.*;
++import org.apache.juneau.http.classic.response.*;
+```
+
+The new canonical `org.apache.juneau.http.*` (and sub-packages `entity` /
`header` / `part` / `response`) host the JDK-native NG types. The
`org.apache.juneau.http.remote.*` annotation package (`@Remote`, `@RemoteGet`,
etc.) **did not move**.
+
<!-- Additional rows will be populated as 9.5 breaking changes land. See
todo/TODO-17 for the
ongoing 9.5.0 audit. -->
