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 a40ccdb403 docs: typed-handler View return docs for all four view
modules (TODO-97/107/108/109)
a40ccdb403 is described below
commit a40ccdb403d6ee10e7c32e9594b252fd28b4f0e9
Author: James Bognar <[email protected]>
AuthorDate: Wed May 27 13:22:42 2026 -0400
docs: typed-handler View return docs for all four view modules
(TODO-97/107/108/109)
Co-authored-by: Cursor <[email protected]>
---
pages/release-notes/9.5.0.md | 49 +++++++++++++++++++++++++++-
pages/topics/10.14d.JspViewSupport.md | 30 +++++++++++++++--
pages/topics/10.14e.ThymeleafViewSupport.md | 25 ++++++++++++--
pages/topics/10.14f.MustacheViewSupport.md | 25 ++++++++++++--
pages/topics/10.14g.FreemarkerViewSupport.md | 25 ++++++++++++--
5 files changed, 145 insertions(+), 9 deletions(-)
diff --git a/pages/release-notes/9.5.0.md b/pages/release-notes/9.5.0.md
index d890634825..8b3e5592c8 100644
--- a/pages/release-notes/9.5.0.md
+++ b/pages/release-notes/9.5.0.md
@@ -2261,7 +2261,8 @@ public class AppResource extends RestServlet {
```
This is the foundational fix that unblocks the typed-handler View-return path
for all four
-view modules (TODO-97 / TODO-107 / TODO-108 / TODO-109).
+view modules — the per-engine typed-handler integration test matrices landed
alongside
+this change (see the `juneau-rest-server-view-*` entries below).
#### Framework-internal `@Value` adoption (TODO-92)
@@ -4226,6 +4227,26 @@ public class AppResource extends RestServlet {
}
```
+#### Typed-handler View-return integration (`JspView_TypedHandler_Test`)
+
+`@RestGet` methods returning `JspView` now reach `JspViewRenderer` rather than
being
+bean-serialized, thanks to the `ResponseProcessorList` partition pass. To use
`JspView`
+from a host class without the mixin, add `JspViewRenderer.class` to the host's
+`responseProcessors`:
+
+```java
+@Rest(responseProcessors={JspViewRenderer.class})
+public class AppResource extends BasicRestServlet {
+ @RestGet("/hello/{name}")
+ public View hello(@Path String name) {
+ return JspView.of("hello.jsp").attr("name", name);
+ }
+}
+```
+
+Full JSP rendering requires a real servlet container; the MockRest test
verifies that the
+renderer is reached and the response body is not a bean-JSON dump of `JspView`.
+
See [JSP View Support](/docs/topics/JspViewSupport) for the full topic —
engine-selection matrix, Spring Boot fat-jar caveats, and known limitations.
### juneau-rest-server-view-thymeleaf (new module)
@@ -4282,6 +4303,14 @@ public class AppResource extends RestServlet {
}
```
+#### Typed-handler View-return integration (`ThymeleafView_TypedHandler_Test`)
+
+`@RestGet` methods returning `ThymeleafView` now reach `ThymeleafViewRenderer`
rather than
+being bean-serialized. Because Thymeleaf renders directly to a `Writer` with
no
+servlet-container dependency, attribute interpolation (`th:text="${name}"` →
`"Alice"`) is
+fully assertable under MockRest. Add `ThymeleafViewRenderer.class` to the
host's
+`responseProcessors` to use `ThymeleafView` without the mixin.
+
See [Thymeleaf View Support](/docs/topics/ThymeleafViewSupport) for the full
topic — engine-selection matrix, Spring Boot integration notes, path-traversal
hardening, and known limitations.
#### Security
@@ -4336,6 +4365,14 @@ public class AppResource extends RestServlet {
}
```
+#### Typed-handler View-return integration (`MustacheView_TypedHandler_Test`)
+
+`@RestGet` methods returning `MustacheView` now reach `MustacheViewRenderer`
rather than
+being bean-serialized. mustache.java renders directly to a `Writer` with no
+servlet-container dependency, so `{{name}}` → `"Alice"` is fully assertable
under MockRest.
+Add `MustacheViewRenderer.class` to the host's `responseProcessors` to use
`MustacheView`
+without the mixin.
+
See [Mustache View Support](/docs/topics/MustacheViewSupport) for the full
topic — engine-selection matrix, Spring Boot integration notes (Spring Boot's
official starter ships `jmustache`, not `mustache.java`), path-traversal
hardening, and known limitations.
### juneau-rest-server-view-freemarker (new module)
@@ -4387,6 +4424,16 @@ public class AppResource extends RestServlet {
}
```
+#### Typed-handler View-return integration (`FreemarkerView_TypedHandler_Test`)
+
+`@RestGet` methods returning `FreemarkerView` now reach
`FreemarkerViewRenderer` rather than
+being bean-serialized. FreeMarker renders directly to a `Writer` with no
servlet-container
+dependency, so `${name}` → `"Alice"` is fully assertable under MockRest. Add
+`FreemarkerViewRenderer.class` to the host's `responseProcessors` to use
`FreemarkerView`
+without the mixin. Spring Boot's `spring-boot-starter-freemarker`
autoconfigures a
+`freemarker.template.Configuration` bean that the bridge picks up
automatically via
+`BeanStore.getBean(Configuration.class)` — no additional wiring required.
+
See [FreeMarker View Support](/docs/topics/FreemarkerViewSupport) for the full
topic — engine-selection matrix, Spring Boot integration notes
(`spring-boot-starter-freemarker` autoconfigures a `Configuration` bean the
bridge picks up automatically), `.ftl` vs `.ftlh` auto-escape selection,
template caching, path-traversal hardening, and known limitations.
### juneau-bean-rfc7807 (new module)
diff --git a/pages/topics/10.14d.JspViewSupport.md
b/pages/topics/10.14d.JspViewSupport.md
index c8a9b47af4..c41b31f8a0 100644
--- a/pages/topics/10.14d.JspViewSupport.md
+++ b/pages/topics/10.14d.JspViewSupport.md
@@ -127,6 +127,32 @@ public class AppResource extends RestServlet {
`JspView` return, copies the `name` attribute onto the request, and forwards
to the JSP
engine at `/WEB-INF/views/hello.jsp`.
+### Typed handler integration
+
+To use `JspView` from a host-class `@RestGet` *without* adopting the full
mixin, add
+`JspViewRenderer.class` directly to the host's `responseProcessors`:
+
+```java
+@Rest(responseProcessors={JspViewRenderer.class})
+public class AppResource extends BasicRestServlet {
+ @RestGet("/hello/{name}")
+ public View hello(@Path String name) {
+ return JspView.of("hello.jsp").attr("name", name);
+ }
+}
+```
+
+The `ResponseProcessorList` partition pass (added in 9.5.0) automatically
repositions
+`JspViewRenderer` to run before `SerializedPojoProcessor`, so
`JspView`-returning methods
+reach the renderer rather than being bean-serialized. The complementary
negative case —
+a host *without* the renderer bean-serializes the `JspView` — is verified by
+`JspView_TypedHandler_Test#a05`.
+
+> **JSP note:** Full template rendering (`${name}` substitution) requires a
real servlet
+> container with a JSP engine. Under MockRest the dispatcher is absent so the
renderer
+> reaches a 500; the invariant tested is that the renderer *was reached*
(response body does
+> not contain `"templateName"` as a bean-serialized field).
+
### REST resource — raw-JSP mount
The mixin also installs a default `/jsp/*` mount that forwards raw `.jsp`
requests under
@@ -179,8 +205,8 @@ known constraints that aren't bridge-module bugs but worth
documenting up front:
1. **Servlet-mapping conflicts.** Juneau's `RestServlet` is mapped at `/*`,
which can
intercept `RequestDispatcher.forward(...)` calls intended for the
container's JSP
- servlet. The Spring Boot integration tests for this scenario are tracked as
`TODO-97`
- (real-container integration tests).
+ servlet. Register the JSP servlet at `*.jsp` with higher precedence, or
mount Juneau
+ at a sub-path such as `/api/*`.
**Response-processor ordering** (previously a known limitation, resolved in
9.5.0 by
`TODO-96`): `JspViewRenderer` now implements
diff --git a/pages/topics/10.14e.ThymeleafViewSupport.md
b/pages/topics/10.14e.ThymeleafViewSupport.md
index 3e7e01d678..f1f1c7b176 100644
--- a/pages/topics/10.14e.ThymeleafViewSupport.md
+++ b/pages/topics/10.14e.ThymeleafViewSupport.md
@@ -133,6 +133,27 @@ public class AppResource extends RestServlet {
`ThymeleafView` return, populates a Thymeleaf `Context` from the view's
attributes, and asks
the active `TemplateEngine` to render `/templates/hello.html` directly onto
the response.
+### Typed handler integration
+
+To use `ThymeleafView` from a host-class `@RestGet` *without* adopting the
full mixin, add
+`ThymeleafViewRenderer.class` directly to the host's `responseProcessors`:
+
+```java
+@Rest(responseProcessors={ThymeleafViewRenderer.class})
+public class AppResource extends BasicRestServlet {
+ @RestGet("/hello/{name}")
+ public View hello(@Path String name) {
+ return ThymeleafView.of("templates/hello.html").attr("name", name);
+ }
+}
+```
+
+The `ResponseProcessorList` partition pass (added in 9.5.0) automatically
repositions
+`ThymeleafViewRenderer` to run before `SerializedPojoProcessor`. Because
Thymeleaf renders
+directly to a `Writer` with zero servlet-container dependencies, attribute
interpolation
+works under MockRest — verified end-to-end by
+`ThymeleafView_TypedHandler_Test#a04_renderInterpolatesAttributesFromTypedHandler`.
+
### REST resource — raw-template mount
The mixin also installs a default `/thymeleaf/*` mount that renders raw
`.html` templates
@@ -196,8 +217,8 @@ required.
automatically positioned before `SerializedPojoProcessor` by the
`ResponseProcessorList`
partition pass (TODO-96). A `@RestOp` method returning `ThymeleafView`
reaches the renderer
without any extra configuration — the mixin registers the renderer and the
framework ensures
-ordering. Real-container integration tests under embedded Tomcat / Jetty are
tracked as
-`TODO-107`.
+ordering. MockRest-level typed-handler integration is verified by
+`ThymeleafView_TypedHandler_Test` (attribute interpolation asserted
end-to-end).
## Multiple base paths
diff --git a/pages/topics/10.14f.MustacheViewSupport.md
b/pages/topics/10.14f.MustacheViewSupport.md
index c3ee0b04dc..22b3c4620c 100644
--- a/pages/topics/10.14f.MustacheViewSupport.md
+++ b/pages/topics/10.14f.MustacheViewSupport.md
@@ -134,6 +134,27 @@ public class AppResource extends RestServlet {
`MustacheView` return, hands the view's attributes to the active
`MustacheFactory`, and asks
the compiled `Mustache` to render `/templates/hello.mustache` directly onto
the response.
+### Typed handler integration
+
+To use `MustacheView` from a host-class `@RestGet` *without* adopting the full
mixin, add
+`MustacheViewRenderer.class` directly to the host's `responseProcessors`:
+
+```java
+@Rest(responseProcessors={MustacheViewRenderer.class})
+public class AppResource extends BasicRestServlet {
+ @RestGet("/hello/{name}")
+ public View hello(@Path String name) {
+ return
MustacheView.of("mustache-templates/hello.mustache").attr("name", name);
+ }
+}
+```
+
+The `ResponseProcessorList` partition pass (added in 9.5.0) automatically
repositions
+`MustacheViewRenderer` to run before `SerializedPojoProcessor`. Because
mustache.java
+renders directly to a `Writer` with zero servlet-container dependencies,
attribute
+interpolation (`{{name}}` → `"Alice"`) works under MockRest — verified
end-to-end by
+`MustacheView_TypedHandler_Test#a04_renderInterpolatesAttributesFromTypedHandler`.
+
### REST resource — raw-template mount
The mixin also installs a default `/mustache/*` mount that renders raw
templates under the
@@ -201,8 +222,8 @@ no additional plumbing is required.
automatically positioned before `SerializedPojoProcessor` by the
`ResponseProcessorList`
partition pass (TODO-96). A `@RestOp` method returning `MustacheView` reaches
the renderer
without any extra configuration — the mixin registers the renderer and the
framework ensures
-ordering. Real-container integration tests under embedded Tomcat / Jetty are
tracked as
-`TODO-108`.
+ordering. MockRest-level typed-handler integration is verified by
+`MustacheView_TypedHandler_Test` (attribute interpolation asserted end-to-end).
## Multiple base paths
diff --git a/pages/topics/10.14g.FreemarkerViewSupport.md
b/pages/topics/10.14g.FreemarkerViewSupport.md
index cb7f99bb91..c0a886ebd5 100644
--- a/pages/topics/10.14g.FreemarkerViewSupport.md
+++ b/pages/topics/10.14g.FreemarkerViewSupport.md
@@ -148,6 +148,27 @@ data model, and asks the resolved `Template` to render
`/templates/hello.ftlh` d
the response writer. The `.ftlh` suffix is appended idempotently because the
builder
declared it.
+### Typed handler integration
+
+To use `FreemarkerView` from a host-class `@RestGet` *without* adopting the
full mixin, add
+`FreemarkerViewRenderer.class` directly to the host's `responseProcessors`:
+
+```java
+@Rest(responseProcessors={FreemarkerViewRenderer.class})
+public class AppResource extends BasicRestServlet {
+ @RestGet("/hello/{name}")
+ public View hello(@Path String name) {
+ return
FreemarkerView.of("freemarker-templates/hello.ftlh").attr("name", name);
+ }
+}
+```
+
+The `ResponseProcessorList` partition pass (added in 9.5.0) automatically
repositions
+`FreemarkerViewRenderer` to run before `SerializedPojoProcessor`. Because
FreeMarker renders
+directly to a `Writer` with zero servlet-container dependencies, attribute
interpolation
+(`${name}` → `"Alice"`) works under MockRest — verified end-to-end by
+`FreemarkerView_TypedHandler_Test#a04_renderInterpolatesAttributesFromTypedHandler`.
+
### REST resource — raw-template mount
The mixin also installs a default `/freemarker/*` mount that renders raw
templates under
@@ -236,8 +257,8 @@ is bypassed entirely when the starter is on the classpath.
automatically positioned before `SerializedPojoProcessor` by the
`ResponseProcessorList`
partition pass (TODO-96). A `@RestOp` method returning `FreemarkerView`
reaches the renderer
without any extra configuration — the mixin registers the renderer and the
framework ensures
-ordering. Real-container integration tests under embedded Tomcat / Jetty are
tracked as
-`TODO-109`.
+ordering. MockRest-level typed-handler integration is verified by
+`FreemarkerView_TypedHandler_Test` (attribute interpolation asserted
end-to-end).
## Multiple base paths
