This is an automated email from the ASF dual-hosted git repository.
jamesbognar pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/juneau.git
The following commit(s) were added to refs/heads/master by this push:
new 42f217c Context API refactoring.
42f217c is described below
commit 42f217c94ea8a7a6c75f4aac98d6b2a7b8b522d8
Author: JamesBognar <[email protected]>
AuthorDate: Sat Sep 11 20:02:33 2021 -0400
Context API refactoring.
---
.../src/main/java/org/apache/juneau/Value.java | 1 -
.../org/apache/juneau/rest/ResponseProcessor.java | 3 +-
.../apache/juneau/rest/ResponseProcessorList.java | 49 +++-
.../java/org/apache/juneau/rest/RestContext.java | 65 +----
.../org/apache/juneau/rest/RestContextBuilder.java | 303 +++++++++++++--------
.../java/org/apache/juneau/rest/RestResponse.java | 2 +-
.../org/apache/juneau/rest/annotation/Rest.java | 2 +-
.../juneau/rest/annotation/RestAnnotation.java | 2 +-
8 files changed, 234 insertions(+), 193 deletions(-)
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/Value.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/Value.java
index 21a645f..f55e57d 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/Value.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/Value.java
@@ -194,5 +194,4 @@ public class Value<T> {
(t instanceof ParameterizedType &&
((ParameterizedType)t).getRawType() == Value.class)
|| (t instanceof Class &&
Value.class.isAssignableFrom((Class<?>)t));
}
-
}
diff --git
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/ResponseProcessor.java
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/ResponseProcessor.java
index ccf3011..29f135c 100644
---
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/ResponseProcessor.java
+++
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/ResponseProcessor.java
@@ -30,8 +30,7 @@ import org.apache.juneau.rest.annotation.*;
* Response processors can be associated with REST resources via the following:
* <ul>
* <li class='ja'>{@link Rest#responseProcessors}
- * <li class='jm'>{@link RestContextBuilder#responseProcessors(Class...)}
- * <li class='jm'>{@link
RestContextBuilder#responseProcessors(ResponseProcessor...)}
+ * <li class='jm'>{@link RestContextBuilder#responseProcessors()}
* </ul>
*
* <p>
diff --git
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/ResponseProcessorList.java
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/ResponseProcessorList.java
index a09c353..80d0c4c 100644
---
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/ResponseProcessorList.java
+++
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/ResponseProcessorList.java
@@ -13,6 +13,9 @@
package org.apache.juneau.rest;
import static org.apache.juneau.assertions.Assertions.*;
+
+import java.util.*;
+
import static java.util.Arrays.*;
import org.apache.juneau.*;
@@ -54,22 +57,34 @@ public class ResponseProcessorList {
*/
public static class Builder {
- AList<Object> entries;
- BeanStore beanStore;
+ List<Object> entries;
+ ResponseProcessorList impl;
+ BeanStore beanStore = BeanStore.INSTANCE;
/**
- * Create an empty builder.
+ * Constructor.
*/
protected Builder() {
this.entries = AList.create();
}
/**
+ * Copy constructor.
+ *
+ * @param copyFrom The builder to copy.
+ */
+ protected Builder(Builder copyFrom) {
+ this.entries = AList.create().append(copyFrom.entries);
+ }
+
+ /**
* Creates a new {@link ResponseProcessorList} object using a
snapshot of the settings defined in this builder.
*
* @return A new {@link ResponseProcessorList} object.
*/
public ResponseProcessorList build() {
+ if (impl != null)
+ return impl;
return new ResponseProcessorList(this);
}
@@ -77,7 +92,7 @@ public class ResponseProcessorList {
* Appends the specified rest response processor classes to the
list.
*
* @param values The values to add.
- * @return This object (for method chaining).
+ * @return This object.
* @throws IllegalArgumentException if any class does not
extend from {@link ResponseProcessor}.
*/
public Builder add(Class<?>...values) {
@@ -89,9 +104,9 @@ public class ResponseProcessorList {
* Appends the specified rest response processor objects to the
list.
*
* @param values The values to add.
- * @return This object (for method chaining).
+ * @return This object.
*/
- public Builder append(ResponseProcessor...values) {
+ public Builder add(ResponseProcessor...values) {
entries.addAll(asList(values));
return this;
}
@@ -100,12 +115,32 @@ public class ResponseProcessorList {
* Specifies the bean store to use for instantiating rest
response processor classes.
*
* @param value The bean store to use for instantiating rest
response processor classes.
- * @return This object (for method chaining).
+ * @return This object.
*/
public Builder beanStore(BeanStore value) {
beanStore = value;
return this;
}
+
+ /**
+ * Specifies a pre-instantiated bean to return from {@link
#build()}.
+ *
+ * @param value The value for this setting.
+ * @return This object.
+ */
+ public Builder impl(ResponseProcessorList value) {
+ this.impl = value;
+ return this;
+ }
+
+ /**
+ * Creates a copy of this builder.
+ *
+ * @return A copy of this builder.
+ */
+ public Builder copy() {
+ return new Builder(this);
+ }
}
private static ResponseProcessor instantiate(Object o, BeanStore bs) {
diff --git
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContext.java
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContext.java
index 39f8200..4699829 100644
---
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContext.java
+++
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContext.java
@@ -247,32 +247,24 @@ public class RestContext extends Context {
parentContext = builder.parentContext;
rootBeanStore = builder.beanStore();
- beanStore = rootBeanStore.copy().build();
+ BeanStore bs = beanStore = rootBeanStore.copy().build();
beanStore
.addBean(BeanStore.class, beanStore)
.addBean(RestContext.class, this)
.addBean(Object.class, resource.get())
.addBean(RestContextBuilder.class, builder)
.addBean(AnnotationWorkList.class,
builder.getApplied());
- BeanStore bs = beanStore;
logger = bs.add(Logger.class, builder.logger());
thrownStore = bs.add(ThrownStore.class,
builder.thrownStore().build());
methodExecStore = bs.add(MethodExecStore.class,
builder.methodExecStore().thrownStoreOnce(thrownStore).build());
messages = bs.add(Messages.class,
builder.messages().build());
+ varResolver = bs.add(VarResolver.class,
builder.varResolver().bean(Messages.class, messages).build());
+ config = bs.add(Config.class,
builder.config().resolving(varResolver.createSession()));
+ responseProcessors = bs.add(ResponseProcessor[].class,
builder.responseProcessors().build().toArray());
Object r = resource.get();
- VarResolver vr = varResolver = builder
- .varResolver()
- .bean(Messages.class, messages)
- .build();
- bs.addBean(VarResolver.class, vr);
-
- config = bs.add(Config.class,
builder.config().resolving(vr.createSession()));
-
- responseProcessors = createResponseProcessors(r,
builder, bs).toArray();
-
callLoggerDefault = builder.callLoggerDefault;
debugDefault = builder.debugDefault;
@@ -358,7 +350,7 @@ public class RestContext extends Context {
restChildren = createRestChildren(r, builder, bs,
builder.inner);
- swaggerProvider = createSwaggerProvider(r, builder, bs,
fileFinder, messages, vr);
+ swaggerProvider = createSwaggerProvider(r, builder, bs,
fileFinder, messages, varResolver);
} catch (BasicHttpException e) {
_initException = e;
@@ -775,53 +767,6 @@ public class RestContext extends Context {
}
/**
- * Instantiates the response handlers for this REST resource.
- *
- * <p>
- * Instantiates based on the following logic:
- * <ul>
- * <li>Looks for response processors set via any of the following:
- * <ul>
- * <li>{@link
RestContextBuilder#responseProcessors(Class...)}/{@link
RestContextBuilder#responseProcessors(ResponseProcessor...)}
- * <li>{@link Rest#responseProcessors()}.
- * </ul>
- * <li>Looks for a static or non-static
<c>createResponseProcessors()</> method that returns <c>{@link
ResponseProcessor}[]</c> on the
- * resource class with any of the following arguments:
- * <ul>
- * <li>{@link RestContext}
- * <li>{@link BeanStore}
- * <li>Any {@doc RestInjection injected beans}.
- * </ul>
- * <li>Resolves it via the bean store registered in this context.
- * <li>Instantiates a <c>ResponseProcessor[0]</c>.
- * </ul>
- *
- * @param resource
- * The REST servlet or bean that this context defines.
- * @param builder
- * The builder for this object.
- * @param beanStore
- * The factory used for creating beans and retrieving injected
beans.
- * <br>Created by {@link RestContextBuilder#beanStore()}.
- * @return The response handlers for this REST resource.
- * @throws Exception If response handlers could not be instantiated.
- */
- protected ResponseProcessorList createResponseProcessors(Object
resource, RestContextBuilder builder, BeanStore beanStore) throws Exception {
-
- ResponseProcessorList.Builder x =
builder.responseProcessors.beanStore(beanStore);
-
- x = BeanStore
- .of(beanStore, resource)
- .addBean(ResponseProcessorList.Builder.class, x)
-
.beanCreateMethodFinder(ResponseProcessorList.Builder.class, resource)
- .find("createResponseProcessors")
- .withDefault(x)
- .run();
-
- return x.build();
- }
-
- /**
* Instantiates the HTTP part serializer for this REST resource.
*
* <p>
diff --git
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContextBuilder.java
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContextBuilder.java
index 7b636ee..b0518bc 100644
---
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContextBuilder.java
+++
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContextBuilder.java
@@ -126,6 +126,7 @@ public class RestContextBuilder extends ContextBuilder
implements ServletConfig
private ThrownStore.Builder thrownStore;
private MethodExecStore.Builder methodExecStore;
private Messages.Builder messages;
+ private ResponseProcessorList.Builder responseProcessors;
String
allowedHeaderParams = env("RestContext.allowedHeaderParams",
"Accept,Content-Type"),
@@ -167,17 +168,6 @@ public class RestContextBuilder extends ContextBuilder
implements ServletConfig
Enablement debugDefault, debug;
- ResponseProcessorList.Builder responseProcessors =
ResponseProcessorList.create().add(
- ReaderProcessor.class,
- InputStreamProcessor.class,
- ThrowableProcessor.class,
- HttpResponseProcessor.class,
- HttpResourceProcessor.class,
- HttpEntityProcessor.class,
- ResponseBeanProcessor.class,
- PlainTextPojoProcessor.class,
- SerializedPojoProcessor.class
- );
List<Object> children = new ArrayList<>();
@@ -315,6 +305,7 @@ public class RestContextBuilder extends ContextBuilder
implements ServletConfig
runInitHooks(bs, resource());
logger();
messages();
+ responseProcessors();
VarResolverSession vrs = varResolver().build().createSession();
AnnotationWorkList al =
rci.getAnnotationList(ContextApplyFilter.INSTANCE).getWork(vrs);
@@ -1087,6 +1078,187 @@ public class RestContextBuilder extends ContextBuilder
implements ServletConfig
return v.get();
}
+ /**
+ * Returns the builder for the {@link ResponseProcessorList} object in
the REST context.
+ *
+ * <p>
+ * Specifies a list of {@link ResponseProcessor} classes that know how
to convert POJOs returned by REST methods or
+ * set via {@link RestResponse#setOutput(Object)} into appropriate HTTP
responses.
+ *
+ * <p>
+ * By default, the following response handlers are provided in the
specified order:
+ * <ul>
+ * <li class='jc'>{@link ReaderProcessor}
+ * <li class='jc'>{@link InputStreamProcessor}
+ * <li class='jc'>{@link ThrowableProcessor}
+ * <li class='jc'>{@link HttpResponseProcessor}
+ * <li class='jc'>{@link HttpResourceProcessor}
+ * <li class='jc'>{@link HttpEntityProcessor}
+ * <li class='jc'>{@link ResponseBeanProcessor}
+ * <li class='jc'>{@link PlainTextPojoProcessor}
+ * <li class='jc'>{@link SerializedPojoProcessor}
+ * </ul>
+ *
+ * <h5 class='section'>Example:</h5>
+ * <p class='bcode w800'>
+ * <jc>// Our custom response processor for Foo objects. </jc>
+ * <jk>public class</jk> MyResponseProcessor <jk>implements</jk>
ResponseProcessor {
+ *
+ * <ja>@Override</ja>
+ * <jk>public int</jk> process(RestCall <jv>call</jv>)
<jk>throws</jk> IOException {
+ *
+ * RestResponse <jv>res</jv> =
<jv>call</jv>.getRestResponse();
+ * Foo <jv>foo</jv> =
<jv>res</jv>.getOutput(Foo.<jk>class</jk>);
+ *
+ * <jk>if</jk> (<jv>foo</jv> ==
<jk>null</jk>)
+ * <jk>return</jk>
<jsf>NEXT</jsf>; <jc>// Let the next processor handle it.</jc>
+ *
+ * <jk>try</jk> (Writer <jv>w</jv> =
<jv>res</jv>.getNegotiatedWriter()) {
+ * <jc>//Pipe it to the writer
ourselves.</jc>
+ * }
+ *
+ * <jk>return</jk> <jsf>FINISHED</jsf>;
<jc>// We handled it.</jc>
+ * }
+ * }
+ * }
+ *
+ * <jc>// Option #1 - Defined via annotation.</jc>
+ *
<ja>@Rest</ja>(responseProcessors=MyResponseProcessor.<jk>class</jk>)
+ * <jk>public class</jk> MyResource {
+ *
+ * <jc>// Option #2 - Defined via builder passed in
through resource constructor.</jc>
+ * <jk>public</jk> MyResource(RestContextBuilder
<jv>builder</jv>) <jk>throws</jk> Exception {
+ *
+ * <jc>// Using method on builder.</jc>
+ *
<jv>builder</jv>.responseProcessors(MyResponseProcessor.<jk>class</jk>);
+ * }
+ *
+ * <jc>// Option #3 - Defined via builder passed in
through init method.</jc>
+ * <ja>@RestHook</ja>(<jsf>INIT</jsf>)
+ * <jk>public void</jk> init(RestContextBuilder
<jv>builder</jv>) <jk>throws</jk> Exception {
+ *
<jv>builder</jv>.responseProcessors(MyResponseProcessors.<jk>class</jk>);
+ * }
+ *
+ * <ja>@RestGet</ja>(...)
+ * <jk>public</jk> Object myMethod() {
+ * <jc>// Return a special object for our
handler.</jc>
+ * <jk>return new</jk> MySpecialObject();
+ * }
+ * }
+ * </p>
+ *
+ * <ul class='notes'>
+ * <li>
+ * Response processors are always inherited from ascendant
resources.
+ * <li>
+ * When defined as a class, the implementation must have
one of the following constructors:
+ * <ul>
+ * <li><code><jk>public</jk> T(RestContext)</code>
+ * <li><code><jk>public</jk> T()</code>
+ * <li><code><jk>public static</jk> T
<jsm>create</jsm>(RestContext)</code>
+ * <li><code><jk>public static</jk> T
<jsm>create</jsm>()</code>
+ * </ul>
+ * <li>
+ * Inner classes of the REST resource class are allowed.
+ * </ul>
+ *
+ * @return The builder for the {@link ResponseProcessorList} object in
the REST context.
+ */
+ public final ResponseProcessorList.Builder responseProcessors() {
+ if (responseProcessors == null)
+ responseProcessors =
createResponseProcessors(beanStore(), resource());
+ return responseProcessors;
+ }
+
+ /**
+ * Sets the builder for the {@link ResponseProcessorList} object in the
REST context.
+ *
+ * @param value The builder for the {@link ResponseProcessorList}
object in the REST context.
+ * @return This object.
+ * @throws RuntimeException If {@link #init(Object)} has not been
called.
+ */
+ public final RestContextBuilder
responseProcessors(ResponseProcessorList value) {
+ responseProcessors().impl(value);
+ return this;
+ }
+
+ /**
+ * Instantiates the response handlers for this REST resource.
+ *
+ * <p>
+ * Instantiates based on the following logic:
+ * <ul>
+ * <li>Looks for response processors set via any of the following:
+ * <ul>
+ * <li>{@link
RestContextBuilder#responseProcessors()}
+ * <li>{@link Rest#responseProcessors()}.
+ * </ul>
+ * <li>Looks for a static or non-static
<c>createResponseProcessors()</> method that returns <c>{@link
ResponseProcessor}[]</c> on the
+ * resource class with any of the following arguments:
+ * <ul>
+ * <li>{@link RestContext}
+ * <li>{@link BeanStore}
+ * <li>Any {@doc RestInjection injected beans}.
+ * </ul>
+ * <li>Resolves it via the bean store registered in this context.
+ * <li>Instantiates a <c>ResponseProcessor[0]</c>.
+ * </ul>
+ *
+ * @param beanStore
+ * The factory used for creating beans and retrieving injected
beans.
+ * @param resource
+ * The REST servlet or bean that this context defines.
+ * @return The response handler builder for this REST resource.
+ */
+ protected ResponseProcessorList.Builder
createResponseProcessors(BeanStore beanStore, Supplier<?> resource) {
+
+ Value<ResponseProcessorList.Builder> v = Value.empty();
+ Object r = resource.get();
+
+ beanStore.getBean(ResponseProcessorList.Builder.class).map(x ->
x.copy()).ifPresent(x -> v.set(x));
+
+ if (v.isEmpty()) {
+ v.set(
+ ResponseProcessorList
+ .create()
+ .beanStore(beanStore)
+ .add(
+ ReaderProcessor.class,
+ InputStreamProcessor.class,
+ ThrowableProcessor.class,
+ HttpResponseProcessor.class,
+ HttpResourceProcessor.class,
+ HttpEntityProcessor.class,
+ ResponseBeanProcessor.class,
+ PlainTextPojoProcessor.class,
+ SerializedPojoProcessor.class
+ )
+ );
+ }
+
+ BeanStore
+ .of(beanStore, r)
+ .addBean(ResponseProcessorList.Builder.class, v.get())
+
.beanCreateMethodFinder(ResponseProcessorList.Builder.class, resource)
+ .find("createResponseProcessors")
+ .execute()
+ .ifPresent(x -> v.set(x));
+
+ beanStore.getBean(ResponseProcessorList.class).ifPresent(x ->
v.get().impl(x));
+
+ BeanStore
+ .of(beanStore, r)
+ .addBean(ResponseProcessorList.Builder.class, v.get())
+ .beanCreateMethodFinder(ResponseProcessorList.class,
resource)
+ .find("createResponseProcessors")
+ .execute()
+ .ifPresent(x -> v.get().impl(x));
+
+ return v.get();
+ }
+
+
+
//----------------------------------------------------------------------------------------------------
// Methods that give access to the config file, var resolver, and
properties.
//----------------------------------------------------------------------------------------------------
@@ -2463,115 +2635,6 @@ public class RestContextBuilder extends ContextBuilder
implements ServletConfig
}
/**
- * Response processors.
- *
- * <p>
- * Specifies a list of {@link ResponseProcessor} classes that know how
to convert POJOs returned by REST methods or
- * set via {@link RestResponse#setOutput(Object)} into appropriate HTTP
responses.
- *
- * <p>
- * By default, the following response handlers are provided in the
specified order:
- * <ul>
- * <li class='jc'>{@link ReaderProcessor}
- * <li class='jc'>{@link InputStreamProcessor}
- * <li class='jc'>{@link ThrowableProcessor}
- * <li class='jc'>{@link HttpResponseProcessor}
- * <li class='jc'>{@link HttpResourceProcessor}
- * <li class='jc'>{@link HttpEntityProcessor}
- * <li class='jc'>{@link ResponseBeanProcessor}
- * <li class='jc'>{@link PlainTextPojoProcessor}
- * <li class='jc'>{@link SerializedPojoProcessor}
- * </ul>
- *
- * <h5 class='section'>Example:</h5>
- * <p class='bcode w800'>
- * <jc>// Our custom response processor for Foo objects. </jc>
- * <jk>public class</jk> MyResponseProcessor <jk>implements</jk>
ResponseProcessor {
- *
- * <ja>@Override</ja>
- * <jk>public int</jk> process(RestCall <jv>call</jv>)
<jk>throws</jk> IOException {
- *
- * RestResponse <jv>res</jv> =
<jv>call</jv>.getRestResponse();
- * Foo <jv>foo</jv> =
<jv>res</jv>.getOutput(Foo.<jk>class</jk>);
- *
- * <jk>if</jk> (<jv>foo</jv> ==
<jk>null</jk>)
- * <jk>return</jk>
<jsf>NEXT</jsf>; <jc>// Let the next processor handle it.</jc>
- *
- * <jk>try</jk> (Writer <jv>w</jv> =
<jv>res</jv>.getNegotiatedWriter()) {
- * <jc>//Pipe it to the writer
ourselves.</jc>
- * }
- *
- * <jk>return</jk> <jsf>FINISHED</jsf>;
<jc>// We handled it.</jc>
- * }
- * }
- * }
- *
- * <jc>// Option #1 - Defined via annotation.</jc>
- *
<ja>@Rest</ja>(responseProcessors=MyResponseProcessor.<jk>class</jk>)
- * <jk>public class</jk> MyResource {
- *
- * <jc>// Option #2 - Defined via builder passed in
through resource constructor.</jc>
- * <jk>public</jk> MyResource(RestContextBuilder
<jv>builder</jv>) <jk>throws</jk> Exception {
- *
- * <jc>// Using method on builder.</jc>
- *
<jv>builder</jv>.responseProcessors(MyResponseProcessor.<jk>class</jk>);
- * }
- *
- * <jc>// Option #3 - Defined via builder passed in
through init method.</jc>
- * <ja>@RestHook</ja>(<jsf>INIT</jsf>)
- * <jk>public void</jk> init(RestContextBuilder
<jv>builder</jv>) <jk>throws</jk> Exception {
- *
<jv>builder</jv>.responseProcessors(MyResponseProcessors.<jk>class</jk>);
- * }
- *
- * <ja>@RestGet</ja>(...)
- * <jk>public</jk> Object myMethod() {
- * <jc>// Return a special object for our
handler.</jc>
- * <jk>return new</jk> MySpecialObject();
- * }
- * }
- * </p>
- *
- * <ul class='notes'>
- * <li>
- * Response processors are always inherited from ascendant
resources.
- * <li>
- * When defined as a class, the implementation must have
one of the following constructors:
- * <ul>
- * <li><code><jk>public</jk> T(RestContext)</code>
- * <li><code><jk>public</jk> T()</code>
- * <li><code><jk>public static</jk> T
<jsm>create</jsm>(RestContext)</code>
- * <li><code><jk>public static</jk> T
<jsm>create</jsm>()</code>
- * </ul>
- * <li>
- * Inner classes of the REST resource class are allowed.
- * </ul>
- *
- * @param values The values to add to this setting.
- * @return This object (for method chaining).
- * @throws IllegalArgumentException if any class does not extend from
{@link ResponseProcessor}.
- */
- @FluentSetter
- public RestContextBuilder responseProcessors(Class<?>...values) {
- responseProcessors.add(assertClassArrayArgIsType("values",
ResponseProcessor.class, values));
- return this;
- }
-
- /**
- * Response processors.
- *
- * <p>
- * Same as {@link #responseProcessors(Class...)} except input is
pre-constructed instances.
- *
- * @param values The values to add to this setting.
- * @return This object (for method chaining).
- */
- @FluentSetter
- public RestContextBuilder
responseProcessors(ResponseProcessor...values) {
- responseProcessors.append(values);
- return this;
- }
-
- /**
* REST children class.
*
* <p>
diff --git
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestResponse.java
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestResponse.java
index ac4c0f6..4fca843 100644
---
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestResponse.java
+++
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestResponse.java
@@ -172,7 +172,7 @@ public final class RestResponse {
* </ul>
*
* <ul class='seealso'>
- * <li class='jm'>{@link
RestContextBuilder#responseProcessors(Class...)}
+ * <li class='jm'>{@link RestContextBuilder#responseProcessors()}
* <li class='link'>{@doc RestmReturnTypes}
* </ul>
*
diff --git
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/Rest.java
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/Rest.java
index 6751339..4765ad2 100644
---
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/Rest.java
+++
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/Rest.java
@@ -1012,7 +1012,7 @@ public @interface Rest {
* set via {@link RestResponse#setOutput(Object)} into appropriate HTTP
responses.
*
* <ul class='seealso'>
- * <li class='jm'>{@link
RestContextBuilder#responseProcessors(Class...)}
+ * <li class='jm'>{@link RestContextBuilder#responseProcessors()}
* </ul>
*/
Class<? extends ResponseProcessor>[] responseProcessors() default {};
diff --git
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/RestAnnotation.java
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/RestAnnotation.java
index 18f9373..55157e4 100644
---
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/RestAnnotation.java
+++
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/annotation/RestAnnotation.java
@@ -1058,7 +1058,7 @@ public class RestAnnotation {
strings(a.defaultResponseHeaders()).map(x ->
stringHeader(x)).forEach(x -> b.defaultResponseHeaders(x));
string(a.defaultAccept()).map(x ->
accept(x)).ifPresent(x -> b.defaultRequestHeaders(x));
string(a.defaultContentType()).map(x ->
contentType(x)).ifPresent(x -> b.defaultRequestHeaders(x));
- b.responseProcessors(a.responseProcessors());
+ b.responseProcessors().add(a.responseProcessors());
b.children((Object[])a.children());
b.restOpArgs(a.restOpArgs());
classes(a.encoders()).ifPresent(x ->
b.getEncoders().add(x));
